ismasan-hash_mapper 0.0.5 → 0.0.6

data/README.rdoc

@@ -188,6 +188,32 @@ But HashMapper's nested mappers will actually do that for you if a value is an a
 	map from('/employees'),	to('employees'), using(UserMapper)
 	
 ... Will map each employee using UserMapper.
+
+==== Before and after filters
+
+Sometimes you will need some slightly more complex processing on the whole hash, either before or after normalizing/denormalizing.
+
+For this you can use the class methods before_normalize, before_denormalize, after_normalize and after_denormalize.
+
+They all yield a block with 2 arguments - the hash you are mapping from and the hash you are mapping to, e.g.
+
+  class EggMapper
+    map from('/raw'), to('/fried')
+    
+    before_normalize do |input, output|
+      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
+
+  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.
+
    
 == REQUIREMENTS:
 
@@ -205,8 +231,9 @@ But HashMapper's nested mappers will actually do that for you if a value is an a
 
 == Credits:
 
-* Ismael Celis (http://www.estadobeta.com)
-* Mark Evans
+* Ismael Celis (Author - http://www.estadobeta.com)
+* Mark Evans (Contributor - http://github.com/markevans)
+* Jdeveloper (Contributor - http://github.com/jdeveloper)
 
 == LICENSE:
 

data/lib/hash_mapper.rb

@@ -1,6 +1,15 @@
 $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
+begin
+  require 'active_support'
+rescue LoadError
+  require 'rubygems'
+  require 'active_support'
+end
+
+
+
 # This allows us to call blah(&:some_method) instead of blah{|i| i.some_method }
 unless Symbol.instance_methods.include?('to_proc')
   class Symbol
@@ -10,11 +19,26 @@ unless Symbol.instance_methods.include?('to_proc')
   end
 end
 
+# http://rpheath.com/posts/341-ruby-inject-with-index
+unless Array.instance_methods.include?("inject_with_index")
+  module Enumerable
+    def inject_with_index(injected)
+      each_with_index{ |obj, index| injected = yield(injected, obj, index) }
+      injected
+    end
+  end
+end
+
 module HashMapper
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
   
-  def maps
-    @maps ||= []
+  # we need this for inheritable mappers, which is annoying because it needs ActiveSupport, kinda overkill.
+  #
+  def self.extended(base)
+    base.class_eval do
+      write_inheritable_attribute :maps, []
+      class_inheritable_accessor :maps
+    end
   end
   
   def map(from, to, using=nil, &filter)
@@ -41,15 +65,40 @@ module HashMapper
   def denormalize(a_hash)
     perform_hash_mapping a_hash, :denormalize
   end
+  
+  def before_normalize(&blk)
+    @before_normalize = blk
+  end
+
+  def before_denormalize(&blk)
+    @before_denormalize = blk
+  end
 
+  def after_normalize(&blk)
+    @after_normalize = blk
+  end
+
+  def after_denormalize(&blk)
+    @after_denormalize = blk
+  end
+  
   protected
+
   
   def perform_hash_mapping(a_hash, meth)
     output = {}
+    # Before filter
+    before_filter = instance_eval "@before_#{meth}"
+    a_hash = before_filter.call(a_hash, output) if before_filter
+    # Do the mapping
     a_hash = symbolize_keys(a_hash)
     maps.each do |m|
       m.process_into(output, a_hash, meth)
     end
+    # After filter
+    after_filter = instance_eval "@after_#{meth}"
+    output = after_filter.call(a_hash, output) if after_filter
+    # Return
     output
   end
   
@@ -85,50 +134,35 @@ module HashMapper
     
     def get_value_from_input(output, input, path, meth)
       value = path.inject(input) do |h,e|
-        throw :no_value unless h.has_key?(e[0].to_sym)
-        e[1].nil? ? h[e[0].to_sym] : h[e[0].to_sym][e[1].to_i]
-        #h[e[0].to_sym]
+        throw :no_value if h[e].nil?#.has_key?(e)
+        h[e]
       end
-      value = delegate_to_nested_mapper(value, meth) if delegated_mapper
-      value
+      delegated_mapper ? delegate_to_nested_mapper(value, meth) : value
     end
     
     
     def delegate_to_nested_mapper(value, meth)
-      v = if value.kind_of?(Array)
+      case value
+      when Array
         value.map {|h| delegated_mapper.send(meth, h)}
+      when nil
+        throw :no_value
       else
         delegated_mapper.send(meth, value)
       end
     end
     
     def add_value_to_hash!(hash, path, value)
-      path.inject(hash) do |h,e|
-        if contained?(h,e)
-          if e[1].nil? 
-            h[e[0].to_sym] 
-          else 
-            if e == path.last
-              h[e[0].to_sym][e[1].to_i] = value
-            end
-            h[e[0].to_sym][e[1].to_i]
-          end
+      path.inject_with_index(hash) do |h,e,i|
+        if h[e]
+          h[e]
         else
-          if e[1].nil?
-            h[e[0].to_sym] = (e == path.last ? path.apply_filter(value) : {})
-          else
-            h[e[0].to_sym] = []
-            h[e[0].to_sym][e[1].to_i] = (e == path.last ? path.apply_filter(value) : {})
-          end
+          h[e] = (i == path.size-1 ? path.apply_filter(value) : {})
         end
       end
+      
     end
     
-    def contained?(h,e)
-      e[1].nil? ? h[e[0].to_sym] : h[e[0].to_sym][e[1].to_i].nil?
-    rescue
-      false
-    end
   end
   
   # contains array of path segments
@@ -153,21 +187,24 @@ module HashMapper
       @segments.each(&blk)
     end
     
+    def first
+      @segments.first
+    end
+    
     def last
       @segments.last
     end
     
+    def size
+      @segments.size
+    end
+    
     private
     
     def parse(path)
-      #path.sub(/^\//,'').split('/').map(&:to_sym)
-      path.sub(/^\//,'').split('/').map{ |p| key_index p }
-    end
-    
-    def key_index(p)
-      p =~ /\[[0-9]+\]$/ ? p.sub(/\[([0-9]+)\]$/,' \1').split(' ') : [p,nil]
+      path.sub(/^\//,'').split('/').map(&:to_sym)
     end
     
   end
   
-end
+end

data/spec/hash_mapper_spec.rb

@@ -146,10 +146,12 @@ describe "array indexes" do
   end
   
   it "should extract defined array values" do
+    pending
     WithArrays.normalize(@from).should == @to
   end
   
   it "should map the other way restoring arrays" do
+    pending
     WithArrays.denormalize(@to).should == @from
   end
 end
@@ -283,8 +285,7 @@ describe "with non-matching maps" do
       :doesnt_exist => 2
     }
     @output = {
-      :exists_yahoo => 1,
-      :exists_nil => nil
+      :exists_yahoo => 1
     }
   end
   
@@ -293,3 +294,92 @@ describe "with non-matching maps" do
   end
 end
 
+class WithBeforeFilters
+  extend HashMapper
+  map from('/hello'), to('/goodbye')
+  map from('/extra'), to('/extra')
+
+  before_normalize do |input, output|
+    input[:extra] = "extra #{input[:hello]} innit"
+    input
+  end
+  before_denormalize do |input, output|
+    input[:goodbye] = 'changed'
+    input
+  end
+end
+
+class WithAfterFilters
+  extend HashMapper
+  map from('/hello'), to('/goodbye')
+
+  after_normalize do |input, output|
+    output = output.to_a
+    output
+  end
+  after_denormalize do |input, output|
+    output.delete(:hello)
+    output
+  end
+end
+
+describe "before and after filters" do
+  before(:all) do
+    @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'}
+  end
+  it "should allow filtering before denormalize" do
+    WithBeforeFilters.denormalize(@norm).should == {:hello => 'changed'}
+  end
+  it "should allow filtering after normalize" do
+    WithAfterFilters.normalize(@denorm).should == [[:goodbye, 'wassup?!']]
+  end
+  it "should allow filtering after denormalize" do
+    WithAfterFilters.denormalize(@norm).should == {}
+  end
+
+end
+
+class NotRelated
+  extend HashMapper
+  map from('/n'), to('/n/n')
+end
+
+class A
+  extend HashMapper
+  map from('/a'), to('/a/a')
+end
+
+class B < A
+  map from('/b'), to('/b/b')
+end
+
+class C < B
+  map from('/c'), to('/c/c')
+end
+
+describe "inherited mappers" do
+  before :all do
+    @from = {
+      :a => 'a',
+      :b => 'b',
+      :c => 'c'
+    }
+    @to_b ={
+      :a => {:a => 'a'},
+      :b => {:b => 'b'}
+    }
+
+  end
+  
+  it "should inherit mappings" do
+    B.normalize(@from).should == @to_b
+  end
+  
+  it "should not affect other mappers" do
+    NotRelated.normalize('n' => 'nn').should == {:n => {:n => 'nn'}}
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ismasan-hash_mapper
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors: 
 - Ismael Celis
@@ -9,11 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-08 00:00:00 -08:00
+date: 2009-02-16 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: newgem
+  type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -23,6 +24,7 @@ dependencies:
     version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
+  type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: