two-way-mapper 0.0.1 → 0.3.0

data/lib/two_way_mapper/tools.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 module TwoWayMapper
   module Tools
     class << self
       def first_item_from_hash!(hash)
         raise ArgumentError unless hash.is_a?(Hash)
-        raise ArgumentError unless first = hash.first
+        raise ArgumentError unless (first = hash.first)
 
-        hash.delete first[0]
+        hash.delete(first[0])
         first
       end
     end

data/lib/two_way_mapper/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TwoWayMapper
-  VERSION = "0.0.1"
+  VERSION = '0.3.0'
 end

data/spec/map_spec.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 describe TwoWayMapper::Map do
   describe '#register' do
-    let(:map) { TwoWayMapper::Map.new }
+    let(:map) { described_class.new }
 
     it 'should register new mapping' do
       map.register :import

data/spec/mapping_spec.rb

@@ -1,65 +1,125 @@
+# frozen_string_literal: true
+
 describe TwoWayMapper::Mapping do
-  [:left, :right].each do |method|
-    describe "##{method}" do
-      let(:mapping) { TwoWayMapper::Mapping.new }
+  let(:mapping) { described_class.new }
 
-      it "should set #{method} with options" do
-        mapping.send method, :object, opt1: ''
+  described_class::DIRECTIONS.each do |direction|
+    describe "##{direction}" do
+      it "should set #{direction} with options" do
+        mapping.send direction, :object, opt1: ''
 
-        expect(mapping.send("#{method}_class")).to eql TwoWayMapper::Node::Object
-        expect(mapping.send("#{method}_options")).to include opt1: ''
+        expect(mapping.send("#{direction}_class")).to eql TwoWayMapper::Node::Object
+        expect(mapping.send("#{direction}_options")).to include opt1: ''
+      end
+    end
+  end
+
+  context 'selectors' 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 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 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 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 Field1 Field2 Field3 Field4 Field5)
+        )
       end
     end
   end
 
   describe '#rule' do
-    let(:mapping) { TwoWayMapper::Mapping.new }
     before :each do
       mapping.left :object
       mapping.right :hash
     end
 
     context 'left and right validation' do
-      let(:mapping_without_both) { TwoWayMapper::Mapping.new }
-      let(:mapping_without_left) { TwoWayMapper::Mapping.new }
-      let(:mapping_without_right) { TwoWayMapper::Mapping.new }
+      let(:mapping_without_both) { described_class.new }
+      let(:mapping_without_left) { described_class.new }
+      let(:mapping_without_right) { described_class.new }
+
       before :each do
         mapping_without_left.right :hash
         mapping_without_right.left :hash
       end
 
       it 'should raise error when no left or right nodes' do
-        expect{mapping_without_left.rule 'key', 'key'}.to raise_error
-        expect{mapping_without_right.rule 'key', 'key'}.to raise_error
-        expect{mapping_without_both.rule 'key', 'key'}.to raise_error
+        expect { mapping_without_left.rule 'key', 'key' }.to raise_error StandardError
+        expect { mapping_without_right.rule 'key', 'key' }.to raise_error StandardError
+        expect { mapping_without_both.rule 'key', 'key' }.to raise_error StandardError
       end
     end
 
     it 'should add item to rules hash' do
-      expect{mapping.rule 'key1', 'Key1'}.to change{mapping.rules.count}.from(0).to(1)
+      expect { mapping.rule 'key1', 'Key1' }.to change { mapping.rules_list.count }.from(0).to(1)
 
-      rule = mapping.rules.first
+      rule = mapping.rules_list.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_list.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
-      expect{mapping.rule 'key1' => { opt1: 'val' }}.to raise_error
+      expect { mapping.rule 'key1' => { opt1: 'val' } }.to raise_error StandardError
 
       mapping.rule 'key1' => { opt1: 'val' }, 'Key2' => {}
-      rule = mapping.rules.first
+      rule = mapping.rules_list.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
+      rule = mapping.rules_list.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
@@ -71,18 +131,20 @@ describe TwoWayMapper::Mapping do
   end
 
   context 'convertion methods' do
-    let(:mapping) { TwoWayMapper::Mapping.new }
     let(:rule1) { double from_left_to_right: nil, from_right_to_left: nil }
     let(:rule2) { double from_left_to_right: nil, from_right_to_left: nil }
-    let(:left_obj) { double() }
-    let(:right_obj) { double() }
+    let(:left_obj) { double }
+    let(:right_obj) { double }
+
     before :each do
       mapping.left :object
       mapping.right :hash
-      allow(mapping).to receive(:rules).and_return [rule1, rule2]
+      allow(mapping).to receive(:rules_list).and_return [rule1, rule2]
     end
 
-    [:from_left_to_right, :from_right_to_left].each do |method|
+    [described_class::DIRECTIONS, described_class::DIRECTIONS.reverse].each do |from, to|
+      method = "from_#{from}_to_#{to}"
+
       describe "##{method}" do
         it 'should proxy to all rules' do
           expect(rule1).to receive(method).with left_obj, right_obj
@@ -93,4 +155,30 @@ describe TwoWayMapper::Mapping do
       end
     end
   end
+
+  describe '#rules' do
+    let(:hash) do
+      {
+        key1: :Key1,
+        key2: :Key2
+      }
+    end
+
+    before :each do
+      mapping.left :object
+      mapping.right :hash
+    end
+
+    it 'should allow to define multiple rules' do
+      expect { mapping.rules(hash) }.to change { mapping.rules_list.count }.from(0).to(2)
+
+      hash.each_with_index do |(left, right), index|
+        rule = mapping.rules_list[index]
+
+        expect(rule).to be_instance_of TwoWayMapper::Rule
+        expect(rule.left_nodes.map(&:selector)).to eql [left]
+        expect(rule.right_nodes.map(&:selector)).to eql [right]
+      end
+    end
+  end
 end

data/spec/node/active_record_spec.rb

@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
 describe TwoWayMapper::Node::ActiveRecord do
-  let(:node) { TwoWayMapper::Node::ActiveRecord.new 'user.email' }
+  let(:node) { described_class.new 'user.email' }
 
   describe '#write' do
     it 'should try to build before write' do
       user = double(email: '')
-      obj = double()
+      obj = double
+
       allow(obj).to receive :build_user do
         allow(obj).to receive(:user).and_return user
       end
@@ -18,6 +21,7 @@ describe TwoWayMapper::Node::ActiveRecord do
     it 'should try to build even if respond_to but obj itself is nil' do
       user = double(email: '')
       obj = double(user: nil)
+
       allow(obj).to receive :build_user do
         allow(obj).to receive(:user).and_return user
       end

data/spec/node/{abstract_spec.rb → base_spec.rb}

@@ -1,19 +1,24 @@
-describe TwoWayMapper::Node::Abstract do
+# frozen_string_literal: true
+
+describe TwoWayMapper::Node::Base do
   describe '#keys' do
-    subject { TwoWayMapper::Node::Abstract.new 'key1.key11.key111' }
+    subject { described_class.new('key1.key11.key111') }
 
-    its(:keys) { should eql [:key1, :key11, :key111] }
+    its(:keys) { should eql %i[key1 key11 key111] }
   end
 
   describe 'writable?' do
     it 'should be truthy if write_if options not set' do
-      node = TwoWayMapper::Node::Abstract.new 'key1.key11.key111'
+      node = described_class.new('key1.key11.key111')
 
       expect(node).to be_writable 'current', 'new'
     end
 
     it 'should be truthy if write_if option set' do
-      node = TwoWayMapper::Node::Abstract.new 'key1.key11.key111', write_if: ->(c, n) { c == 'current' || n == 'new' }
+      node = described_class.new(
+        'key1.key11.key111',
+        write_if: ->(c, n) { c == 'current' || n == 'new' }
+      )
 
       expect(node).to be_writable 'current', 'new1'
       expect(node).to be_writable 'current1', 'new'

data/spec/node/hash_spec.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 describe TwoWayMapper::Node::Hash do
   context 'normal keys' do
-    let(:node) { TwoWayMapper::Node::Hash.new 'key1.key11.key111' }
+    let(:node) { described_class.new('key1.key11.key111') }
 
     describe '#read' do
       it 'should return nil when path is not avaiable' do
@@ -25,7 +27,9 @@ describe TwoWayMapper::Node::Hash do
   end
 
   context 'string keys' do
-    let(:node) { TwoWayMapper::Node::Hash.new 'key1.key11.key111', stringify_keys: true }
+    let(:node) do
+      described_class.new('key1.key11.key111', stringify_keys: true)
+    end
 
     describe '#read' do
       it 'should return nil when path is not avaiable' do
@@ -50,7 +54,7 @@ describe TwoWayMapper::Node::Hash do
   end
 
   context 'write_if option' do
-    let(:node) { TwoWayMapper::Node::Hash.new 'key1.key11', write_if: ->(c, n) { c.empty? || n == 'value1' } }
+    let(:node) { described_class.new 'key1.key11', write_if: ->(c, n) { c.empty? || n == 'value1' } }
     let(:writable_obj1) { { key1: { key11: '' } } }
     let(:writable_obj2) { { key1: { key11: 'smth' } } }
     let(:not_writable_obj) { { key1: { key11: 'smth' } } }

data/spec/node/object_spec.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 describe TwoWayMapper::Node::Object do
-  let(:node) { TwoWayMapper::Node::Object.new 'key1.key11.key111' }
+  let(:node) { described_class.new 'key1.key11.key111' }
 
   describe '#read' do
     it 'should return nil when path is not avaiable' do
@@ -25,7 +27,7 @@ describe TwoWayMapper::Node::Object do
   end
 
   context 'write_if option' do
-    let(:node) { TwoWayMapper::Node::Object.new 'key', write_if: ->(c, n) { c.empty? || n == 'value1'} }
+    let(:node) { described_class.new 'key', write_if: ->(c, n) { c.empty? || n == 'value1'} }
     let(:writable_obj1) { OpenStruct.new key: '' }
     let(:writable_obj2) { OpenStruct.new key: 'smth' }
     let(:not_writable_obj) { OpenStruct.new key: 'smth' }

data/spec/rule_spec.rb

@@ -1,127 +1,305 @@
+# frozen_string_literal: true
+
 describe TwoWayMapper::Rule do
-  context 'transformation methods' do
-    let(:left_node) { TwoWayMapper::Node::Object.new 'key1' }
-    let(:right_node) { TwoWayMapper::Node::Hash.new 'Kk.Key1' }
-    let(:left_object) { OpenStruct.new }
-    let(:map) { { 'value' => 'VALUE' } }
+  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(:options) { {} }
+  let(:rule) { described_class.new(left_nodes, right_nodes, options) }
 
-    context 'without options' do
-      let(:rule) { TwoWayMapper::Rule.new left_node, right_node }
+  context 'without options' do
+    let(:options) { {} }
 
-      describe '#from_left_to_right' do
-        it 'should read from left node and write to right node' do
-          left_object.key1 = 'value1'
-          right_object = {}
-          rule.from_left_to_right left_object, right_object
+    describe '#from_left_to_right' 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)
 
-          expect(right_object).to eql Kk: { Key1: 'value1' }
-        end
+        expect(right_object).to eql Kk: { Key1: 'value1' }
       end
+    end
 
-      describe '#from_right_to_left' do
-        it 'should read from right node and write to left node' do
-          left_object.key1 = nil
-          right_object = { Kk: { Key1: 'value1' } }
-          rule.from_right_to_left left_object, right_object
+    describe '#from_right_to_left' 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)
 
-          expect(left_object.key1).to eql 'value1'
-        end
+        expect(left_object.key1).to eql 'value1'
       end
     end
+  end
 
-    context 'with map option' do
-      let(:rule) { TwoWayMapper::Rule.new left_node, right_node, map: map, default: 'not found' }
+  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 } }
 
-      describe '#from_left_to_right' do
-        it 'should read from left node and write to right node' do
-          left_object.key1 = 'value'
-          right_object = {}
-          rule.from_left_to_right left_object, right_object
+      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 Kk: { Key1: 'VALUE' }
-        end
+        expect(right_object).to eql({})
       end
+    end
+
+    describe '#from_right_to_left' do
+      let(:options) { { from_left_to_right_only: true } }
 
-      describe '#from_right_to_left' do
-        it 'should read from right node and write to left node' do
-          left_object.key1 = nil
-          right_object = { Kk: { Key1: 'VALUE' } }
-          rule.from_right_to_left left_object, right_object
+      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 eql 'value'
-        end
+        expect(left_object.key1).to be_nil
       end
     end
+  end
 
-    context 'with default option' do
-      describe '#from_left_to_right' do
-        it 'should return default value if not found' do
-          rule = TwoWayMapper::Rule.new left_node, right_node, map: map, default: 'not found'
+  context 'with map option' do
+    let(:options) { { map: map } }
 
-          left_object.key1 = 'value1'
-          right_object = {}
-          rule.from_left_to_right left_object, right_object
+    describe '#from_left_to_right' do
+      it 'should read from left node and write to right node' do
+        left_object.key1 = 'value'
+        right_object = {}
+        rule.from_left_to_right(left_object, right_object)
 
-          expect(right_object).to eql Kk: { Key1: 'not found' }
-        end
+        expect(right_object).to eql Kk: { Key1: 'VALUE' }
+      end
+    end
 
-        it 'should return use default_left if present and value not found' do
-          rule = TwoWayMapper::Rule.new left_node, right_node, map: map, default: 'not found', default_left: 'not found on left', default_right: 'not found on right'
+    describe '#from_right_to_left' do
+      it 'should read from right node and write to left node' do
+        left_object.key1 = nil
+        right_object = { Kk: { Key1: 'VALUE' } }
+        rule.from_right_to_left(left_object, right_object)
 
-          left_object.key1 = 'value1'
-          right_object = {}
-          rule.from_left_to_right left_object, right_object
+        expect(left_object.key1).to eql 'value'
+      end
+    end
+  end
+
+  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'
+
+        left_object.key1 = 'value1'
+        right_object = {}
+        rule.from_left_to_right(left_object, right_object)
 
-          expect(right_object).to eql Kk: { Key1: 'not found on left' }
-        end
+        expect(right_object).to eql Kk: { Key1: 'not found' }
       end
 
-      describe '#from_right_to_left' do
-        it 'should return default value if not found' do
-          rule = TwoWayMapper::Rule.new left_node, right_node, map: map, default: 'not found'
+      it 'should return use default_left if present and value not found' do
+        rule = described_class.new(
+          [left_node],
+          [right_node],
+          map: map,
+          default: 'not found',
+          default_left: 'not found on left',
+          default_right: 'not found on right'
+        )
 
-          left_object.key1 = nil
-          right_object = { Kk: { Key1: 'VALUE1' } }
-          rule.from_right_to_left left_object, right_object
+        left_object.key1 = 'value1'
+        right_object = {}
+        rule.from_left_to_right(left_object, right_object)
 
-          expect(left_object.key1).to eql 'not found'
-        end
+        expect(right_object).to eql Kk: { Key1: 'not found on left' }
+      end
+    end
 
-        it 'should return use default_right if present and value not found' do
-          rule = TwoWayMapper::Rule.new left_node, right_node, map: map, default: 'not found', default_left: 'not found on left', default_right: 'not found on right'
+    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'
 
-          left_object.key1 = nil
-          right_object = { Kk: { Key1: 'VALUE1' } }
-          rule.from_right_to_left left_object, right_object
+        left_object.key1 = nil
+        right_object = { Kk: { Key1: 'VALUE1' } }
+        rule.from_right_to_left(left_object, right_object)
 
-          expect(left_object.key1).to eql 'not found on right'
-        end
+        expect(left_object.key1).to eql 'not found'
+      end
+
+      it 'should return use default_right if present and value not found' do
+        rule = described_class.new(
+          [left_node],
+          [right_node],
+          map: map,
+          default: 'not found',
+          default_left: 'not found on left',
+          default_right: 'not found on right'
+        )
+
+        left_object.key1 = nil
+        right_object = { Kk: { Key1: 'VALUE1' } }
+        rule.from_right_to_left(left_object, right_object)
+
+        expect(left_object.key1).to eql 'not found on right'
+      end
+    end
+  end
+
+  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, _n) { v.upcase }
+        )
+
+        left_object.key1 = 'value1'
+        right_object = {}
+        rule.from_left_to_right(left_object, right_object)
+
+        expect(right_object).to eql Kk: { Key1: 'VALUE1' }
+      end
+
+      it 'should pass left object and right object' do
+        rule = described_class.new(
+          [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}-#{left_node.selector}" }
       end
     end
 
-    describe 'with callback option' do
-      describe 'on_left_to_right' do
-        it 'should transform value if such options passed' do
-          rule = TwoWayMapper::Rule.new left_node, right_node, on_left_to_right: ->(v) { v.upcase }
+    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, _n) { v.downcase }
+        )
+
+        left_object.key1 = nil
+        right_object = { Kk: { Key1: 'VALUE1' } }
+        rule.from_right_to_left(left_object, right_object)
+
+        expect(left_object.key1).to eql 'value1'
+      end
+
+      it 'should pass left object and right object' do
+        rule = described_class.new(
+          [left_node],
+          [right_node],
+          on_right_to_left: ->(_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
+        left_object.key1 = nil
+        right_object = { Kk: { Key1: 'VALUE1' } }
+        rule.from_right_to_left(left_object, right_object)
 
-          expect(right_object).to eql Kk: { Key1: 'VALUE1' }
-        end
+        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 'on_right_to_left' do
-        it 'should transform value if such options passed' do
-          rule = TwoWayMapper::Rule.new left_node, right_node, on_right_to_left: ->(v) { v.downcase }
+  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 } } }
 
-          left_object.key1 = nil
-          right_object = { Kk: { Key1: 'VALUE1' } }
-          rule.from_right_to_left left_object, right_object
+    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(left_object.key1).to eql 'value1'
-        end
+        expect(right_object).to eql Kk: { Key1: 'value' }
       end
     end
   end