two-way-mapper 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b6b6b6c10afaa565467784f5fca1b94bb7a6a7040d0edcff5c8be15a71114db
-  data.tar.gz: a996e65d5901e53b367134044b8e322e15f9c3dd105f7ae41d0d46345bca001c
+  metadata.gz: 524242de8d10dfa77f277974cd5e1670dcc68b0345b371d847a687cce8998c59
+  data.tar.gz: e4b0d1784f91ee600a316c161a8bb97b3bccabd6c2d97a1296dbb82596a93c08
 SHA512:
-  metadata.gz: 434786c065ea474bd39fceeb6e43961eaa97a0b1052f7ce8f9f6da957eb98aab76eb3b1e637759c50ff7a2d78e887645be86715f084478514d5a993d8df65c22
-  data.tar.gz: 1752b21435477d3f948f87c69655cc606de07f80afefc156f2717851051be1cf3a141b257a6eea2deb8bbaa756468fc8a67102232ae7f228e7ef1d43a3d2c2ee
+  metadata.gz: ce3eb28e41536134ac6c221b41c7bc0c0fecd01092a8f2f26c7076d4d7249a93c26c1e8103a9644a8418e7d93e8570fd273a4eb96023b52d77f92138cfa81be8
+  data.tar.gz: '09b3e9f0ccf3cc4e9f5ca8d3668b2cd7b253d7c9190f06daceb3afb3f3c0f4d58329d0a12ec394e6675fdd95ec79d1a28c26242037d24b0387193db6957d2c2c'

data/lib/two_way_mapper/mapping.rb

@@ -2,31 +2,34 @@
 
 module TwoWayMapper
   class Mapping
+    DIRECTIONS = [:left, :right].freeze
+
     attr_reader :rules, :left_class, :left_options, :right_class, :right_options
 
     def initialize
       @rules = []
     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
 
-      class_eval <<-CODE, __FILE__, __LINE__ + 1
-        def #{method}_selectors
-          rules.map { |rule| rule.#{method}.selector }
+        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
+          end
         end
-      CODE
-    end
 
-    def node_class(plugin)
-      TwoWayMapper::Node.const_get(plugin.to_s.camelize)
-    rescue NameError
-      raise NameError, 'Cannot find node'
+        def from_#{from}_to_#{to}(left_obj, right_obj)
+          rules.each { |rule| rule.from_#{from}_to_#{to}(left_obj, right_obj) }
+          #{to}_obj
+        end
+      CODE
     end
 
     def rule(left_selector, right_selector = {}, options = {})
@@ -53,13 +56,12 @@ module TwoWayMapper
       @rules << Rule.new(left, right, 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)
-          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
   end
 end

data/lib/two_way_mapper/rule.rb

@@ -10,29 +10,48 @@ module TwoWayMapper
       @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)
-
-          #{to}_obj
-        end
-      CODE
+    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)
+
+      right_obj
+    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)
+
+      left_obj
+    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)
       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

data/lib/two_way_mapper/version.rb

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

data/spec/mapping_spec.rb

@@ -3,39 +3,45 @@
 describe TwoWayMapper::Mapping do
   let(:mapping) { described_class.new }
 
-  [:left, :right].each do |method|
-    describe "##{method}" do
-      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
+  context 'selectors' do
+    before do
+      mapping.left :object
+      mapping.right :object
 
-        mapping.rule 'firstname', 'FirstName'
-        mapping.rule 'lastname', 'LastName'
-      end
+      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
+    end
 
-      describe "#left_selectors" do
-        subject { mapping.left_selectors }
+    describe '#left_selectors' do
+      it 'should get left selectors' do
+        expect(mapping.left_selectors).to eql %w(firstname fullname lastname fullname1)
+      end
 
-        it "should get left selectors" do
-          is_expected.to eql %w(firstname lastname)
-        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)
       end
+    end
 
-      describe "#right_selectors" do
-        subject { mapping.right_selectors }
+    describe '#right_selectors' do
+      it 'should get right selectors' do
+        expect(mapping.right_selectors).to eql %w(FirstName FullName LastName FullName1)
+      end
 
-        it "should get right selectors" do
-          is_expected.to eql %w(FirstName LastName)
-        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)
       end
     end
   end
@@ -110,7 +116,9 @@ describe TwoWayMapper::Mapping do
       allow(mapping).to receive(:rules).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

data/spec/rule_spec.rb

@@ -1,151 +1,178 @@
 # 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' } }
-
-    context 'without options' do
-      let(:rule) { described_class.new left_node, right_node }
-
-      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
-
-          expect(right_object).to eql Kk: { Key1: 'value1' }
-        end
+  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(:rule) { described_class.new(left_node, right_node, 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
+        left_object.key1 = 'value1'
+        right_object = {}
+        rule.from_left_to_right(left_object, right_object)
+
+        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 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)
 
-          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) { described_class.new left_node, right_node, map: map, default: 'not found' }
+  context 'with map option' do
+    let(:options) { { map: map } }
 
-      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
+    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: 'VALUE' }
-        end
+        expect(right_object).to eql Kk: { Key1: 'VALUE' }
       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: 'VALUE' } }
-          rule.from_right_to_left left_object, right_object
+    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)
 
-          expect(left_object.key1).to eql 'value'
-        end
+        expect(left_object.key1).to eql 'value'
       end
     end
+  end
+
+  context 'with 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' }
+      end
+
+      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 = 'value1'
+        right_object = {}
+        rule.from_left_to_right(left_object, right_object)
+
+        expect(right_object).to eql Kk: { Key1: 'not found on left' }
+      end
+    end
+
+    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)
 
-    context 'with 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' }
-        end
-
-        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 = '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(left_object.key1).to eql 'not found'
       end
 
-      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
-
-          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
+      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
+
+  describe '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_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) { "#{l.object_id}-#{r.object_id}" }
+        )
+
+        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}" }
+      end
+    end
+
+    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_object.key1 = nil
+        right_object = { Kk: { Key1: 'VALUE1' } }
+        rule.from_right_to_left(left_object, right_object)
 
-    describe '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) { 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
+        expect(left_object.key1).to eql 'value1'
       end
 
-      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) { v.downcase }
-          )
+      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_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 'value1'
-        end
+        expect(left_object.key1).to eql "#{left_object.object_id}-#{right_object.object_id}"
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: two-way-mapper
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Tim Masliuchenko