hash_mapper 0.2.0 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4ccb1b38f4a738cf5b7f1a147cc998463f14246e
-  data.tar.gz: bb40000c4e4f03cc7cda222bea3f9182189e7faf
+SHA256:
+  metadata.gz: 3bddd2af1ce1793dad8c629df875b3896616603d26ca85d1373acf19bc366c8a
+  data.tar.gz: c3c7d3ea740effd2faa8e870025e1bdff510e99fd6d03981be91facb23f014b1
 SHA512:
-  metadata.gz: 71dc27f23fae5c544caa5389fd7a31c1ae0bd04cfa84b007dfc18197f4dbee1349cbd7d677d59e8420505dcd2fa4c981f4c792429580fe05b656f9fad2046dc5
-  data.tar.gz: 68946b78bc3dc7dd2d0b7d287649125b63bb0ffb5f357fddac4cbd48fd1c944b1b7f3880813d0cce8d73b05605e49c8e19e47cec72acb6c9513a8cdf2b5ee596
+  metadata.gz: ae9aa35b6b73b898c1db69c1fe154578035286f1ed4bc77d8d413aa44b8225b8425c0b40f897236a07e9ba2b96520bc7c09b80d63d286cd4e2a0f8f1ecc05822
+  data.tar.gz: 5c708bb349d7aa178a5461e3e6076cb838ee3aef005eebc7437f85b135dc79c268f7dc08436211959f637ceb94a34ce0e291cc3eb7990a76757f15b2b665e797

data/README.md

@@ -1,3 +1,5 @@
+[ ![Codeship Status for ismasan/hash_mapper](https://www.codeship.io/projects/85d172c0-4668-0132-e925-7a7d3d72b19b/status)](https://www.codeship.io/projects/45296)
+
 # hash_mapper
 
 * http://ismasan.github.com/hash_mapper/
@@ -5,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:
@@ -59,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')
 
@@ -87,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'}
@@ -95,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}
 ```
 
@@ -146,7 +148,7 @@ Do this:
 
 ```ruby
 map from('/names'), to('/user') do |names|
-  "Mr. #{names[1]}, #{names[0]}"
+  "Mr. #{names[:last]}, #{names[:first]}"
 end
 ```
 
@@ -163,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:
@@ -250,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.
@@ -266,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
@@ -282,7 +284,29 @@ end
 Important: note that for before filters, you need to return the (modified) input, and for after filters, you need to return the output.
 Note also that 'output' is correct at the time of the filter, i.e. before_normalize yields 'output' as an empty hash, while after_normalize yields it as an already normalized hash.
 
-   
+It is possible to define multiple filters of a given type. These are run in the order in which they are defined. A common use case might be to define a `before_normalize` filter in a parent class and a child class. The output from the previous invocation of the filter is passed as the input of the next invocation.
+
+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
+  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({}, options: { no_default: true })
+EggMapper.denormalize({fried: 4})
+```
+
+
 ## REQUIREMENTS:
 
 ## TODO:
@@ -304,6 +328,7 @@ Note also that 'output' is correct at the time of the filter, i.e. before_normal
 * Jdeveloper (Contributor - http://github.com/jdeveloper)
 * nightscape (Contributor - http://github.com/nightscape)
 * radamanthus (Contributor - http://github.com/radamanthus)
+* Tom Wey (Contributor - (https://github.com/tjmw)
 
 ## LICENSE:
 

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

@@ -39,11 +39,21 @@ 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
-      class_attribute :maps
+      class_attribute :maps, :before_normalize_filters,
+        :before_denormalize_filters, :after_normalize_filters,
+        :after_denormalize_filters
+
       self.maps = []
+      self.before_normalize_filters = []
+      self.before_denormalize_filters = []
+      self.after_normalize_filters = []
+      self.after_denormalize_filters = []
     end
   end
 
@@ -66,47 +76,49 @@ module HashMapper
     { using: mapper_class }
   end
 
-  def normalize(a_hash)
-    perform_hash_mapping a_hash, :normalize
+  def normalize(a_hash, options: DEFAULT_OPTIONS, context: nil)
+    perform_hash_mapping a_hash, :normalize, options: options, context: context
   end
 
-  def denormalize(a_hash)
-    perform_hash_mapping a_hash, :denormalize
+  def denormalize(a_hash, options: DEFAULT_OPTIONS, context: nil)
+    perform_hash_mapping a_hash, :denormalize, options: options, context: context
   end
 
   def before_normalize(&blk)
-    @before_normalize = blk
+    self.before_normalize_filters = self.before_normalize_filters + [blk]
   end
 
   def before_denormalize(&blk)
-    @before_denormalize = blk
+    self.before_denormalize_filters = self.before_denormalize_filters + [blk]
   end
 
   def after_normalize(&blk)
-    @after_normalize = blk
+    self.after_normalize_filters = self.after_normalize_filters + [blk]
   end
 
   def after_denormalize(&blk)
-    @after_denormalize = blk
+    self.after_denormalize_filters = self.after_denormalize_filters + [blk]
   end
 
   protected
 
-
-  def perform_hash_mapping(a_hash, meth)
+  def perform_hash_mapping(a_hash, meth, options:, context:)
     output = {}
-    # Before filter
-    before_filter = instance_eval "@before_#{meth}"
-    a_hash = before_filter.call(a_hash, output) if before_filter
+
+    # Before filters
+    a_hash = self.send(:"before_#{meth}_filters").inject(a_hash) do |memo, filter|
+      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, options)
     end
-    # After filter
-    after_filter = instance_eval "@after_#{meth}"
-    output = after_filter.call(a_hash, output) if after_filter
-    # Return
-    output
   end
 
   # Contains PathMaps
@@ -120,32 +132,32 @@ 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)
+    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)
     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
+      if value == NO_VALUE
+        if default_value == NO_DEFAULT
           return
         else
           value = default_value
@@ -154,14 +166,14 @@ module HashMapper
       add_value_to_hash!(output, path, value)
     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
 

data/lib/hash_mapper/version.rb

@@ -1,3 +1,3 @@
 module HashMapper
-  VERSION = "0.2.0"
+  VERSION = "0.2.5"
 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,15 +433,198 @@ 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
+
+class MultiBeforeFilter
+  extend HashMapper
+
+  before_normalize do |input, output|
+    input[:foo] << 'Y'
+    input
+  end
+
+  before_normalize do |input, output|
+    input[:foo] << 'Z'
+    input
+  end
+
+  before_denormalize do |input, output|
+    input[:bar].prepend('A')
+    input
+  end
+
+  before_denormalize do |input, output|
+    input[:bar].prepend('B')
+    input
+  end
+
+  map from('/foo'), to('bar')
+end
+
+class MultiBeforeFilterSubclass < MultiBeforeFilter
+  before_normalize do |input, output|
+    input[:foo] << '!'
+    input
+  end
+
+  before_denormalize do |input, output|
+    input[:bar].prepend('C')
+    input
+  end
+end
+
+describe 'multiple before filters' do
+  it 'runs before_normalize filters in the order they are defined' do
+    expect(MultiBeforeFilter.normalize({ foo: 'X' })).to eq({ bar: 'XYZ' })
+  end
+
+  it 'runs before_denormalize filters in the order they are defined' do
+    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
+      expect(MultiBeforeFilterSubclass.normalize({ foo: 'X' })).to eq({ bar: 'XYZ!' })
+    end
+
+    it 'runs before_denormalize filters in the order they are defined' do
+      expect(MultiBeforeFilterSubclass.denormalize({ bar: 'X' })).to eq({ foo: 'CBAX' })
+    end
+  end
+end
+
+class MultiAfterFilter
+  extend HashMapper
+
+  map from('/baz'), to('bat')
+
+  after_normalize do |input, output|
+    output[:bat] << '1'
+    output
+  end
+
+  after_normalize do |input, output|
+    output[:bat] << '2'
+    output
+  end
+
+  after_denormalize do |input, output|
+    output[:baz].prepend('9')
+    output
+  end
+
+  after_denormalize do |input, output|
+    output[:baz].prepend('8')
+    output
+  end
+end
+
+class MultiAfterFilterSubclass < MultiAfterFilter
+  after_normalize do |input, output|
+    output[:bat] << '3'
+    output
+  end
+
+  after_denormalize do |input, output|
+    output[:baz].prepend('7')
+    output
+  end
+end
+
+describe 'multiple after filters' do
+  it 'runs after_normalize filters in the order they are defined' do
+    expect(MultiAfterFilter.normalize({ baz: '0' })).to eq({ bat: '012' })
+  end
+
+  it 'runs after_denormalize filters in the order they are defined' do
+    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
+      expect(MultiAfterFilterSubclass.normalize({ baz: '0' })).to eq({ bat: '0123' })
+    end
+
+    it 'runs after_denormalize filters in the order they are defined' do
+      expect(MultiAfterFilterSubclass.denormalize({ bat: '0' })).to eq({ baz: '7890' })
+    end
+  end
+end
+
+class WithOptions
+  extend HashMapper
+
+  before_normalize do |input, output, opts|
+    output[:bn] = opts[:bn] if opts[:bn]
+    input
+  end
+
+  after_normalize do |input, output, opts|
+    output[:an] = opts[:an] if opts[:an]
+    output
+  end
+
+  before_denormalize do |input, output, opts|
+    output[:bdn] = opts[:bdn] if opts[:bdn]
+    input
+  end
+
+  after_denormalize do |input, output, opts|
+    output[:adn] = opts[:adn] if opts[:adn]
+    output
+  end
+end
+
+describe 'with options' do
+  context 'when called with options' do
+    it 'passes the options to all the filters' do
+      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
+      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

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,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: hash_mapper
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.5
 platform: ruby
 authors:
 - Ismael Celis
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2010-09-21 00:00:00.000000000 Z
+date: 2020-09-02 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
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     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
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Tiny module that allows you to easily adapt from one hash structure to
@@ -59,7 +59,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - History.txt
 - README.md
@@ -72,25 +72,24 @@ files:
 homepage: http://github.com/ismasan/hash_mapper
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
-- --charset=UTF-8
+- "--charset=UTF-8"
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.0.3
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: Maps input hashes to a normalized format
 test_files: