light_mapper 0.0.2 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 739e3317c888c4ead5db06449dee80bf264cff23
-  data.tar.gz: 353f10793c1cd990659934465b064fe035771f55
+SHA256:
+  metadata.gz: 90664595ffebf1ec50dc86f05c193a044f6deee8bafe3091d18f3aed23d3ec32
+  data.tar.gz: e4cbe5fa16216ca94cf9c77b0fb2c96fbfc02978acf805b06984dcaedebb9a26
 SHA512:
-  metadata.gz: 6748d296cb4d18fa6c2f49e6777ec4e269e5eb19c961baa6e57677d8014958aa59c8464cbda208da8ff8b5b5a975974bdfffd86eaf9e6ae3ad00a68f619c8f68
-  data.tar.gz: b52174375c53a98b10c09664096fa01ee0a6ec18e841c06a0f12571cd704580c48935c907faec8b32dd77aa6e60a05b518a969ff986f9e3d5e55a62db339131c
+  metadata.gz: 4c91780ca138072138e84d7fadc7b8d552009107f1a40c7c96cef076181120a141182894e6d907bd28be11eb85b4db52a60496fc5b162753de42733dd2646aef
+  data.tar.gz: 5c27ebcc9f91eda5680d9a5105a6bd54c43e90b229d447ca457adc49a4d0504b7b4aabdab4e7b8029f799d66b1b80de32d0ce232f59b1589812f3c0f34571b9c

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,8 @@
 # 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=master)](https://travis-ci.org/pniemczyk/light_mapper)
+
 This is simple mapper for hash.
 
 ## Installation
@@ -31,6 +34,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 +66,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 +83,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 +95,124 @@ 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
+}
+```
+
+### 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
+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.5'
 end

data/lib/light_mapper.rb

@@ -1,29 +1,124 @@
 require 'light_mapper/version'
 
 module LightMapper
-  def mapping(mappings, opts = {})
-    LightMapper.mapping(clone, mappings, opts)
-  end
+  BaseError = Class.new(StandardError)
+  InvalidKey = Class.new(BaseError)
+  KeyMissing = Class.new(BaseError)
+  InvalidStructure = Class.new(BaseError)
+  AlreadyAssignedValue = Class.new(BaseError)
 
-  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
 
-    {}.tap do |h|
-      mappings.each { |k, v| h[v] = fetch_method.call(hash, k) }
+    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 = {})
+    LightMapper.mapping(clone, mappings, opts)
+  end
+
+  def self.mapping(hash, mappings, opts = {})
+    strict, any_keys, keys = opts.values_at(:strict, :any_keys, :keys)
+
+    mappings.each_with_object({}) do |(k, v), h|
+      next Helper.push(h, v, k.call(hash), keys: keys) if k.is_a?(Proc)
+
+      key_path = Helper.key_destructor(k)
+      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/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,5 +1,19 @@
 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
 
   subject { original_hash.extend(LightMapper) }
@@ -12,7 +26,7 @@ describe LightMapper do
       }
     end
 
-    let(:maper) do
+    let(:mapper) do
       {
         'A' => :a,
         'b' => 'z'
@@ -20,7 +34,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 +46,7 @@ describe LightMapper do
       }
     end
 
-    let(:maper) do
+    let(:mapper) do
       {
         'A' => :a,
         'c' => 'z'
@@ -40,11 +54,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 +68,7 @@ describe LightMapper do
       }
     end
 
-    let(:maper) do
+    let(:mapper) do
       {
         'A' => :a,
         'c' => :c,
@@ -63,15 +77,15 @@ describe LightMapper do
     end
 
     it 'return correct hash' do
-      expect(subject.mapping(maper, any_keys_kind: true)).to eq(
-        a: original_hash['A'],
-        c: original_hash[:c],
-        'z' => original_hash['b']
-      )
+      expect(subject.mapping(mapper, any_keys: true)).to eq(
+                                                           a: original_hash['A'],
+                                                           c: original_hash[:c],
+                                                           'z' => original_hash['b']
+                                                         )
     end
 
     describe 'raise KeyError' do
-      let(:maper) do
+      let(:mapper) do
         {
           'A' => :a,
           'c' => :c,
@@ -80,11 +94,173 @@ 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
 
-  it 'nested keys'
-  it 'value conversion'
+  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 '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
+
+    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
 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.5
 platform: ruby
 authors:
 - Pawel Niemczyk
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-04-27 00:00:00.000000000 Z
+date: 2022-12-11 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.2.3
+signing_key:
 specification_version: 4
 summary: Very light hash mapper
 test_files: