light_mapper 1.0.5 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90664595ffebf1ec50dc86f05c193a044f6deee8bafe3091d18f3aed23d3ec32
-  data.tar.gz: e4cbe5fa16216ca94cf9c77b0fb2c96fbfc02978acf805b06984dcaedebb9a26
+  metadata.gz: a800edac754047d5a624828133bcc37a9c79e9249bf24cb3ccd4442c7b294acc
+  data.tar.gz: e4381557b9e15af95471a77c7e201a08acf59a634ce8d8cebff0e7200f582f0e
 SHA512:
-  metadata.gz: 4c91780ca138072138e84d7fadc7b8d552009107f1a40c7c96cef076181120a141182894e6d907bd28be11eb85b4db52a60496fc5b162753de42733dd2646aef
-  data.tar.gz: 5c27ebcc9f91eda5680d9a5105a6bd54c43e90b229d447ca457adc49a4d0504b7b4aabdab4e7b8029f799d66b1b80de32d0ce232f59b1589812f3c0f34571b9c
+  metadata.gz: fdfbc28bf90ceb8495578d0109077544ce08b4be8432ab2eba8899acf524c3cff446af6cbe2c18153c9a59dc8e486f896fa5a3041ccbb049c724f0f595ad658e
+  data.tar.gz: 297000ae1a8a25d0abf4fc1ecb7256ef6a7e9db066bdd6a370cc44cc674e4bcbc6256c650c582c3949fc0fd38272ea110b2a844bb5f2bab0935b08ee317cafa9

data/README.md

@@ -193,7 +193,14 @@ result will be:
 }
 ```
 
+### Support for pushing values to specific key based on key path
 
+```ruby
+{a: 1}.extend(LightMapper).push('b.c', 2, keys: :symbol)
+# result { a: 1, b: { c: 2 } }
+{ a: 1, b: { ab: 1}}.extend(LightMapper).push('b.ab', 2, keys: :symbol, override: true)
+# result { a: 1, b: { ab: 2 } }
+```
 
 ### Mappers selection via pattern matching
 

data/lib/light_mapper/version.rb

@@ -1,3 +1,3 @@
 module LightMapper
-  VERSION = '1.0.5'
+  VERSION = '1.0.6'
 end

data/lib/light_mapper.rb

@@ -76,7 +76,7 @@ module LightMapper
       end
     end
 
-    def self.push(hash, key, value, keys: :string, build_structure: true)
+    def self.push(hash, key, value, keys: :string, build_structure: true, override: false)
       return hash[key] = value if key.is_a?(Symbol)
 
       path = key.to_s.split('.')
@@ -87,11 +87,11 @@ module LightMapper
 
       path.each_with_index do |k, idx|
         last_idx = idx == path.size - 1
-        raise AlreadyAssignedValue, "Key #{k} already assigned in #{path} for #{hash.inspect} structure" if last_idx && context.key?(k) && !context[k].nil?
-        next context[k] = value if last_idx
+        raise AlreadyAssignedValue, "Key #{k} already assigned in #{path} for #{hash.inspect} structure" if !override && last_idx && context.key?(k) && !context[k].nil?
+        next context[k] = value if last_idx && context.is_a?(Hash)
 
         context.send(:[]=,k, {}) if build_structure && !context.key?(k)
-        context = context.send(:[], k) if context.is_a?(Hash)
+        context.is_a?(Hash) ? context = context.send(:[], k) : break
       end
     end
 
@@ -110,6 +110,11 @@ module LightMapper
     LightMapper.mapping(clone, mappings, opts)
   end
 
+  def push(key, value, keys: :string, build_structure: true, override: false)
+    LightMapper::Helper.push(self, key, value, keys: keys, build_structure: build_structure, override: override)
+    self
+  end
+
   def self.mapping(hash, mappings, opts = {})
     strict, any_keys, keys = opts.values_at(:strict, :any_keys, :keys)
 

data/spec/lib/light_mapper_spec.rb

@@ -18,248 +18,266 @@ describe LightMapper do
 
   subject { original_hash.extend(LightMapper) }
 
-  describe 'basic data mapping' do
-    let(:original_hash) do
-      {
-        'A' => 'test',
-        'b' => 1
-      }
-    end
-
-    let(:mapper) do
-      {
-        'A' => :a,
-        'b' => 'z'
-      }
-    end
+  context '#push' do
+    let(:original_hash) { { a: 1, b: { ab: 1}} }
 
-    it 'return correct hash' do
-      expect(subject.mapping(mapper)).to eq(a: original_hash['A'], 'z' => original_hash['b'])
+    it 'adds value to hash by key path' do
+      expect(subject.push('b.ac', 2, keys: :symbol)).to match({ a: 1, b: { ab: 1, ac: 2 } })
     end
-  end
 
-  describe 'basic data mapping when keys are required' do
-    let(:original_hash) do
-      {
-        'A' => 'test',
-        'b' => 1
-      }
+    it 'override value to hash by key path' do
+      expect(subject.push('b.ab', 2, keys: :symbol, override: true)).to match({ a: 1, b: { ab: 2 } })
     end
 
-    let(:mapper) do
-      {
-        'A' => :a,
-        'c' => 'z'
-      }
-    end
-
-    it 'raise KeyError when required key missing' do
-      expect { subject.mapping(mapper, strict: true) }.to raise_error(LightMapper::KeyMissing)
+    it 'not pushing values when path is not found for build_structure: false' do
+      expect(subject.push('b.abc.c', 2, keys: :symbol, override: true, build_structure: false)).to match({ a: 1, b: { ab: 1 } })
     end
   end
 
-  describe 'basic data mapping when any keys kind is allowed' do
-    let(:original_hash) do
-      {
-        'A' => 'test',
-        'b' => 1,
-        c: 10
-
-      }
-    end
-
-    let(:mapper) do
-      {
-        'A' => :a,
-        'c' => :c,
-        b: 'z'
-      }
-    end
-
-    it 'return correct hash' do
-      expect(subject.mapping(mapper, any_keys: true)).to eq(
-                                                           a: original_hash['A'],
-                                                           c: original_hash[:c],
-                                                           'z' => original_hash['b']
-                                                         )
-    end
+  context '#mapping' do
+    context 'basic data mapping' do
+      let(:original_hash) do
+        {
+          'A' => 'test',
+          'b' => 1
+        }
+      end
 
-    describe 'raise KeyError' do
       let(:mapper) do
         {
           'A' => :a,
-          'c' => :c,
-          k: 'z'
+          'b' => 'z'
         }
       end
 
-      it ' when required key missing' do
-        expect { subject.mapping(mapper, strict: true, any_keys: true) }.to raise_error(LightMapper::KeyMissing)
+      it 'return correct hash' do
+        expect(subject.mapping(mapper)).to eq(a: original_hash['A'], 'z' => original_hash['b'])
       end
     end
-  end
-
-  describe 'more advanced mapping' do
-    let(:source) do
-      {
-        'source' => { 'google' => { 'search_word' => 'ruby' } },
-        'user' => User.new(email: 'pawel@example.com', name: 'Pawel'),
-        'roles' => %w[admin manager user],
-        'mixed' => { users: [User.new(email: 'max@example.com', name: 'Max', manager: true), User.new(email: 'pawel@example.com', name: 'Pawel', manager: false)] },
-        'scores' => [10, 2, 5, 1000],
-        'last_4_payments' => [
-          { 'amount' => 100, 'currency' => 'USD' },
-          { 'amount' => 200, 'currency' => 'USD' },
-          { 'amount' => 300, 'currency' => 'USD' },
-          { 'amount' => 400, 'currency' => 'USD' }
-        ],
-        'array' => [
-          [1, 2, 3],
-          [4, 5, 6],
-          [
-            7,
-            8,
-            [':D']
-          ],
-        ]
-      }
-    end
 
-    context 'with nested hash mapping' do
-      let(:mapping) { { 'source.google.search_word' => :word } }
-
-      it 'return correct result' do
-        expect(source.extend(LightMapper).mapping(mapping)).to eq(word: 'ruby')
+    context 'basic data mapping when keys are required' do
+      let(:original_hash) do
+        {
+          'A' => 'test',
+          'b' => 1
+        }
       end
-    end
-
-    context 'with nested array mapping' do
-      let(:mapping) { { 'array.2.2.first' => :result } }
 
-      it 'return correct result' do
-        expect(source.extend(LightMapper).mapping(mapping)).to eq(result: ':D')
+      let(:mapper) do
+        {
+          'A' => :a,
+          'c' => 'z'
+        }
       end
-    end
 
-    context 'with nested object mapping' do
-      let(:mapping) { { 'user.email' => :result } }
-
-      it 'return correct result' do
-        expect(source.extend(LightMapper).mapping(mapping)).to eq(result: 'pawel@example.com')
+      it 'raise KeyError when required key missing' do
+        expect { subject.mapping(mapper, strict: true) }.to raise_error(LightMapper::KeyMissing)
       end
     end
 
-    context 'with mapping proc' do
-      let(:mapping) { { (->(source) { source['last_4_payments'].last['amount'].to_s }) => :result } }
+    context 'basic data mapping when any keys kind is allowed' do
+      let(:original_hash) do
+        {
+          'A' => 'test',
+          'b' => 1,
+          c: 10
 
-      it 'return correct result' do
-        expect(source.extend(LightMapper).mapping(mapping)).to eq(result: '400')
+        }
       end
-    end
 
-    context 'with mix of nested object types' do
-      let(:mapping) do
+      let(:mapper) do
         {
-          'source.google.search_word' => :word,
-          'user.email' => :email,
-          'user.as_json.name' => :name,
-          'roles.0' => :first_role,
-          ['roles', 1] => :middle_role,
-          'roles.last' => :last_role,
-          (->(source) { source['mixed'][:users].find { |user| user.manager }.email }) => :manager_email,
-          (->(source) { source['mixed'][:users].find { |user| user.manager }.name }) => :manager_name,
-          'mixed.users.last.name' => :last_user_name,
-          (->(source) { source['last_4_payments'].map(&:values).map(&:first).max }) => :quarterly_payment_amount,
-          'scores.sum' => :final_score,
-          'array.2.2.first' => :smile
+          'A' => :a,
+          'c' => :c,
+          b: 'z'
         }
       end
 
-      it 'return correct result' do
-        expect(source.extend(LightMapper).mapping(mapping, any_keys: true)).to match({
-                                                                                       word: 'ruby',
-                                                                                       email: 'pawel@example.com',
-                                                                                       name: 'Pawel',
-                                                                                       final_score: 1017,
-                                                                                       first_role: 'admin',
-                                                                                       last_role: 'user',
-                                                                                       manager_email: 'max@example.com',
-                                                                                       manager_name: 'Max',
-                                                                                       last_user_name: 'Pawel',
-                                                                                       middle_role: 'manager',
-                                                                                       quarterly_payment_amount: 400,
-                                                                                       smile: ':D'
-                                                                                     })
-      end
-
-      it 'return correct result base on proper key types' do
-        expect(source.extend(LightMapper).mapping(mapping)).to match({
-                                                                       word: 'ruby',
-                                                                       email: 'pawel@example.com',
-                                                                       name: 'Pawel',
-                                                                       final_score: 1017,
-                                                                       first_role: 'admin',
-                                                                       last_role: 'user',
-                                                                       manager_email: 'max@example.com',
-                                                                       manager_name: 'Max',
-                                                                       last_user_name: nil,
-                                                                       middle_role: 'manager',
-                                                                       quarterly_payment_amount: 400,
-                                                                       smile: ':D'
-                                                                     })
+      it 'return correct hash' do
+        expect(subject.mapping(mapper, any_keys: true)).to eq(
+                                                             a: original_hash['A'],
+                                                             c: original_hash[:c],
+                                                             'z' => original_hash['b']
+                                                           )
       end
 
-      it 'raise KeyMissing error' do
-        expect { source.extend(LightMapper).mapping({ 'user.non_existence_method' => :result }, strict: true) }.to raise_error(LightMapper::KeyMissing)
-        expect { source.extend(LightMapper).mapping({ 'last_4_payments.4' => :result }, strict: true) }.to raise_error(LightMapper::KeyMissing)
-        expect { source.extend(LightMapper).mapping({ 'source.google.missing_key' => :result }, strict: true) }.to raise_error(LightMapper::KeyMissing)
+      context 'raise KeyError' do
+        let(:mapper) do
+          {
+            'A' => :a,
+            'c' => :c,
+            k: 'z'
+          }
+        end
+
+        it ' when required key missing' do
+          expect { subject.mapping(mapper, strict: true, any_keys: true) }.to raise_error(LightMapper::KeyMissing)
+        end
       end
     end
 
-    context 'nested input to nested output' do
-      let(:source) do
+    context 'more advanced mapping' do
+      let(:original_hash) do
         {
-          'source' => { 'google' => { 'private_pool' => true } },
+          'source' => { 'google' => { 'search_word' => 'ruby' } },
           'user' => User.new(email: 'pawel@example.com', name: 'Pawel'),
           'roles' => %w[admin manager user],
+          'mixed' => { users: [User.new(email: 'max@example.com', name: 'Max', manager: true), User.new(email: 'pawel@example.com', name: 'Pawel', manager: false)] },
           'scores' => [10, 2, 5, 1000],
           'last_4_payments' => [
             { 'amount' => 100, 'currency' => 'USD' },
             { 'amount' => 200, 'currency' => 'USD' },
             { 'amount' => 300, 'currency' => 'USD' },
             { 'amount' => 400, 'currency' => 'USD' }
+          ],
+          'array' => [
+            [1, 2, 3],
+            [4, 5, 6],
+            [
+              7,
+              8,
+              [':D']
+            ],
           ]
         }
       end
 
-      let(:mapping) do
-        {
-          'source.google.private_pool' => 'private',
-          'user.email' => 'user.email',
-          'user.name' => 'user.name',
-          'roles' => 'user.roles',
-          'scores.max' => 'user.best_score',
-          'last_4_payments.last' => 'payment.last',
-        }
+      context 'with nested hash mapping' do
+        let(:mapping) { { 'source.google.search_word' => :word } }
+
+        it 'return correct result' do
+          expect(subject.mapping(mapping)).to eq(word: 'ruby')
+        end
+      end
+
+      context 'with nested array mapping' do
+        let(:mapping) { { 'array.2.2.first' => :result } }
+
+        it 'return correct result' do
+          expect(subject.mapping(mapping)).to eq(result: ':D')
+        end
+      end
+
+      context 'with nested object mapping' do
+        let(:mapping) { { 'user.email' => :result } }
+
+        it 'return correct result' do
+          expect(subject.mapping(mapping)).to eq(result: 'pawel@example.com')
+        end
+      end
+
+      context 'with mapping proc' do
+        let(:mapping) { { (->(source) { source['last_4_payments'].last['amount'].to_s }) => :result } }
+
+        it 'return correct result' do
+          expect(subject.mapping(mapping)).to eq(result: '400')
+        end
       end
 
-      it 'return correct result' do
-        expect(source.extend(LightMapper).mapping(mapping, keys: :symbol)).to match({
-                                                                                      private: true,
-                                                                                      user: {
-                                                                                        email: 'pawel@example.com',
-                                                                                        name: 'Pawel',
-                                                                                        roles: %w[admin manager user],
-                                                                                        best_score: 1000,
-                                                                                      },
-                                                                                      payment: {
-                                                                                        last: { 'amount' => 400, 'currency' => 'USD' }
-                                                                                      }
-                                                                                    })
+      context 'with mix of nested object types' do
+        let(:mapping) do
+          {
+            'source.google.search_word' => :word,
+            'user.email' => :email,
+            'user.as_json.name' => :name,
+            'roles.0' => :first_role,
+            ['roles', 1] => :middle_role,
+            'roles.last' => :last_role,
+            (->(source) { source['mixed'][:users].find { |user| user.manager }.email }) => :manager_email,
+            (->(source) { source['mixed'][:users].find { |user| user.manager }.name }) => :manager_name,
+            'mixed.users.last.name' => :last_user_name,
+            (->(source) { source['last_4_payments'].map(&:values).map(&:first).max }) => :quarterly_payment_amount,
+            'scores.sum' => :final_score,
+            'array.2.2.first' => :smile
+          }
+        end
+
+        it 'return correct result' do
+          expect(subject.mapping(mapping, any_keys: true)).to match({
+                                                                                         word: 'ruby',
+                                                                                         email: 'pawel@example.com',
+                                                                                         name: 'Pawel',
+                                                                                         final_score: 1017,
+                                                                                         first_role: 'admin',
+                                                                                         last_role: 'user',
+                                                                                         manager_email: 'max@example.com',
+                                                                                         manager_name: 'Max',
+                                                                                         last_user_name: 'Pawel',
+                                                                                         middle_role: 'manager',
+                                                                                         quarterly_payment_amount: 400,
+                                                                                         smile: ':D'
+                                                                                       })
+        end
+
+        it 'return correct result base on proper key types' do
+          expect(subject.mapping(mapping)).to match({
+                                                                         word: 'ruby',
+                                                                         email: 'pawel@example.com',
+                                                                         name: 'Pawel',
+                                                                         final_score: 1017,
+                                                                         first_role: 'admin',
+                                                                         last_role: 'user',
+                                                                         manager_email: 'max@example.com',
+                                                                         manager_name: 'Max',
+                                                                         last_user_name: nil,
+                                                                         middle_role: 'manager',
+                                                                         quarterly_payment_amount: 400,
+                                                                         smile: ':D'
+                                                                       })
+        end
+
+        it 'raise KeyMissing error' do
+          expect { subject.mapping({ 'user.non_existence_method' => :result }, strict: true) }.to raise_error(LightMapper::KeyMissing)
+          expect { subject.mapping({ 'last_4_payments.4' => :result }, strict: true) }.to raise_error(LightMapper::KeyMissing)
+          expect { subject.mapping({ 'source.google.missing_key' => :result }, strict: true) }.to raise_error(LightMapper::KeyMissing)
+        end
       end
 
-      it 'raise AlreadyAssignedValue error when key was allready assigned' do
-        expect { source.extend(LightMapper).mapping('source.google.private_pool' => 'private', 'source.google' => 'private') }.to raise_error(LightMapper::AlreadyAssignedValue)
+      context 'nested input to nested output' do
+        let(:original_hash) do
+          {
+            'source' => { 'google' => { 'private_pool' => true } },
+            'user' => User.new(email: 'pawel@example.com', name: 'Pawel'),
+            'roles' => %w[admin manager user],
+            'scores' => [10, 2, 5, 1000],
+            'last_4_payments' => [
+              { 'amount' => 100, 'currency' => 'USD' },
+              { 'amount' => 200, 'currency' => 'USD' },
+              { 'amount' => 300, 'currency' => 'USD' },
+              { 'amount' => 400, 'currency' => 'USD' }
+            ]
+          }
+        end
+
+        let(:mapping) do
+          {
+            'source.google.private_pool' => 'private',
+            'user.email' => 'user.email',
+            'user.name' => 'user.name',
+            'roles' => 'user.roles',
+            'scores.max' => 'user.best_score',
+            'last_4_payments.last' => 'payment.last',
+          }
+        end
+
+        it 'return correct result' do
+          expect(subject.mapping(mapping, keys: :symbol)).to match({
+                                                                                        private: true,
+                                                                                        user: {
+                                                                                          email: 'pawel@example.com',
+                                                                                          name: 'Pawel',
+                                                                                          roles: %w[admin manager user],
+                                                                                          best_score: 1000,
+                                                                                        },
+                                                                                        payment: {
+                                                                                          last: { 'amount' => 400, 'currency' => 'USD' }
+                                                                                        }
+                                                                                      })
+        end
+
+        it 'raise AlreadyAssignedValue error when key was allready assigned' do
+          expect { subject.mapping('source.google.private_pool' => 'private', 'source.google' => 'private') }.to raise_error(LightMapper::AlreadyAssignedValue)
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: light_mapper
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.6
 platform: ruby
 authors:
 - Pawel Niemczyk