light_mapper 0.0.2 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 739e3317c888c4ead5db06449dee80bf264cff23
-  data.tar.gz: 353f10793c1cd990659934465b064fe035771f55
+SHA256:
+  metadata.gz: 309f037da546bc788d238d3fd43c7f92f1d117a1b885a30b7eaf65dc2947a445
+  data.tar.gz: f7a0c2c83eb49ce56ccbf1da8b102bf4325f868d9c35dee3a2dc36377f6c96f2
 SHA512:
-  metadata.gz: 6748d296cb4d18fa6c2f49e6777ec4e269e5eb19c961baa6e57677d8014958aa59c8464cbda208da8ff8b5b5a975974bdfffd86eaf9e6ae3ad00a68f619c8f68
-  data.tar.gz: b52174375c53a98b10c09664096fa01ee0a6ec18e841c06a0f12571cd704580c48935c907faec8b32dd77aa6e60a05b518a969ff986f9e3d5e55a62db339131c
+  metadata.gz: 9c306788435e091828219174645e0034c4bdfa8a096643d506e34258831bbefbbccf5dca2b0595720207796c301b01dc988abbd312d04391a9c0a5fc2b2d5dc2
+  data.tar.gz: 0fbd144a196b3edc3110c81e945d1d7ed6880f7d5cd8b82d34d1754bbdb3a32d7069254b03d5f8d977118c182fe8446734f555da92a144f130029c55c391ecce

data/.rubocop.yml

@@ -15,10 +15,6 @@ Style/Documentation:
 Style/PercentLiteralDelimiters:
   Enabled: false
 
-# Offense count: 2
-Style/RegexpLiteral:
-  MaxSlashes: 0
-
 # Offense count: 1
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle, SupportedStyles.
@@ -45,4 +41,4 @@ Metrics/LineLength:
 AllCops:
   Exclude:
     - '**/Guardfile'
-    - '**/light_parmas.gemspec'
+    - '**/light_mapper.gemspec'

data/.travis.yml

@@ -1,6 +1,4 @@
 language: ruby
 script: bundle exec rake
 rvm:
-  - 2.0.0
-  - 2.1.0
-  - 2.1.4
+  - 3.1.2

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in light_mapper.gemspec
 gemspec
+
+ruby '2.7.4'

data/README.md

@@ -1,5 +1,9 @@
 # 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)
+
 This is simple mapper for hash.
 
 ## Installation
@@ -31,6 +35,16 @@ Or install it yourself as:
   'LastName' => :last_name
 )
 ```
+
+or
+
+```ruby
+LightMapper.mapping(
+  { 'FirstName' => 'Pawel', 'LastName'  => 'Niemczyk' },
+  { 'FirstName' => :first_name, 'LastName' => :last_name }
+)
+```
+
 result is obvious:
 
 ```ruby
@@ -53,20 +67,16 @@ data = {
 }
 
 data.extend(LightMapper).mapping(PersonMapper)
+# {first_name: 'Pawel', last_name: 'Niemczyk', 'age': 5}
 ```
 
 ### When you require all keys
 
 ```ruby
-{
-  'FirstName' => 'Pawel'
-}.extend(LightMapper, require_keys: true).mapping(
-  'FirstName' => :first_name,
-  'LastName' => :last_name
-)
+{ 'FirstName' => 'Pawel' }.extend(LightMapper).mapping({'FirstName' => :first_name, 'LastName' => :last_name}, strict: true)
 ```
 
-it will raise KeyError
+it will raise LightMapper::KeyMissing: LastName key not found; Full path LastName
 
 ### When you want to pass string or symbol keys
 
@@ -74,10 +84,10 @@ it will raise KeyError
 {
   'FirstName' => 'Pawel',
   second_name: 'Niemczyk'
-}.extend(LightMapper, any_keys_kind: true).mapping(
-  'FirstName' => :first_name,
-  'second_name' => :last_name
-)
+}.extend(LightMapper).mapping({
+                                'FirstName' => :first_name,
+                                'second_name' => :last_name
+                              }, any_keys: true)
 ```
 
 result will be:
@@ -86,6 +96,81 @@ result will be:
 { first_name: 'Pawel', last_name: 'Niemczyk' }
 ```
 
+### Support for nested hashes, arrays and objects (now we talking what it is capable of)
+
+```ruby
+{
+  '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']
+    ],
+  ]
+}.extend(LightMapper).mapping(
+  '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
+)
+```
+
+result will be:
+
+```ruby
+{ 
+  word: 'ruby', 
+  email: 'pawel@example.com',
+  name: 'Pawel',
+  first_role: 'admin',
+  last_role: 'user',
+  manager_email: 'max@example.com',
+  manager_name: 'Max',
+  last_user_name: 'Pawel',
+  quarterly_payment_amount: 1000,
+  final_score: 1017
+}
+```
+
+### Mappers selection via pattern matching
+
+```ruby
+GOOGLE_MAPPER   = { 'result.user.name' => :name }
+LINKEDIN_MAPPER = { 'result.client.display_name' => :word }
+
+data = { source: 'google', user: { name: 'test'}, 'result' => { 'user' => { 'name' => 'Pawel'} } } 
+mapper = case data
+         in source: 'google', user: {name:} then GOOGLE_MAPPER
+         in source: 'linkedin', client: {display_name:} then LINKEDIN_MAPPER
+         else
+           raise 'Unknown mapper'
+         end
+
+data.extend(LightMapper).mapping(mapper)
+# result { name: 'Pawel' }
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/light_mapper/fork )

data/Rakefile

@@ -1,2 +1,6 @@
 require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/light_mapper/version.rb

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

data/lib/light_mapper.rb

@@ -1,29 +1,78 @@
 require 'light_mapper/version'
 
 module LightMapper
-  def mapping(mappings, opts = {})
-    LightMapper.mapping(clone, mappings, opts)
-  end
+  InvalidKey = Class.new(StandardError)
+  KeyMissing = Class.new(StandardError)
 
-  def self.mapping(hash, mappings, opts = {})
-    require_keys  = opts[:require_keys]  == true
-    any_keys_kind = opts[:any_keys_kind] == true
-    fetch_method  = if any_keys_kind
-      if require_keys
-        -> (hash, key) { hash.fetch(key.to_s, hash.fetch(key.to_sym)) }
+  module Helper
+    def self.raise_key_missing(current, full_path, additional_message = nil)
+
+      raise KeyMissing, ["#{current} key not found; Full path #{full_path.map(&:to_s).join('.')}", additional_message].compact.join('; ')
+    end
+
+    def self.key_destructor(value)
+      case value
+      in String
+        value.split('.')
+      in Symbol
+        [value]
+      in Array
+        value
       else
-        -> (hash, key) { hash[key.to_s] || hash[key.to_sym] }
+        raise InvalidKey, "Invalid key type: #{value.class}"
       end
-    else
-      if require_keys
-        -> (hash, key) { hash.fetch(key) }
+    end
+
+    def self.value_extractor(object, current, path, full_path, strict = false, any_keys = false)
+      result = case object
+               in Hash
+                 hash_key_extractor(object, current, full_path, strict, any_keys)
+               in Array
+                 array_key_extractor(object, current, full_path, strict, any_keys)
+              in NilClass
+                 nil
+              else
+                method_name = current.to_s.to_sym
+                object.respond_to?(method_name) ? object.send(method_name) : !strict ? nil : raise_key_missing(current, full_path)
+              end
+
+      path.compact.empty? ? result : value_extractor(result, path.first, path[1..-1], full_path, strict, any_keys)
+    end
+
+    def self.hash_key_extractor(object, current, full_path, strict, any_keys)
+      keys = any_keys ? [current, current.to_s, current.to_s.to_sym] : [current]
+      raise_key_missing(current, full_path) if strict && !keys.any? { |k| object.key?(k) }
+
+      object.values_at(*keys).compact.first
+    end
+
+    def self.array_key_extractor(object, current, full_path, strict, _any_keys)
+      index = current.to_s.match(/^(\d)+$/) ? current.to_i : nil
+
+      if index
+        raise_key_missing(current, full_path) if strict && index && object.size < index.next
+
+        object[index]
       else
-        -> (hash, key) { hash[key] }
+        method_name = current.to_s.to_sym
+        raise_key_missing(current, full_path, "Array do not respond on #{method_name}") if strict && !object.respond_to?(method_name)
+
+        object.public_send(method_name)
       end
     end
+  end
+
+  def mapping(mappings, opts = {})
+    LightMapper.mapping(clone, mappings, opts)
+  end
+
+  def self.mapping(hash, mappings, opts = {})
+    strict, any_keys = opts.values_at(:strict, :any_keys)
+    mappings.each_with_object({}) do |(k, v), h|
+      next h[v] = k.call(hash) if k.is_a?(Proc)
 
-    {}.tap do |h|
-      mappings.each { |k, v| h[v] = fetch_method.call(hash, k) }
+      key_path = Helper.key_destructor(k)
+      h[v] = Helper.value_extractor(hash, key_path.first, key_path[1..-1], key_path, strict, any_keys)
     end
   end
 end

data/light_mapper.gemspec

@@ -17,8 +17,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = %w(lib)
+  spec.required_ruby_version = '>= 2.7'
 
-  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'bundler', '~> 2.3'
   spec.add_development_dependency 'rake', '~> 10.4'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'guard', '~> 2.12'

data/spec/lib/light_mapper_spec.rb

@@ -1,4 +1,17 @@
 require 'spec_helper'
+class User
+  attr_accessor :name, :email, :manager
+
+  def initialize(name:, email:, manager: false)
+    @name = name
+    @email = email
+    @manager = manager
+  end
+
+  def as_json
+    { 'name' => name, 'email' => email, 'manager' => manager }
+  end
+end
 
 describe LightMapper do
 
@@ -12,7 +25,7 @@ describe LightMapper do
       }
     end
 
-    let(:maper) do
+    let(:mapper) do
       {
         'A' => :a,
         'b' => 'z'
@@ -20,7 +33,7 @@ describe LightMapper do
     end
 
     it 'return correct hash' do
-      expect(subject.mapping(maper)).to eq(a: original_hash['A'], 'z' => original_hash['b'])
+      expect(subject.mapping(mapper)).to eq(a: original_hash['A'], 'z' => original_hash['b'])
     end
   end
 
@@ -32,7 +45,7 @@ describe LightMapper do
       }
     end
 
-    let(:maper) do
+    let(:mapper) do
       {
         'A' => :a,
         'c' => 'z'
@@ -40,11 +53,11 @@ describe LightMapper do
     end
 
     it 'raise KeyError when required key missing' do
-      expect { subject.mapping(maper, require_keys: true) }.to raise_error(KeyError)
+      expect { subject.mapping(mapper, strict: true) }.to raise_error(LightMapper::KeyMissing)
     end
   end
 
-   describe 'basic data mapping when any keys kind is allowed' do
+  describe 'basic data mapping when any keys kind is allowed' do
     let(:original_hash) do
       {
         'A' => 'test',
@@ -54,7 +67,7 @@ describe LightMapper do
       }
     end
 
-    let(:maper) do
+    let(:mapper) do
       {
         'A' => :a,
         'c' => :c,
@@ -63,7 +76,7 @@ describe LightMapper do
     end
 
     it 'return correct hash' do
-      expect(subject.mapping(maper, any_keys_kind: true)).to eq(
+      expect(subject.mapping(mapper, any_keys: true)).to eq(
         a: original_hash['A'],
         c: original_hash[:c],
         'z' => original_hash['b']
@@ -71,7 +84,7 @@ describe LightMapper do
     end
 
     describe 'raise KeyError' do
-      let(:maper) do
+      let(:mapper) do
         {
           'A' => :a,
           'c' => :c,
@@ -80,11 +93,126 @@ describe LightMapper do
       end
 
       it ' when required key missing' do
-        expect { subject.mapping(maper, require_keys: true, any_keys_kind: true) }.to raise_error(KeyError)
+        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
+      {
+        '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')
+      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')
+      end
+    end
+
+    context 'with nested object mapping' do
+      let(:mapping) { {'user.email' => :result} }
 
-  it 'nested keys'
-  it 'value conversion'
+      it 'return correct result' do
+        expect(source.extend(LightMapper).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(source.extend(LightMapper).mapping(mapping)).to eq(result: '400')
+      end
+    end
+
+    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(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'
+                                                                  })
+      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)
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: light_mapper
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.4
 platform: ruby
 authors:
 - Pawel Niemczyk
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-04-27 00:00:00.000000000 Z
+date: 2022-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -147,7 +147,7 @@ homepage: https://github.com/pniemczyk/light_mapper
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -155,16 +155,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: Very light hash mapper
 test_files: