two-way-mapper 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 524242de8d10dfa77f277974cd5e1670dcc68b0345b371d847a687cce8998c59
-  data.tar.gz: e4b0d1784f91ee600a316c161a8bb97b3bccabd6c2d97a1296dbb82596a93c08
+  metadata.gz: 7b43b700b85546bce3d9c79425c5d82a20e4e63b24df74219296328c83c5f069
+  data.tar.gz: 5582e71aa4fc752c5fcc60709e65a7a58a72c119b529de1973845f768c804075
 SHA512:
-  metadata.gz: ce3eb28e41536134ac6c221b41c7bc0c0fecd01092a8f2f26c7076d4d7249a93c26c1e8103a9644a8418e7d93e8570fd273a4eb96023b52d77f92138cfa81be8
-  data.tar.gz: '09b3e9f0ccf3cc4e9f5ca8d3668b2cd7b253d7c9190f06daceb3afb3f3c0f4d58329d0a12ec394e6675fdd95ec79d1a28c26242037d24b0387193db6957d2c2c'
+  metadata.gz: 9f72fb8bfa5c89f4e810c955552d9fd4eed5d2a4d7bd67cc27f5bed42fe33d50c34447f2bf9f7ab16445385733cc3a5e5e0fa71a722ff621f2ab2e591c691945
+  data.tar.gz: ae220a4dea0fe3e3c836897822ac77d839a12d368bdd80f2f82aa2851fdebf25b057877aa55d6ab1632011f3de5ad7c4f0610e8407c66419103ba2bd2ccee271

data/lib/two_way_mapper/mapping.rb

@@ -18,10 +18,12 @@ module TwoWayMapper
         end
 
         def #{from}_selectors(mappable: false)
-          rules.each_with_object [] do |rule, memo|
-            next if mappable && rule.from_#{from}_to_#{to}_only?
-
-            memo << rule.#{from}.selector
+          rules.flat_map do |rule|
+            if mappable && rule.from_#{from}_to_#{to}_only?
+              []
+            else
+              rule.#{from}_nodes.map(&:selector)
+            end
           end
         end
 
@@ -32,7 +34,7 @@ module TwoWayMapper
       CODE
     end
 
-    def rule(left_selector, right_selector = {}, options = {})
+    def rule(left_selectors, right_selectors = {}, 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
 
@@ -40,20 +42,24 @@ module TwoWayMapper
       left_opt = opt.delete(:left) || {}
       right_opt = opt.delete(:right) || {}
 
-      if left_selector.is_a?(Hash)
-        raise ArgumentError if left_selector.count < 2
+      if left_selectors.is_a?(Hash)
+        raise ArgumentError if left_selectors.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))
+        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))
+      left_nodes = Array(left_selectors).map do |left_selector|
+        left_class.new(left_selector, left_options.merge(left_opt))
+      end
+      right_nodes = Array(right_selectors).map do |right_selector|
+        right_class.new(right_selector, right_options.merge(right_opt))
+      end
 
-      @rules << Rule.new(left, right, opt)
+      @rules << Rule.new(left_nodes, right_nodes, opt)
     end
 
     private

data/lib/two_way_mapper/node/base.rb

@@ -40,11 +40,7 @@ module TwoWayMapper
 
         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)
         end

data/lib/two_way_mapper/rule.rb

@@ -2,38 +2,28 @@
 
 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
 
     def from_left_to_right(left_obj, right_obj)
       return right_obj if from_right_to_left_only?
 
-      value = left.read(left_obj)
-      value = map_value(value, true)
-      if @options[:on_left_to_right].respond_to?(:call)
-        value = @options[:on_left_to_right].call(value, left_obj, right_obj)
-      end
-      right.write(right_obj, value)
+      value = read(left_nodes, [left_obj, right_obj], true)
 
-      right_obj
+      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 = right.read(right_obj)
-      value = map_value(value, false)
-      if @options[:on_right_to_left].respond_to?(:call)
-        value = @options[:on_right_to_left].call(value, left_obj, right_obj)
-      end
-      left.write(left_obj, value)
+      value = read(right_nodes, [left_obj, right_obj], false)
 
-      left_obj
+      write(left_nodes, left_obj, value)
     end
 
     def from_right_to_left_only?
@@ -46,7 +36,32 @@ module TwoWayMapper
 
     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.is_a?(Hash)
         map = map.invert unless left_to_right

data/lib/two_way_mapper/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TwoWayMapper
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 end

data/spec/mapping_spec.rb

@@ -18,30 +18,43 @@ describe TwoWayMapper::Mapping do
     before do
       mapping.left :object
       mapping.right :object
+    end
 
+    before do
       mapping.rule 'firstname', 'FirstName'
       mapping.rule 'fullname',  'FullName', from_right_to_left_only: true
       mapping.rule 'lastname',  'LastName'
       mapping.rule 'fullname1', 'FullName1', from_left_to_right_only: true
+      mapping.rule ['field1', 'field2'], 'Field1'
+      mapping.rule 'field3', ['Field2', 'Field3']
+      mapping.rule ['field4', 'field5'], ['Field4', 'Field5']
     end
 
     describe '#left_selectors' do
       it 'should get left selectors' do
-        expect(mapping.left_selectors).to eql %w(firstname fullname lastname fullname1)
+        expect(mapping.left_selectors).to eql(
+          %w(firstname fullname lastname fullname1 field1 field2 field3 field4 field5)
+        )
       end
 
       it 'should include only mappable selectors if such option is passed' do
-        expect(mapping.left_selectors(mappable: true)).to eql %w(firstname fullname lastname)
+        expect(mapping.left_selectors(mappable: true)).to eql(
+          %w(firstname fullname lastname field1 field2 field3 field4 field5)
+        )
       end
     end
 
     describe '#right_selectors' do
       it 'should get right selectors' do
-        expect(mapping.right_selectors).to eql %w(FirstName FullName LastName FullName1)
+        expect(mapping.right_selectors).to eql(
+          %w(FirstName FullName LastName FullName1 Field1 Field2 Field3 Field4 Field5)
+        )
       end
 
       it 'should include only mappable selectors if such option is passed' do
-        expect(mapping.right_selectors(mappable: true)).to eql %w(FirstName LastName FullName1)
+        expect(mapping.right_selectors(mappable: true)).to eql(
+          %w(FirstName LastName FullName1 Field1 Field2 Field3 Field4 Field5)
+        )
       end
     end
   end
@@ -74,8 +87,21 @@ describe TwoWayMapper::Mapping do
 
       rule = mapping.rules.first
       expect(rule).to be_instance_of TwoWayMapper::Rule
-      expect(rule.left.selector).to eql 'key1'
-      expect(rule.right.selector).to eql 'Key1'
+      expect(rule.left_nodes.map(&:selector)).to eql ['key1']
+      expect(rule.right_nodes.map(&:selector)).to eql ['Key1']
+    end
+
+    it 'should support multiple selectors' do
+      mapping.rule ['key1', 'key2'], ['Key1', 'Key2']
+
+      rule = mapping.rules.first
+
+      expect(rule.left_nodes.size).to eql 2
+      expect(rule.left_nodes[0].selector).to eql 'key1'
+      expect(rule.left_nodes[1].selector).to eql 'key2'
+      expect(rule.right_nodes.size).to eql 2
+      expect(rule.right_nodes[0].selector).to eql 'Key1'
+      expect(rule.right_nodes[1].selector).to eql 'Key2'
     end
 
     it 'should allow to pass hash' do
@@ -84,16 +110,16 @@ describe TwoWayMapper::Mapping do
       mapping.rule 'key1' => { opt1: 'val' }, 'Key2' => {}
       rule = mapping.rules.first
 
-      expect(rule.left.selector).to eql 'key1'
-      expect(rule.right.selector).to eql 'Key2'
+      expect(rule.left_nodes.map(&:selector)).to eql ['key1']
+      expect(rule.right_nodes.map(&:selector)).to eql ['Key2']
     end
 
     it 'should allow to pass left abd right options ' do
       mapping.rule 'key1', 'Key2', left: { opt1: 'val' }, right: { opt2: 'val' }
       rule = mapping.rules.first
 
-      expect(rule.left.options).to include opt1: 'val'
-      expect(rule.right.options).to include opt2: 'val'
+      expect(rule.left_nodes.first.options).to include opt1: 'val'
+      expect(rule.right_nodes.first.options).to include opt2: 'val'
     end
 
     it 'should work with options copy' do

data/spec/rule_spec.rb

@@ -2,16 +2,19 @@
 
 describe TwoWayMapper::Rule do
   let(:left_node) { TwoWayMapper::Node::Object.new('key1') }
+  let(:left_nodes) { [left_node] }
   let(:right_node) { TwoWayMapper::Node::Hash.new('Kk.Key1') }
+  let(:right_nodes) { [right_node] }
   let(:left_object) { OpenStruct.new }
   let(:map) { { 'value' => 'VALUE' } }
-  let(:rule) { described_class.new(left_node, right_node, options) }
+  let(:options) { {} }
+  let(:rule) { described_class.new(left_nodes, right_nodes, options) }
 
   context 'without options' do
     let(:options) { {} }
 
     describe '#from_left_to_right' do
-      it 'should read from left node and write to right node' do
+      it 'should read from the left node and write to the right node' do
         left_object.key1 = 'value1'
         right_object = {}
         rule.from_left_to_right(left_object, right_object)
@@ -21,7 +24,7 @@ describe TwoWayMapper::Rule do
     end
 
     describe '#from_right_to_left' do
-      it 'should read from right node and write to left node' do
+      it 'should read from the right node and write to the left node' do
         left_object.key1 = nil
         right_object = { Kk: { Key1: 'value1' } }
         rule.from_right_to_left(left_object, right_object)
@@ -31,6 +34,32 @@ describe TwoWayMapper::Rule do
     end
   end
 
+  context 'with from_left_to_right_only/from_right_to_left_only options' do
+    describe '#from_left_to_right' do
+      let(:options) { { from_right_to_left_only: true } }
+
+      it 'should do nothing if from_right_to_left_only is set to true' do
+        left_object.key1 = 'value1'
+        right_object = {}
+        rule.from_left_to_right(left_object, right_object)
+
+        expect(right_object).to eql({})
+      end
+    end
+
+    describe '#from_right_to_left' do
+      let(:options) { { from_left_to_right_only: true } }
+
+      it 'should do nothing if from_left_to_right_only is set to true' do
+        left_object.key1 = nil
+        right_object = { Kk: { Key1: 'value1' } }
+        rule.from_right_to_left(left_object, right_object)
+
+        expect(left_object.key1).to be_nil
+      end
+    end
+  end
+
   context 'with map option' do
     let(:options) { { map: map } }
 
@@ -55,10 +84,10 @@ describe TwoWayMapper::Rule do
     end
   end
 
-  context 'with default option' do
+  context 'with map and default option' do
     describe '#from_left_to_right' do
       it 'should return default value if not found' do
-        rule = described_class.new left_node, right_node, map: map, default: 'not found'
+        rule = described_class.new [left_node], [right_node], map: map, default: 'not found'
 
         left_object.key1 = 'value1'
         right_object = {}
@@ -69,8 +98,8 @@ describe TwoWayMapper::Rule do
 
       it 'should return use default_left if present and value not found' do
         rule = described_class.new(
-          left_node,
-          right_node,
+          [left_node],
+          [right_node],
           map: map,
           default: 'not found',
           default_left: 'not found on left',
@@ -87,7 +116,7 @@ describe TwoWayMapper::Rule do
 
     describe '#from_right_to_left' do
       it 'should return default value if not found' do
-        rule = described_class.new left_node, right_node, map: map, default: 'not found'
+        rule = described_class.new [left_node], [right_node], map: map, default: 'not found'
 
         left_object.key1 = nil
         right_object = { Kk: { Key1: 'VALUE1' } }
@@ -98,8 +127,8 @@ describe TwoWayMapper::Rule do
 
       it 'should return use default_right if present and value not found' do
         rule = described_class.new(
-          left_node,
-          right_node,
+          [left_node],
+          [right_node],
           map: map,
           default: 'not found',
           default_left: 'not found on left',
@@ -115,13 +144,13 @@ describe TwoWayMapper::Rule do
     end
   end
 
-  describe 'with callback option' do
-    describe 'on_left_to_right' do
+  context 'with callback option' do
+    describe '#on_left_to_right' do
       it 'should transform value if such options passed' do
         rule = described_class.new(
-          left_node,
-          right_node,
-          on_left_to_right: ->(v, _l, _r) { v.upcase }
+          [left_node],
+          [right_node],
+          on_left_to_right: ->(v, _l, _r, _n) { v.upcase }
         )
 
         left_object.key1 = 'value1'
@@ -133,25 +162,25 @@ describe TwoWayMapper::Rule do
 
       it 'should pass left object and right object' do
         rule = described_class.new(
-          left_node,
-          right_node,
-          on_left_to_right: ->(_v, l, r) { "#{l.object_id}-#{r.object_id}" }
+          [left_node],
+          [right_node],
+          on_left_to_right: ->(_v, l, r, n) { "#{l.object_id}-#{r.object_id}-#{n.selector}" }
         )
 
         left_object.key1 = 'value1'
         right_object = {}
         rule.from_left_to_right(left_object, right_object)
 
-        expect(right_object).to eql Kk: { Key1: "#{left_object.object_id}-#{right_object.object_id}" }
+        expect(right_object).to eql Kk: { Key1: "#{left_object.object_id}-#{right_object.object_id}-#{left_node.selector}" }
       end
     end
 
-    describe 'on_right_to_left' do
+    describe '#on_right_to_left' do
       it 'should transform value if such options passed' do
         rule = described_class.new(
-          left_node,
-          right_node,
-          on_right_to_left: ->(v, _l, _r) { v.downcase }
+          [left_node],
+          [right_node],
+          on_right_to_left: ->(v, _l, _r, _n) { v.downcase }
         )
 
         left_object.key1 = nil
@@ -163,16 +192,114 @@ describe TwoWayMapper::Rule do
 
       it 'should pass left object and right object' do
         rule = described_class.new(
-          left_node,
-          right_node,
-          on_right_to_left: ->(_v, l, r) { "#{l.object_id}-#{r.object_id}" }
+          [left_node],
+          [right_node],
+          on_right_to_left: ->(_v, l, r, n) { "#{l.object_id}-#{r.object_id}-#{n.selector}" }
         )
 
         left_object.key1 = nil
         right_object = { Kk: { Key1: 'VALUE1' } }
         rule.from_right_to_left(left_object, right_object)
 
-        expect(left_object.key1).to eql "#{left_object.object_id}-#{right_object.object_id}"
+        expect(left_object.key1).to eql "#{left_object.object_id}-#{right_object.object_id}-#{right_node.selector}"
+      end
+    end
+  end
+
+  context 'with multiple nodes on the left side' do
+    let(:another_left_node) { TwoWayMapper::Node::Object.new('key2') }
+    let(:left_nodes) { [left_node, another_left_node] }
+
+    describe '#from_left_to_right' do
+      it 'should get first non nil value from left nodes and write to the right node' do
+        left_object.key2 = 'value2'
+        right_object = {}
+        rule.from_left_to_right(left_object, right_object)
+
+        expect(right_object).to eql Kk: { Key1: 'value2' }
+      end
+    end
+
+    describe '#from_right_to_left' do
+      it 'should read from right node and write to all left nodes' do
+        left_object.key1 = nil
+        left_object.key2 = nil
+        right_object = { Kk: { Key1: 'value1' } }
+        rule.from_right_to_left(left_object, right_object)
+
+        expect(left_object.key1).to eql 'value1'
+        expect(left_object.key2).to eql 'value1'
+      end
+    end
+  end
+
+  context 'with multiple nodes on the right side' do
+    let(:another_right_node) { TwoWayMapper::Node::Hash.new('Kk1.Key') }
+    let(:right_nodes) { [right_node, another_right_node] }
+
+    describe '#from_left_to_right' do
+      it 'should read from the left node and write to all right nodes' do
+        left_object.key1 = 'value'
+        right_object = {}
+        rule.from_left_to_right(left_object, right_object)
+
+        expect(right_object).to eql Kk: { Key1: 'value' }, Kk1: { Key: 'value' }
+      end
+    end
+
+    describe '#from_right_to_left' do
+      it 'should get first non nil value from right nodes and write to the left node' do
+        left_object.key1 = nil
+        right_object = { Kk1: { Key: 'value' } }
+        rule.from_right_to_left(left_object, right_object)
+
+        expect(left_object.key1).to eql 'value'
+      end
+    end
+  end
+
+  context 'with multiple nodes on both sides' do
+    let(:another_left_node) { TwoWayMapper::Node::Object.new('key2') }
+    let(:left_nodes) { [left_node, another_left_node] }
+    let(:another_right_node) { TwoWayMapper::Node::Hash.new('Kk1.Key') }
+    let(:right_nodes) { [right_node, another_right_node] }
+
+    describe '#from_left_to_right' do
+      it 'should get first non nil value from left nodes and write to all right nodes' do
+        left_object.key2 = 'value'
+        right_object = {}
+        rule.from_left_to_right(left_object, right_object)
+
+        expect(right_object).to eql Kk: { Key1: 'value' }, Kk1: { Key: 'value' }
+      end
+    end
+
+    describe '#from_right_to_left' do
+      it 'should get first non nil value from right nodes and write to all left nodes' do
+        left_object.key1 = nil
+        left_object.key2 = nil
+        right_object = { Kk1: { Key: 'value' } }
+        rule.from_right_to_left(left_object, right_object)
+
+        expect(left_object.key1).to eql 'value'
+      end
+    end
+  end
+
+  describe 'multiple nodes with callback' do
+    let(:another_left_node) { TwoWayMapper::Node::Object.new('key2') }
+    let(:left_nodes) { [left_node, another_left_node] }
+    # return false on empty string to emulate a situation when we need to skip blank values
+    let(:options) { { on_left_to_right: proc { |v| v != '' && v } } }
+
+    describe '#from_left_to_right' do
+      it 'should involve the callback' do
+        left_object.key1 = ''
+        left_object.key2 = 'value'
+        right_object = {}
+        rule.from_left_to_right(left_object, right_object)
+
+        expect(right_object).to eql Kk: { Key1: 'value' }
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: two-way-mapper
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Tim Masliuchenko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-31 00:00:00.000000000 Z
+date: 2020-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport