hash_mapper 0.2.2 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: af39a6882d3304ec2e61725f82386d1856852971
-  data.tar.gz: bdd2c354eb2537699d33501240911f799b18dabc
+SHA256:
+  metadata.gz: e24c6fe7171260dd214d3b5b1f5250afe1038a63702b1cc0db74dece9b648cd1
+  data.tar.gz: b27d3e3af82035e1bd5192906b4dad65a918a9a928513c854884ed2bed500709
 SHA512:
-  metadata.gz: aff0e443feb90e2a54325138e4660922a89351a510fb947295dd855ab219599909c9d643f8ae355f8c93c296c8514faf9e82b4d506d341b5c8dd445429ebb853
-  data.tar.gz: 55176739edcd3034c6f57c765d3b68f7a5b16ea3f2b0207d19dd5a70cc27c56f3ee089a9dc306ab3015d7467ee5c3a000c6b7e9135897fa131d5ef789166fa25
+  metadata.gz: 8fbc136b57c7e6bd5fcf435f202f6a6adf444a7f2c4982311bd9dd0ff3fd1ea99fb0b4f9cedbc71ba8a17cc08c7b0da9a4d55e9b7c22da5bb5b1d2e055914a43
+  data.tar.gz: 100954ccf11324b9b54ce471a3dafcb0ba7cc68e69b2cedd37e610c325ad7d12e3c2c61fdb3686721383f7a4dc0e80b765b21e3c1ba1a804ef586851e8106373

data/README.md

@@ -7,7 +7,7 @@
 ## DESCRIPTION:
 
 Maps values from hashes with different structures and/or key names. Ideal for normalizing arbitrary data to be consumed by your applications, or to prepare your data for different display formats (ie. json).
- 
+
 Tiny module that allows you to easily adapt from one hash structure to another with a simple declarative DSL.
 
 ## FEATURES/PROBLEMS:
@@ -61,7 +61,7 @@ You can use HashMapper in your own little hash-like objects:
 class NiceHash
   include Enumerable
   extend HashMapper
-  
+
   map from('/names/first'), to('/first_name')
   map from('/names/last'), to('/last_name')
 
@@ -89,7 +89,7 @@ end
 
 #### Coercing values
 
-You want to make sure an incoming value gets converted to a certain type, so 
+You want to make sure an incoming value gets converted to a certain type, so
 
 ```ruby
 {'one' => '1', 'two' => '2'}
@@ -97,7 +97,7 @@ You want to make sure an incoming value gets converted to a certain type, so
 
 gets translated to
 
-```ruby`
+```ruby
 {:one => 1, :two => 2}
 ```
 
@@ -165,9 +165,9 @@ output = NameMapper.normalize(input) # => {:first_name => 'Mark', :last_name =>
 
 NameMapper.denormalize(output) # => input
 ```
-	
+
 This will work with your block filters and even nested mappers (see below).
-	
+
 ### Advanced usage
 #### Array access
 You want:
@@ -252,7 +252,7 @@ end
 
 But HashMapper's nested mappers will actually do that for you if a value is an array, so:
 
-```ruby	
+```ruby
 map from('/employees'),	to('employees'), using: UserMapper
 ```
 ... Will map each employee using UserMapper.
@@ -268,12 +268,12 @@ They all yield a block with 2 arguments - the hash you are mapping from and the
 ```ruby
 class EggMapper
   map from('/raw'), to('/fried')
-  
+
   before_normalize do |input, output|
-    input['raw'] ||= 'please'     # this will give 'raw' a default value 
+    input['raw'] ||= 'please'     # this will give 'raw' a default value
     input
   end
-  
+
   after_denormalize do |input, output|
     output.to_a        # the denormalized object will now be an array, not a hash!!
   end
@@ -290,23 +290,23 @@ You can pass one extra argument to before and after filters if you need to:
 ```ruby
 class EggMapper
   map from('/raw'), to('/fried')
-  
+
   before_normalize do |input, output, opts|
-    input['raw'] ||= 'please' unless opts[:no_default] # this will give 'raw' a default value 
+    input['raw'] ||= 'please' unless opts[:no_default] # this will give 'raw' a default value
     input
   end
-  
+
   after_denormalize do |input, output, opts|
     output.to_a        # the denormalized object will now be an array, not a hash!!
   end
 
 end
 
-EggMapper.normalize({}, no_default: true)
+EggMapper.normalize({}, options: { no_default: true })
 EggMapper.denormalize({fried: 4})
 ```
 
-   
+
 ## REQUIREMENTS:
 
 ## TODO:

data/hash_mapper.gemspec

@@ -7,9 +7,8 @@ Gem::Specification.new do |s|
   s.version     = HashMapper::VERSION
   s.authors     = ['Ismael Celis']
   s.description = %q{Tiny module that allows you to easily adapt from one hash structure to another with a simple declarative DSL.}
-  s.date        = %q{2010-09-21}
   s.email       = %q{ismaelct@gmail.com}
-  
+
   s.files         = `git ls-files`.split("\n")
   s.homepage      = %q{http://github.com/ismasan/hash_mapper}
   s.rdoc_options  = ['--charset=UTF-8']
@@ -18,14 +17,14 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ['lib']
-  
+
   if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-    s.add_runtime_dependency("activesupport", "~> 4")
+    s.add_runtime_dependency("activesupport", ">= 4")
   else
-    s.add_dependency("activesupport", "~> 4")
+    s.add_dependency("activesupport", ">= 4")
   end
-  
+
   # specify any dependencies here; for example:
-  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rspec', '>= 3.9'
   s.add_development_dependency 'rake'
 end

data/lib/hash_mapper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'hash_mapper/version'
 
 $:.unshift(File.dirname(__FILE__)) unless
@@ -39,6 +41,9 @@ unless [].respond_to?(:inject_with_index)
 end
 
 module HashMapper
+  DEFAULT_OPTIONS = {}.freeze
+  NO_VALUE = :hash_mapper_no_value
+  NO_DEFAULT = :hash_mapper_no_default
 
   def self.extended(base)
     base.class_eval do
@@ -73,12 +78,12 @@ module HashMapper
     { using: mapper_class }
   end
 
-  def normalize(a_hash, opts = {})
-    perform_hash_mapping a_hash, :normalize, opts
+  def normalize(a_hash, options: DEFAULT_OPTIONS, context: nil)
+    perform_hash_mapping a_hash, :normalize, options: options, context: context
   end
 
-  def denormalize(a_hash, opts = {})
-    perform_hash_mapping a_hash, :denormalize, opts
+  def denormalize(a_hash, options: DEFAULT_OPTIONS, context: nil)
+    perform_hash_mapping a_hash, :denormalize, options: options, context: context
   end
 
   def before_normalize(&blk)
@@ -99,22 +104,22 @@ module HashMapper
 
   protected
 
-  def perform_hash_mapping(a_hash, meth, opts)
+  def perform_hash_mapping(a_hash, meth, options:, context:)
     output = {}
 
     # Before filters
     a_hash = self.send(:"before_#{meth}_filters").inject(a_hash) do |memo, filter|
-      filter.call(memo, output, opts)
+      filter.call(memo, output, options)
     end
 
     # Do the mapping
     self.maps.each do |m|
-      m.process_into(output, a_hash, meth)
+      m.process_into(output, a_hash, method_name: meth, context: context)
     end
 
     # After filters
     self.send(:"after_#{meth}_filters").inject(output) do |memo, filter|
-      filter.call(a_hash, memo, opts)
+      filter.call(a_hash, memo, options)
     end
   end
 
@@ -129,58 +134,58 @@ module HashMapper
       @path_from = path_from
       @path_to = path_to
       @delegated_mapper = options.fetch(:using, nil)
-      @default_value = options.fetch(:default, :hash_mapper_no_default)
+      @default_value = options.fetch(:default, NO_DEFAULT)
     end
 
-    def process_into(output, input, meth = :normalize)
-      path_1, path_2 = (meth == :normalize ? [path_from, path_to] : [path_to, path_from])
-      value = get_value_from_input(output, input, path_1, meth)
-      set_value_in_output(output, path_2, value)
+    def process_into(output, input, method_name: :normalize, context: nil)
+      path_1, path_2 = (method_name == :normalize ? [path_from, path_to] : [path_to, path_from])
+      value = get_value_from_input(output, input, path_1, method_name: method_name, context: context)
+      set_value_in_output(output, path_2, value, context: context)
     end
     protected
 
-    def get_value_from_input(output, input, path, meth)
+    def get_value_from_input(output, input, path, method_name:, context:)
       value = path.inject(input) do |h,e|
         if h.is_a?(Hash)
           v = [h[e.to_sym], h[e.to_s]].compact.first
         else
           v = h[e]
         end
-        return :hash_mapper_no_value if v.nil?
+        return NO_VALUE if v.nil?
         v
       end
-      delegated_mapper ? delegate_to_nested_mapper(value, meth) : value
+      delegated_mapper ? delegate_to_nested_mapper(value, method_name, context: context) : value
     end
 
-    def set_value_in_output(output, path, value)
-      if value == :hash_mapper_no_value
-        if default_value == :hash_mapper_no_default
+    def set_value_in_output(output, path, value, context: context)
+      if value == NO_VALUE
+        if default_value == NO_DEFAULT
           return
         else
           value = default_value
         end
       end
-      add_value_to_hash!(output, path, value)
+      add_value_to_hash!(output, path, value, context: context)
     end
 
-    def delegate_to_nested_mapper(value, meth)
+    def delegate_to_nested_mapper(value, method_name, context:)
       case value
       when Array
-        value.map {|h| delegated_mapper.send(meth, h)}
+        value.map {|v| delegated_mapper.public_send(method_name, v, context: context)}
       when nil
-        return :hash_mapper_no_value
+        return NO_VALUE
       else
-        delegated_mapper.send(meth, value)
+        delegated_mapper.public_send(method_name, value, context: context)
       end
     end
 
-    def add_value_to_hash!(hash, path, value)
+    def add_value_to_hash!(hash, path, value, context: nil)
       path.inject_with_index(hash) do |h,e,i|
         if !h[e].nil? # it can be FALSE
           h[e]
         else
           h[e] = if i == path.size-1
-            path.apply_filter(value)
+            path.apply_filter(value, context: context)
           else
             if path.segments[i+1].is_a? Integer
               []
@@ -201,17 +206,24 @@ module HashMapper
     include Enumerable
 
     attr_reader :segments
-    attr_writer :filter
     attr_reader :path
 
     def initialize(path)
       @path = path.dup
       @segments = parse(path)
       @filter = lambda{|value| value}# default filter does nothing
+      @filter_arity = 1
+    end
+
+    def filter=(f)
+      @filter_arity = f.respond_to?(:arity) ? f.arity : 1
+      @filter = f
     end
 
-    def apply_filter(value)
-      @filter.call(value)
+    def apply_filter(value, context: nil)
+      args = [value]
+      args << context if @filter_arity > 1
+      @filter.call(*args)
     end
 
     def each(&blk)

data/lib/hash_mapper/version.rb

@@ -1,3 +1,3 @@
 module HashMapper
-  VERSION = "0.2.2"
+  VERSION = "0.2.6"
 end

data/spec/hash_mapper_spec.rb

@@ -6,24 +6,24 @@ class OneLevel
 end
 
 describe 'mapping a hash with one level' do
-  
+
   before :each do
-    @from = {:name => 'ismael'}
-    @to   = {:nombre => 'ismael'}
+    @from = {name: 'ismael'}
+    @to   = {nombre: 'ismael'}
   end
-  
+
   it "should map to" do
-    OneLevel.normalize(@from).should == @to
+    expect(OneLevel.normalize(@from)).to eq(@to)
   end
-  
+
   it "should have indifferent access" do
-    OneLevel.normalize({'name' => 'ismael'}).should == @to
+    expect(OneLevel.normalize({'name' => 'ismael'})).to eq(@to)
   end
-  
+
   it "should map back the other way" do
-    OneLevel.denormalize(@to).should == @from
+    expect(OneLevel.denormalize(@to)).to eq(@from)
   end
-  
+
 end
 
 class ManyLevels
@@ -35,35 +35,35 @@ class ManyLevels
 end
 
 describe 'mapping from one nested hash to another' do
-  
+
   before :each do
     @from = {
-      :name => 'ismael',
-      :tagid => 1,
-      :properties => {
-        :type => 'BLAH',
-        :egg => 33
+      name: 'ismael',
+      tagid: 1,
+      properties: {
+        type: 'BLAH',
+        egg: 33
       }
     }
-    
+
     @to   = {
-      :tag_id => 1,
-      :chicken => 33,
-      :tag_attributes => {
-        :name => 'ismael',
-        :type => 'BLAH'
+      tag_id: 1,
+      chicken: 33,
+      tag_attributes: {
+        name: 'ismael',
+        type: 'BLAH'
       }
     }
   end
-  
+
   it "should map from and to different depths" do
-    ManyLevels.normalize(@from).should == @to
+    expect(ManyLevels.normalize(@from)).to eq(@to)
   end
-  
+
   it "should map back the other way" do
-    ManyLevels.denormalize(@to).should == @from
+    expect(ManyLevels.denormalize(@to)).to eq(@from)
   end
-  
+
 end
 
 class DifferentTypes
@@ -73,53 +73,53 @@ class DifferentTypes
 end
 
 describe 'coercing types' do
-  
+
   before :each do
     @from = {
-      :strings => {:a => '10'},
-      :integers =>{:b => 20}
+      strings: {a: '10'},
+      integers: {b: 20}
     }
-    
+
     @to   = {
-      :integers => {:a => 10},
-      :strings  => {:b => '20'}
+      integers: {a: 10},
+      strings: {b: '20'}
     }
   end
-  
+
   it "should coerce values to specified types" do
-    DifferentTypes.normalize(@from).should == @to
+    expect(DifferentTypes.normalize(@from)).to eq(@to)
   end
-  
+
   it "should coerce the other way if specified" do
-    DifferentTypes.denormalize(@to).should == @from
+    expect(DifferentTypes.denormalize(@to)).to eq(@from)
   end
-  
+
 end
 
 
 describe 'arrays in hashes' do
   before :each do
     @from = {
-      :name => ['ismael','sachiyo'],
-      :tagid => 1,
-      :properties => {
-        :type => 'BLAH',
-        :egg => 33
+      name: ['ismael','sachiyo'],
+      tagid: 1,
+      properties: {
+        type: 'BLAH',
+        egg: 33
       }
     }
-    
+
     @to   = {
-      :tag_id => 1,
-      :chicken => 33,
-      :tag_attributes => {
-        :name => ['ismael','sachiyo'],
-        :type => 'BLAH'
+      tag_id: 1,
+      chicken: 33,
+      tag_attributes: {
+        name: ['ismael','sachiyo'],
+        type: 'BLAH'
       }
     }
   end
-  
+
   it "should map array values as normal" do
-    ManyLevels.normalize(@from).should == @to
+    expect(ManyLevels.normalize(@from)).to eq(@to)
   end
 end
 
@@ -129,34 +129,34 @@ class WithArrays
   map from('/arrays/names[1]'),      to('/last_name')
   map from('/arrays/company'),       to('/work/company')
 end
- 
+
 describe "array indexes" do
   before :each do
     @from = {
-      :arrays => {
-        :names => ['ismael','celis'],
-        :company => 'New Bamboo'
+      arrays: {
+        names: ['ismael','celis'],
+        company: 'New Bamboo'
       }
     }
-    @to ={
-      :first_name => 'ismael',
-      :last_name => 'celis',
-      :work       => {:company => 'New Bamboo'}
+    @to = {
+      first_name: 'ismael',
+      last_name: 'celis',
+      work: {company: 'New Bamboo'}
     }
   end
-  
+
   it "should extract defined array values" do
-    WithArrays.normalize(@from).should == @to
+    expect(WithArrays.normalize(@from)).to eq(@to)
   end
-  
+
   it "should map the other way restoring arrays" do
-    WithArrays.denormalize(@to).should == @from
+    expect(WithArrays.denormalize(@to)).to eq(@from)
   end
 end
 
 class PersonWithBlock
   extend HashMapper
-  def self.normalize(h)
+  def self.normalize(*_)
     super
   end
   map from('/names/first'){|n| n.gsub('+','')}, to('/first_name'){|n| "+++#{n}+++"}
@@ -166,64 +166,64 @@ class PersonWithBlockOneWay
   map from('/names/first'), to('/first_name') do |n| "+++#{n}+++" end
 end
 
-describe "with blocks filters" do
+describe "with block filters" do
   before :each do
     @from = {
-      :names => {:first => 'Ismael'}
+      names: {first: 'Ismael'}
     }
     @to = {
-      :first_name => '+++Ismael+++'
+      first_name: '+++Ismael+++'
     }
   end
-  
+
   it "should pass final value through given block" do
-    PersonWithBlock.normalize(@from).should == @to
+    expect(PersonWithBlock.normalize(@from)).to eq(@to)
   end
-  
+
   it "should be able to map the other way using a block" do
-    PersonWithBlock.denormalize(@to).should == @from
+    expect(PersonWithBlock.denormalize(@to)).to eq(@from)
   end
-  
+
   it "should accept a block for just one direction" do
-    PersonWithBlockOneWay.normalize(@from).should == @to
+    expect(PersonWithBlockOneWay.normalize(@from)).to eq(@to)
   end
-  
+
 end
 
 class ProjectMapper
   extend HashMapper
-  
+
   map from('/name'),        to('/project_name')
-  map from('/author_hash'), to('/author'), using(PersonWithBlock)
+  map from('/author_hash'), to('/author'), using: PersonWithBlock
 end
 
 describe "with nested mapper" do
   before :each do
     @from ={
-      :name => 'HashMapper',
-      :author_hash => {
-        :names => {:first => 'Ismael'}
+      name: 'HashMapper',
+      author_hash: {
+        names: {first: 'Ismael'}
       }
     }
     @to = {
-      :project_name => 'HashMapper',
-      :author => {:first_name => '+++Ismael+++'}
+      project_name: 'HashMapper',
+      author: {first_name: '+++Ismael+++'}
     }
   end
-  
+
   it "should delegate nested hashes to another mapper" do
-    ProjectMapper.normalize(@from).should == @to
+    expect(ProjectMapper.normalize(@from)).to eq(@to)
   end
-  
+
   it "should translate the other way using nested hashes" do
-    ProjectMapper.denormalize(@to).should == @from
+    expect(ProjectMapper.denormalize(@to)).to eq(@from)
   end
-  
+
 end
 
 class CompanyMapper
   extend HashMapper
-  
+
   map from('/name'),      to('/company_name')
   map from('/employees'), to('/employees') do |employees_array|
     employees_array.collect{|emp_hash| PersonWithBlock.normalize(emp_hash)}
@@ -232,82 +232,82 @@ end
 
 class CompanyEmployeesMapper
   extend HashMapper
-  
+
   map from('/name'),      to('/company_name')
-  map from('/employees'), to('/employees'), using(PersonWithBlock)
+  map from('/employees'), to('/employees'), using: PersonWithBlock
 end
 
 describe "with arrays of nested hashes" do
   before :each do
     @from = {
-      :name => 'New Bamboo',
-      :employees => [
-        {:names => {:first => 'Ismael'}},
-        {:names => {:first => 'Sachiyo'}},
-        {:names => {:first => 'Pedro'}}
+      name: 'New Bamboo',
+      employees: [
+        {names: {first: 'Ismael'}},
+        {names: {first: 'Sachiyo'}},
+        {names: {first: 'Pedro'}}
       ]
     }
     @to = {
-      :company_name => 'New Bamboo',
-      :employees => [
-        {:first_name => '+++Ismael+++'},
-        {:first_name => '+++Sachiyo+++'},
-        {:first_name => '+++Pedro+++'}
+      company_name: 'New Bamboo',
+      employees: [
+        {first_name: '+++Ismael+++'},
+        {first_name: '+++Sachiyo+++'},
+        {first_name: '+++Pedro+++'}
       ]
     }
   end
-  
+
   it "should pass array value though given block mapper" do
-    CompanyMapper.normalize(@from).should == @to
+    expect(CompanyMapper.normalize(@from)).to eq(@to)
   end
-  
+
   it "should map array elements automatically" do
-    CompanyEmployeesMapper.normalize(@from).should == @to
+    expect(CompanyEmployeesMapper.normalize(@from)).to eq(@to)
   end
 end
 
 class NoKeys
   extend HashMapper
-  
+
   map from('/exists'), to('/exists_yahoo') #in
   map from('/exists_as_nil'), to('/exists_nil') #in
   map from('/foo'), to('/bar') # not in
-  
+
 end
 
 describe "with non-matching maps" do
   before :all do
     @input = {
-      :exists => 1,
-      :exists_as_nil => nil,
-      :doesnt_exist => 2
+      exists: 1,
+      exists_as_nil: nil,
+      doesnt_exist: 2
     }
     @output = {
-      :exists_yahoo => 1
+      exists_yahoo: 1
     }
   end
-  
+
   it "should ignore maps that don't exist" do
-    NoKeys.normalize(@input).should == @output
+    expect(NoKeys.normalize(@input)).to eq(@output)
   end
 end
 
 describe "with false values" do
-  
+
   it "should include values in output" do
-    NoKeys.normalize({'exists' => false}).should == {:exists_yahoo => false}
-    NoKeys.normalize({:exists => false}).should == {:exists_yahoo => false}
+    expect(NoKeys.normalize({'exists' => false})).to eq({exists_yahoo: false})
+    expect(NoKeys.normalize({exists: false})).to eq({exists_yahoo: false})
   end
-  
+
 end
 
 describe "with nil values" do
-  
+
   it "should not include values in output" do
-    NoKeys.normalize({:exists => nil}).should == {}
-    NoKeys.normalize({'exists' => nil}).should == {}
+    expect(NoKeys.normalize({exists: nil})).to eq({})
+    expect(NoKeys.normalize({'exists' => nil})).to eq({})
   end
-  
+
 end
 
 class WithBeforeFilters
@@ -341,22 +341,22 @@ end
 
 describe "before and after filters" do
   before(:all) do
-    @denorm = {:hello   => 'wassup?!'}
-    @norm   = {:goodbye => 'seeya later!'}
+    @denorm = {hello: 'wassup?!'}
+    @norm   = {goodbye: 'seeya later!'}
   end
+
   it "should allow filtering before normalize" do
-    WithBeforeFilters.normalize(@denorm).should == {:goodbye => 'wassup?!', :extra => 'extra wassup?! innit'}
+    expect(WithBeforeFilters.normalize(@denorm)).to eq({goodbye: 'wassup?!', extra: 'extra wassup?! innit'})
   end
   it "should allow filtering before denormalize" do
-    WithBeforeFilters.denormalize(@norm).should == {:hello => 'changed'}
+    expect(WithBeforeFilters.denormalize(@norm)).to eq({hello: 'changed'})
   end
   it "should allow filtering after normalize" do
-    WithAfterFilters.normalize(@denorm).should == [[:goodbye, 'wassup?!']]
+    expect(WithAfterFilters.normalize(@denorm)).to eq([[:goodbye, 'wassup?!']])
   end
   it "should allow filtering after denormalize" do
-    WithAfterFilters.denormalize(@norm).should == {}
+    expect(WithAfterFilters.denormalize(@norm)).to eq({})
   end
-
 end
 
 class NotRelated
@@ -380,23 +380,23 @@ end
 describe "inherited mappers" do
   before :all do
     @from = {
-      :a => 'a',
-      :b => 'b',
-      :c => 'c'
+      a: 'a',
+      b: 'b',
+      c: 'c'
     }
     @to_b ={
-      :a => {:a => 'a'},
-      :b => {:b => 'b'}
+      a: {a: 'a'},
+      b: {b: 'b'}
     }
 
   end
-  
+
   it "should inherit mappings" do
-    B.normalize(@from).should == @to_b
+    expect(B.normalize(@from)).to eq(@to_b)
   end
-  
+
   it "should not affect other mappers" do
-    NotRelated.normalize('n' => 'nn').should == {:n => {:n => 'nn'}}
+    expect(NotRelated.normalize('n' => 'nn')).to eq({n: {n: 'nn'}})
   end
 end
 
@@ -407,23 +407,21 @@ class MixedMappings
 end
 
 describe "dealing with strings and symbols" do
-  
+
   it "should be able to normalize from a nested hash with string keys" do
-    MixedMappings.normalize(
+    expect(MixedMappings.normalize(
       'big' => {'jobs' => 5},
       'timble' => 3.2
-    ).should ==   {:dodo  => 5,
-                   :bingo => {:biscuit => 3.2}}
+    )).to eq({dodo: 5, bingo: {biscuit: 3.2}})
   end
-  
+
   it "should not symbolized keys in value hashes" do
-    MixedMappings.normalize(
+    expect(MixedMappings.normalize(
       'big' => {'jobs' => 5},
       'timble' => {'string key' => 'value'}
-    ).should ==   {:dodo  => 5,
-                   :bingo => {:biscuit => {'string key' => 'value'}}}
+    )).to eq({dodo: 5, bingo: {biscuit: {'string key' => 'value'}}})
   end
-  
+
 end
 
 class DefaultValues
@@ -435,16 +433,16 @@ end
 
 describe "default values" do
   it "should use a default value whenever a key is not set" do
-    DefaultValues.normalize(
+    expect(DefaultValues.normalize(
       'without_default' => 'some_value'
-    ).should == { not_defaulted: 'some_value', defaulted: 'the_default_value' }
+    )).to eq({ not_defaulted: 'some_value', defaulted: 'the_default_value' })
   end
 
   it "should not use a default if a key is set (even if the value is falsy)" do
-    DefaultValues.normalize({
+    expect(DefaultValues.normalize({
         'without_default' => 'some_value',
         'with_default' => false
-      }).should == { not_defaulted: 'some_value', defaulted: false }
+      })).to eq({ not_defaulted: 'some_value', defaulted: false })
   end
 end
 
@@ -488,20 +486,20 @@ end
 
 describe 'multiple before filters' do
   it 'runs before_normalize filters in the order they are defined' do
-    MultiBeforeFilter.normalize({ foo: 'X' }).should == { bar: 'XYZ' }
+    expect(MultiBeforeFilter.normalize({ foo: 'X' })).to eq({ bar: 'XYZ' })
   end
 
   it 'runs before_denormalize filters in the order they are defined' do
-    MultiBeforeFilter.denormalize({ bar: 'X' }).should == { foo: 'BAX' }
+    expect(MultiBeforeFilter.denormalize({ bar: 'X' })).to eq({ foo: 'BAX' })
   end
 
   context 'when the filters are spread across classes' do
     it 'runs before_normalize filters in the order they are defined' do
-      MultiBeforeFilterSubclass.normalize({ foo: 'X' }).should == { bar: 'XYZ!' }
+      expect(MultiBeforeFilterSubclass.normalize({ foo: 'X' })).to eq({ bar: 'XYZ!' })
     end
 
     it 'runs before_denormalize filters in the order they are defined' do
-      MultiBeforeFilterSubclass.denormalize({ bar: 'X' }).should == { foo: 'CBAX' }
+      expect(MultiBeforeFilterSubclass.denormalize({ bar: 'X' })).to eq({ foo: 'CBAX' })
     end
   end
 end
@@ -546,20 +544,20 @@ end
 
 describe 'multiple after filters' do
   it 'runs after_normalize filters in the order they are defined' do
-    MultiAfterFilter.normalize({ baz: '0' }).should == { bat: '012' }
+    expect(MultiAfterFilter.normalize({ baz: '0' })).to eq({ bat: '012' })
   end
 
   it 'runs after_denormalize filters in the order they are defined' do
-    MultiAfterFilter.denormalize({ bat: '0' }).should == { baz: '890' }
+    expect(MultiAfterFilter.denormalize({ bat: '0' })).to eq({ baz: '890' })
   end
 
   context 'when the filters are spread across classes' do
     it 'runs after_normalize filters in the order they are defined' do
-      MultiAfterFilterSubclass.normalize({ baz: '0' }).should == { bat: '0123' }
+      expect(MultiAfterFilterSubclass.normalize({ baz: '0' })).to eq({ bat: '0123' })
     end
 
     it 'runs after_denormalize filters in the order they are defined' do
-      MultiAfterFilterSubclass.denormalize({ bat: '0' }).should == { baz: '7890' }
+      expect(MultiAfterFilterSubclass.denormalize({ bat: '0' })).to eq({ baz: '7890' })
     end
   end
 end
@@ -591,15 +589,58 @@ end
 describe 'with options' do
   context 'when called with options' do
     it 'passes the options to all the filters' do
-      WithOptions.normalize({}, bn: 1, an: 2).should == {bn: 1, an: 2}
-      WithOptions.denormalize({}, bdn: 1, adn: 2).should == {bdn: 1, adn: 2}
+      expect(WithOptions.normalize({}, options: { bn: 1, an: 2 })).to eq({bn: 1, an: 2})
+      expect(WithOptions.denormalize({}, options: { bdn: 1, adn: 2 })).to eq({bdn: 1, adn: 2})
     end
   end
 
   context 'when called without options' do
     it 'stills work' do
-      WithOptions.normalize({}).should == {}
-      WithOptions.denormalize({}).should == {}
+      expect(WithOptions.normalize({})).to eq({})
+      expect(WithOptions.denormalize({})).to eq({})
     end
   end
 end
+
+describe 'passing custom context object' do
+  it 'passes context object down to sub-mappers' do
+    friend_mapper = Class.new do
+      extend HashMapper
+
+      map from('/name'), to('/name')
+
+      def normalize(input, context: , **kargs)
+        context[:names] ||= []
+        context[:names] << input[:name]
+        self.class.normalize(input, context: context, **kargs)
+      end
+    end
+
+    mapper = Class.new do
+      extend HashMapper
+
+      map from('/friends'), to('/friends'), using: friend_mapper.new
+    end
+
+    input = {friends: [{name: 'Ismael', last_name: 'Celis'}, {name: 'Joe'}]}
+    ctx = {}
+    mapper.normalize(input, context: ctx)
+    expect(ctx[:names]).to eq(%w(Ismael Joe))
+  end
+end
+
+describe 'passing context down to filters' do
+  it 'yields context to filters' do
+    mapper = Class.new do
+      extend HashMapper
+
+      map from('/name'), to('/name', &(->(name, ctx) { "#{ctx[:title]} #{name}" }))
+      map from('/age'), to('/age') do |age, ctx|
+        "#{age} #{ctx[:age_suffix]}"
+      end
+    end
+
+    output = mapper.normalize({ name: 'Ismael', age: 43 }, context: { title: 'Mr.', age_suffix: 'years old' })
+    expect(output).to eq({ name: 'Mr. Ismael', age: '43 years old' })
+  end
+end

data/spec/spec_helper.rb

@@ -9,7 +9,7 @@ RSpec.configure do |config|
   config.filter_run focus: true
 
   config.expect_with :rspec do |c|
-    c.syntax = :should
+    c.syntax = :expect
   end
 end
 

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: hash_mapper
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.6
 platform: ruby
 authors:
 - Ismael Celis
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2010-09-21 00:00:00.000000000 Z
+date: 2021-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4'
 - !ruby/object:Gem::Dependency
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.9'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -72,7 +72,7 @@ files:
 homepage: http://github.com/ismasan/hash_mapper
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--charset=UTF-8"
 require_paths:
@@ -88,9 +88,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: Maps input hashes to a normalized format
 test_files: