two-way-mapper 0.0.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: bcbb9ddd6ab08af20ca40eec44b53bf3ac2109e9
-  data.tar.gz: 914738db9bb087708fc3603c1297738137d6226e
+SHA256:
+  metadata.gz: 27c5a5f04384aebefba51e9ec085042cdf6d1ca40ff7d82aafba522b3b8eb457
+  data.tar.gz: 52d3d15700603d35a82e12f53c64765c71053644238bbe02cb44e9666934b6f6
 SHA512:
-  metadata.gz: 9aad37686d32b6c02c163addb8d1a99bcdbbb39c5e5e770de7978825c354051872e114f4468c415b61d1574e83f7ef633bdb008c92d4bdd269bafa841cca000c
-  data.tar.gz: 24b29a8195033c489f9314620e5191c5be144c4d6b4bf15fb4280039ac686117569fabefa293d31081095beca0b7508324224006d1239328b7aa9ec8b77adc3e
+  metadata.gz: 7d1319a99792280e03ea43e6b8ecb294cb6da12d443e4b7f4a1211d4ef44515589de48307244330044baa666c4691f4816b7466ac56401ced959321afb263685
+  data.tar.gz: 4e99bb150c889eb4eafcb966ba7f3756cee4d64e63f2ec0b0040f19f2d830e75d1f433234018ca11a7506bb7b35a5962a74cf491b5a0166b3783bf60793f25b1

data/.travis.yml

@@ -5,10 +5,10 @@ notifications:
   email: false
 
 rvm:
- - 1.9.3
- - 2.0.0
- - 2.1.1
- - 2.1.2
+ - 2.3
+ - 2.4
+ - 2.5
+ - 2.6
  - ruby-head
  - jruby
 

data/README.md

@@ -38,7 +38,30 @@ TwoWayMapper.register :customer do |mapping|
 end
 ```
 
-Once mapping is defined we can convert one object to another and vice versa
+For simple rules use
+
+```ruby
+TwoWayMapper.register :customer do |mapping|
+  mapping.left :object # set left plugin to object
+  mapping.right :hash, stringify_keys: true # set right plugin to hash
+
+  mapping.rules(
+    'first_name' => 'FirstName',
+    'last_name' => 'LastName'
+  )
+end
+```
+
+Mapping can be defined explicitly without registration
+
+```ruby
+mapping = TwoWayMapper::Mapping.new
+mapping.left :object
+mapping.right :hash, stringify_keys: true
+# ...
+```
+
+Once the mapping is defined it can be used to convert one object to another and vice versa
 
 ```ruby
 Customer = Struct.new :first_name, :last_name, :gender
@@ -46,7 +69,7 @@ Customer = Struct.new :first_name, :last_name, :gender
 customer = Customer.new
 api_response = { 'FirstName' => 'Evee', 'LastName' => 'Fjord', 'sex' => 'female' }
 
-TwoWayMapper[:customer].from_right_to_left customer, api_response
+TwoWayMapper[:customer].from_right_to_left(customer, api_response)
 puts customer.first_name # => 'Evee'
 puts customer.last_name # => 'Fjord'
 puts customer.gender # => 'F'
@@ -58,17 +81,17 @@ another_customer.first_name = 'Step'
 another_customer.last_name = 'Bander'
 another_customer.gender = 'M'
 
-TwoWayMapper[:customer].from_left_to_right another_customer, request_data
+TwoWayMapper[:customer].from_left_to_right(another_customer, request_data)
 puts request_data # => { 'FirstName' => 'Step', 'LastName' => 'Bander', sex: 'male' }
 ```
 
-On rails, you can put all mappings into `app/mappings` folder
+In rails, mappings can be defined in `app/mappings` folder
 
 ### Available plugins
 
 * hash
 * object
-* active_record (same as object, but for keys like `user.email`, it will try to build `user` before updating `email` on write)
+* active_record (same as `object`, but for keys like `user.email`, it builds `user` before updating `email` on write)
 
 ## Contributing
 

data/lib/two-way-mapper.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'two_way_mapper'

data/lib/two_way_mapper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/dependencies/autoload'
 require 'active_support/core_ext/module/delegation'
 require 'active_support/inflector'

data/lib/two_way_mapper/map.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TwoWayMapper
   class Map
     delegate :[], to: :@maps
@@ -8,7 +10,9 @@ module TwoWayMapper
 
     def register(name)
       mapping = TwoWayMapper::Mapping.new
+
       yield mapping if block_given?
+
       @maps[name.to_sym] = mapping
     end
   end

data/lib/two_way_mapper/mapping.rb

@@ -1,56 +1,82 @@
+# frozen_string_literal: true
+
 module TwoWayMapper
   class Mapping
-    attr_reader :rules, :left_class, :left_options, :right_class, :right_options
+    DIRECTIONS = [:left, :right].freeze
+
+    attr_reader :rules_list, :left_class, :left_options, :right_class, :right_options
 
     def initialize
-      @rules = []
+      @rules_list = []
     end
 
-    [:left, :right].each do |method|
+    [DIRECTIONS, DIRECTIONS.reverse].each do |from, to|
       class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def #{method}(plugin, options = {})
-          @#{method}_class = node_class plugin
-          @#{method}_options = options
+        def #{from}(plugin, options = {})
+          @#{from}_class = node_class(plugin)
+          @#{from}_options = options
         end
-      CODE
-    end
 
-    def node_class(plugin)
-      TwoWayMapper::Node.const_get plugin.to_s.camelize
-    rescue NameError
-      raise NameError, 'Cannot find node'
+        def #{from}_selectors(mappable: false)
+          rules_list.flat_map do |rule|
+            if mappable && rule.from_#{from}_to_#{to}_only?
+              []
+            else
+              rule.#{from}_nodes.map(&:selector)
+            end
+          end
+        end
+
+        def from_#{from}_to_#{to}(left_obj, right_obj)
+          rules_list.each { |rule| rule.from_#{from}_to_#{to}(left_obj, right_obj) }
+          #{to}_obj
+        end
+      CODE
     end
 
-    def rule(left_selector, right_selector = {}, options = {})
-      raise 'You need to set left before calling rule' unless left_class
-      raise 'You need to set right before calling rule' unless right_class
+    def rule(left_selectors, right_selectors = {}, options = {})
+      raise 'left is not defined' unless left_class
+      raise 'right is not defined' unless right_class
 
       opt = options.dup
       left_opt = opt.delete(:left) || {}
       right_opt = opt.delete(:right) || {}
 
-      if left_selector.is_a?(Hash)
-        raise ArgumentError if left_selector.count < 2
-        opt = left_selector
-        left_selector = opt.keys.first
-        left_opt.merge! opt.delete left_selector
-        right_selector = opt.keys.first
-        right_opt.merge! opt.delete right_selector
+      if left_selectors.is_a?(Hash)
+        raise ArgumentError if left_selectors.count < 2
+
+        opt = left_selectors
+        left_selectors = opt.keys.first
+        left_opt.merge! opt.delete(left_selectors)
+        right_selectors = opt.keys.first
+        right_opt.merge!(opt.delete(right_selectors))
       end
 
-      left = left_class.new left_selector, left_options.merge(left_opt)
-      right = right_class.new right_selector, right_options.merge(right_opt)
+      @rules_list << Rule.new(
+        build_nodes(left_selectors, left_class, left_options.merge(left_opt)),
+        build_nodes(right_selectors, right_class, right_options.merge(right_opt)),
+        opt
+      )
+    end
 
-      @rules << Rule.new(left, right, opt)
+    def rules(hash)
+      hash.each do |left_selector, right_selector|
+        rule(left_selector, right_selector)
+      end
     end
 
-    { left: :right, right: :left }.each do |from, to|
-      class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def from_#{from}_to_#{to}(left_obj, right_obj)
-          rules.each { |r| r.from_#{from}_to_#{to} left_obj, right_obj }
-          #{to}_obj
-        end
-      CODE
+    private
+
+    def node_class(plugin)
+      TwoWayMapper::Node.const_get(plugin.to_s.camelize)
+    rescue NameError
+      raise NameError, 'Cannot find node'
+    end
+
+    def build_nodes(selectors, klass, opt)
+      Array(selectors).map do |selector|
+        klass.new(selector, opt)
+      end
     end
   end
 end

data/lib/two_way_mapper/node.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module TwoWayMapper
   module Node
     extend ActiveSupport::Autoload
 
-    autoload :Abstract,     'two_way_mapper/node/abstract'
+    autoload :Base,         'two_way_mapper/node/base'
     autoload :Hash,         'two_way_mapper/node/hash'
     autoload :Object,       'two_way_mapper/node/object'
     autoload :ActiveRecord, 'two_way_mapper/node/active_record'

data/lib/two_way_mapper/node/active_record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TwoWayMapper
   module Node
     class ActiveRecord < Object
@@ -6,7 +8,7 @@ module TwoWayMapper
       end
 
       def create_node(obj, key)
-        obj.send "build_#{key}"
+        obj.send("build_#{key}")
       end
     end
   end

data/lib/two_way_mapper/node/{abstract.rb → base.rb}

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module TwoWayMapper
   module Node
-    class Abstract
+    class Base
       DIVIDER = '.'
 
       attr_accessor :selector, :options
@@ -14,47 +16,48 @@ module TwoWayMapper
           block = options[:stringify_keys] ? :to_s : :to_sym
           block = block.to_proc
         end
-        selector.split(DIVIDER).map &block
+        selector.split(DIVIDER).map(&block)
       end
 
       def read(source)
-        rewind_forward(source) { |obj, key| return nil }
+        rewind_forward(source) { |_obj, _key| return nil }
       end
 
-      def write(obj, value)
+      def write(_obj, _value)
+        raise NotImplementedError
       end
 
       def writable?(current_value, new_value)
         !options[:write_if] ||
-        !options[:write_if].respond_to?(:call) ||
-        options[:write_if].call(current_value, new_value)
+          !options[:write_if].respond_to?(:call) ||
+          options[:write_if].call(current_value, new_value)
       end
 
       private
 
       def rewind_forward(obj, margin = 0)
         to = -(1 + margin.to_i.abs)
+
         keys[0..to].each do |key|
           unless rewind_to?(obj, key)
-            if block_given?
-              yield obj, key
-            else
-              create_node obj, key
-            end
+            block_given? ? yield(obj, key) : create_node(obj, key)
           end
-          obj = next_key obj, key
+          obj = next_key(obj, key)
         end
 
         obj
       end
 
-      def rewind_to?(obj, key)
+      def rewind_to?(_obj, _key)
+        raise NotImplementedError
       end
 
-      def create_node(obj, key)
+      def create_node(_obj, _key)
+        raise NotImplementedError
       end
 
-      def next_key(obj, key)
+      def next_key(_obj, _key)
+        raise NotImplementedError
       end
     end
   end

data/lib/two_way_mapper/node/hash.rb

@@ -1,10 +1,14 @@
+# frozen_string_literal: true
+
 module TwoWayMapper
   module Node
-    class Hash < Abstract
+    class Hash < Base
       def write(source, value)
         rewinded = rewind_forward source, 1
 
-        rewinded[keys.last] = value if writable? rewinded[keys.last], value
+        return unless writable?(rewinded[keys.last], value)
+
+        rewinded[keys.last] = value
       end
 
       private

data/lib/two_way_mapper/node/object.rb

@@ -1,23 +1,27 @@
+# frozen_string_literal: true
+
 module TwoWayMapper
   module Node
-    class Object < Abstract
+    class Object < Base
       def write(source, value)
-        rewinded = rewind_forward source, 1
+        rewinded = rewind_forward(source, 1)
+
+        return unless writable?(rewinded.send(keys.last), value)
 
-        rewinded.send "#{keys.last}=", value if writable? rewinded.send(keys.last), value
+        rewinded.send("#{keys.last}=", value)
       end
 
       private
 
       def rewind_to?(obj, key)
-        obj.respond_to? key
+        obj.respond_to?(key)
       end
 
       def create_node(obj, key)
       end
 
       def next_key(obj, key)
-        obj.send key
+        obj.send(key)
       end
     end
   end

data/lib/two_way_mapper/railtie.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'rails'
 
 module TwoWayMapper
   class Railtie < Rails::Railtie
-    initializer "two_way_mapper.set_load_path" do |app|
+    initializer 'two_way_mapper.set_load_path' do |app|
       path = Rails.root.join('app', 'mappings', '*.rb').to_s
-      Dir[path].each{ |file| load file }
+      Dir[path].each { |file| load file }
     end
   end
 end

data/lib/two_way_mapper/rule.rb

@@ -1,36 +1,72 @@
+# frozen_string_literal: true
+
 module TwoWayMapper
   class Rule
-    attr_reader :left, :right
+    attr_reader :left_nodes, :right_nodes
 
-    def initialize(left, right, opt = {})
-      @left = left
-      @right = right
+    def initialize(left_nodes, right_nodes, opt = {})
+      @left_nodes = left_nodes
+      @right_nodes = right_nodes
       @options = opt
     end
 
-    { left: :right, right: :left }.each do |from, to|
-      class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def from_#{from}_to_#{to}(left_obj, right_obj)
-          value = #{from}.read #{from}_obj
-          value = map_value value, #{(from == :left).inspect}
-          if @options[:on_#{from}_to_#{to}].respond_to? :call
-            value = @options[:on_#{from}_to_#{to}].call value
-          end
-          #{to}.write #{to}_obj, value
+    def from_left_to_right(left_obj, right_obj)
+      return right_obj if from_right_to_left_only?
 
-          #{to}_obj
-        end
-      CODE
+      value = read(left_nodes, [left_obj, right_obj], true)
+
+      write(right_nodes, right_obj, value)
+    end
+
+    def from_right_to_left(left_obj, right_obj)
+      return left_obj if from_left_to_right_only?
+
+      value = read(right_nodes, [left_obj, right_obj], false)
+
+      write(left_nodes, left_obj, value)
+    end
+
+    def from_right_to_left_only?
+      @options[:from_right_to_left_only]
+    end
+
+    def from_left_to_right_only?
+      @options[:from_left_to_right_only]
     end
 
     private
 
-    def map_value(value, left_to_right = true)
+    def read(nodes, objects, left_to_right)
+      callback = left_to_right ? :on_left_to_right : :on_right_to_left
+      obj = left_to_right ? objects.first : objects.last
+      value = nil
+
+      nodes.each do |node|
+        value = node.read(obj)
+        value = map_value(value, left_to_right)
+        if @options[callback].respond_to?(:call)
+          args = [value] + objects + [node]
+          value = @options[callback].call(*args)
+        end
+
+        break if value
+      end
+
+      value
+    end
+
+    def write(nodes, obj, value)
+      nodes.each { |node| node.write(obj, value) }
+
+      obj
+    end
+
+    def map_value(value, left_to_right)
       map = @options[:map]
-      if map && map.is_a?(Hash)
+      if map.is_a?(Hash)
         map = map.invert unless left_to_right
         default_key = "default_#{left_to_right ? 'left' : 'right'}".to_sym
-        value = map[value] || @options[default_key] || @options[:default]
+        map[value] || @options[default_key] || @options[:default]
       else
         value
       end