newbamboo-hash_mapper 0.0.5 → 0.0.6

data/README.rdoc

@@ -201,8 +201,8 @@ They all yield a block with 2 arguments - the hash you are mapping from and the
     map from('/raw'), to('/fried')
     
     before_normalize do |input, output|
-      output[:time] = Time.now     # the normalized hash will now be {:fried => 'blah', :time => <time object> }
-      output
+      input['raw'] ||= 'please'     # this will give 'raw' a default value 
+      input
     end
     
     after_denormalize do |input, output|
@@ -211,7 +211,7 @@ They all yield a block with 2 arguments - the hash you are mapping from and the
 
   end
 
-Important: note that you need to return the output each time.
+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.
 
    

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)
@@ -57,14 +81,15 @@ module HashMapper
   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}"
-    output = before_filter.call(a_hash, output) if before_filter
+    a_hash = before_filter.call(a_hash, output) if before_filter
     # Do the mapping
     a_hash = symbolize_keys(a_hash)
     maps.each do |m|
@@ -109,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
@@ -177,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
   
@@ -296,14 +297,15 @@ end
 class WithBeforeFilters
   extend HashMapper
   map from('/hello'), to('/goodbye')
+  map from('/extra'), to('/extra')
 
   before_normalize do |input, output|
-    output[:this_is] = "extra #{input[:hello]} innit"
-    output
+    input[:extra] = "extra #{input[:hello]} innit"
+    input
   end
   before_denormalize do |input, output|
     input[:goodbye] = 'changed'
-    output
+    input
   end
 end
 
@@ -327,7 +329,7 @@ describe "before and after filters" do
     @norm   = {:goodbye => 'seeya later!'}
   end
   it "should allow filtering before normalize" do
-    WithBeforeFilters.normalize(@denorm).should == {:goodbye => 'wassup?!', :this_is => 'extra wassup?! innit'}
+    WithBeforeFilters.normalize(@denorm).should == {:goodbye => 'wassup?!', :extra => 'extra wassup?! innit'}
   end
   it "should allow filtering before denormalize" do
     WithBeforeFilters.denormalize(@norm).should == {:hello => 'changed'}
@@ -339,4 +341,45 @@ describe "before and after filters" 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: newbamboo-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: