light_mapper 1.0.4 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 309f037da546bc788d238d3fd43c7f92f1d117a1b885a30b7eaf65dc2947a445
-  data.tar.gz: f7a0c2c83eb49ce56ccbf1da8b102bf4325f868d9c35dee3a2dc36377f6c96f2
+  metadata.gz: 90664595ffebf1ec50dc86f05c193a044f6deee8bafe3091d18f3aed23d3ec32
+  data.tar.gz: e4cbe5fa16216ca94cf9c77b0fb2c96fbfc02978acf805b06984dcaedebb9a26
 SHA512:
-  metadata.gz: 9c306788435e091828219174645e0034c4bdfa8a096643d506e34258831bbefbbccf5dca2b0595720207796c301b01dc988abbd312d04391a9c0a5fc2b2d5dc2
-  data.tar.gz: 0fbd144a196b3edc3110c81e945d1d7ed6880f7d5cd8b82d34d1754bbdb3a32d7069254b03d5f8d977118c182fe8446734f555da92a144f130029c55c391ecce
+  metadata.gz: 4c91780ca138072138e84d7fadc7b8d552009107f1a40c7c96cef076181120a141182894e6d907bd28be11eb85b4db52a60496fc5b162753de42733dd2646aef
+  data.tar.gz: 5c27ebcc9f91eda5680d9a5105a6bd54c43e90b229d447ca457adc49a4d0504b7b4aabdab4e7b8029f799d66b1b80de32d0ce232f59b1589812f3c0f34571b9c

data/README.md

@@ -1,8 +1,7 @@
 # LightMapper
 
 [![Gem Version](https://badge.fury.io/rb/light_mapper.svg)](http://badge.fury.io/rb/light_mapper)
-[![Build Status](https://travis-ci.org/pniemczyk/light_mapper.svg?branch=0.2.0)](https://travis-ci.org/pniemczyk/light_mapper)
-[![Dependency Status](https://gemnasium.com/pniemczyk/light_mapper.svg)](https://gemnasium.com/pniemczyk/light_mapper)
+[![Build Status](https://travis-ci.org/pniemczyk/light_mapper.svg?branch=master)](https://travis-ci.org/pniemczyk/light_mapper)
 
 This is simple mapper for hash.
 
@@ -153,6 +152,49 @@ result will be:
 }
 ```
 
+### Support for nested output structure and symbolize output keys
+
+```ruby
+{
+  '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' }
+  ]
+}.extend(LightMapper).mapping({
+  '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',
+}, keys: :symbol)
+```
+
+result will be: 
+
+```ruby
+{
+  private: true,
+  user: {
+    email: 'pawel@example.com',
+    name: 'Pawel',
+    roles: %w[admin manager user],
+    best_score: 1000,
+  },
+  payment: {
+    last: { 'amount' => 400, 'currency' => 'USD' }
+  }
+}
+```
+
+
+
 ### Mappers selection via pattern matching
 
 ```ruby

data/lib/light_mapper/version.rb

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

data/lib/light_mapper.rb

@@ -1,8 +1,11 @@
 require 'light_mapper/version'
 
 module LightMapper
-  InvalidKey = Class.new(StandardError)
-  KeyMissing = Class.new(StandardError)
+  BaseError = Class.new(StandardError)
+  InvalidKey = Class.new(BaseError)
+  KeyMissing = Class.new(BaseError)
+  InvalidStructure = Class.new(BaseError)
+  AlreadyAssignedValue = Class.new(BaseError)
 
   module Helper
     def self.raise_key_missing(current, full_path, additional_message = nil)
@@ -60,6 +63,47 @@ module LightMapper
         object.public_send(method_name)
       end
     end
+
+    def self.build_structure(mapping)
+      mapping.values.each_with_object({}) do |value, result|
+        nesting = value.to_s.split('.')[0..-2]
+        next result if nesting.empty?
+
+        nesting.each do |key|
+          result[key] ||= {}
+          result = result[key]
+        end
+      end
+    end
+
+    def self.push(hash, key, value, keys: :string, build_structure: true)
+      return hash[key] = value if key.is_a?(Symbol)
+
+      path = key.to_s.split('.')
+      path = path.map(&:to_sym) if keys == :symbol
+
+      context = hash
+      context[path.first] if build_structure && path.size == 2
+
+      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
+
+        context.send(:[]=,k, {}) if build_structure && !context.key?(k)
+        context = context.send(:[], k) if context.is_a?(Hash)
+      end
+    end
+
+    def self.compact(hash)
+      hash.each_with_object({}) do |(key, value), result|
+        next if value.empty?
+
+        result[key] = value.is_a?(Hash) ? compact(value) : value
+      end
+    end
+  rescue IndexError
+    raise InvalidStructure, "Invalid key: #{key} for #{hash.inspect} structure"
   end
 
   def mapping(mappings, opts = {})
@@ -67,12 +111,14 @@ module LightMapper
   end
 
   def self.mapping(hash, mappings, opts = {})
-    strict, any_keys = opts.values_at(:strict, :any_keys)
+    strict, any_keys, keys = opts.values_at(:strict, :any_keys, :keys)
+
     mappings.each_with_object({}) do |(k, v), h|
-      next h[v] = k.call(hash) if k.is_a?(Proc)
+      next Helper.push(h, v, k.call(hash), keys: keys) if k.is_a?(Proc)
 
       key_path = Helper.key_destructor(k)
-      h[v] = Helper.value_extractor(hash, key_path.first, key_path[1..-1], key_path, strict, any_keys)
+      value = Helper.value_extractor(hash, key_path.first, key_path[1..-1], key_path, strict, any_keys)
+      Helper.push(h, v, value, keys: keys)
     end
   end
 end

data/spec/lib/light_mapper_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+
 class User
   attr_accessor :name, :email, :manager
 
@@ -77,10 +78,10 @@ describe LightMapper do
 
     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']
-      )
+                                                           a: original_hash['A'],
+                                                           c: original_hash[:c],
+                                                           'z' => original_hash['b']
+                                                         )
     end
 
     describe 'raise KeyError' do
@@ -96,7 +97,7 @@ describe LightMapper do
         expect { subject.mapping(mapper, strict: true, any_keys: true) }.to raise_error(LightMapper::KeyMissing)
       end
     end
-   end
+  end
 
   describe 'more advanced mapping' do
     let(:source) do
@@ -105,7 +106,7 @@ describe LightMapper do
         '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],
+        'scores' => [10, 2, 5, 1000],
         'last_4_payments' => [
           { 'amount' => 100, 'currency' => 'USD' },
           { 'amount' => 200, 'currency' => 'USD' },
@@ -113,8 +114,8 @@ describe LightMapper do
           { 'amount' => 400, 'currency' => 'USD' }
         ],
         'array' => [
-          [1,2,3],
-          [4,5,6],
+          [1, 2, 3],
+          [4, 5, 6],
           [
             7,
             8,
@@ -125,7 +126,7 @@ describe LightMapper do
     end
 
     context 'with nested hash mapping' do
-      let(:mapping) { {'source.google.search_word' => :word} }
+      let(:mapping) { { 'source.google.search_word' => :word } }
 
       it 'return correct result' do
         expect(source.extend(LightMapper).mapping(mapping)).to eq(word: 'ruby')
@@ -133,7 +134,7 @@ describe LightMapper do
     end
 
     context 'with nested array mapping' do
-      let(:mapping) { {'array.2.2.first' => :result} }
+      let(:mapping) { { 'array.2.2.first' => :result } }
 
       it 'return correct result' do
         expect(source.extend(LightMapper).mapping(mapping)).to eq(result: ':D')
@@ -141,7 +142,7 @@ describe LightMapper do
     end
 
     context 'with nested object mapping' do
-      let(:mapping) { {'user.email' => :result} }
+      let(:mapping) { { 'user.email' => :result } }
 
       it 'return correct result' do
         expect(source.extend(LightMapper).mapping(mapping)).to eq(result: 'pawel@example.com')
@@ -176,42 +177,89 @@ describe LightMapper do
 
       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'
-                                                                  })
+                                                                                       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'
-                                                                  })
+                                                                       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 { 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)
+        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)
+      end
+    end
+
+    context 'nested input to nested output' do
+      let(:source) 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(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' }
+                                                                                      }
+                                                                                    })
+      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)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: light_mapper
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.5
 platform: ruby
 authors:
 - Pawel Niemczyk
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-10 00:00:00.000000000 Z
+date: 2022-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -162,7 +162,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
 summary: Very light hash mapper