ismasan-hash_mapper 0.0.2 → 0.0.3

data/README.rdoc

@@ -31,7 +31,7 @@ It is a module so it doesn't get in the way of your inheritance tree.
      }
    }
 
-   ManyLevels.translate(input)
+   ManyLevels.normalize(input)
 
    # outputs:
    	{
@@ -47,7 +47,7 @@ It is a module so it doesn't get in the way of your inheritance tree.
 
 HashMapper was primarily written as a way of mapping data structure in json requests to hashes with structures friendlier to our ActiveRecord models:
 
-   @article = Article.create( ArticleParams.translate(params[:weird_article_data]) )
+   @article = Article.create( ArticleParams.normalize(params[:weird_article_data]) )
 
 You can use HashMapper in your own little hash-like objects:
 
@@ -59,7 +59,7 @@ You can use HashMapper in your own little hash-like objects:
      map from('/names/last'), to('/last_name')
 
      def initialize(input_hash)
-       @hash = self.class.translate(input_hash)
+       @hash = self.class.normalize(input_hash)
      end
 
      def [](k)
@@ -87,10 +87,14 @@ You want to make sure an incoming value get converted to a certain type, so
 
 Do this:
 
-   map from('/one'), to('/one', :to_i)
-   map from('/two'), to('/two', :to_i)
+   map from('/one'), to('/one', &:to_i)
+   map from('/two'), to('/two', &:to_i)
 
-You can pass :to_i, :to_s or anything available method that makes sense.
+You can pass :to_i, :to_s or anything available method that makes sense. Don't forget the block notation (&).
+
+You guessed it. That means that you can actually pass custom blocks to each to() definition as well. The following is similar to the previous example:
+
+   map from('/one), to('/one'){|value| value.to_i}
 
 ==== Custom value filtering
 
@@ -104,17 +108,20 @@ Do this:
      "Mr. #{names[1]}, #{names[0]}"
    end
 
-==== Array access
-
-You want:
-
-{:names => ['Ismael', 'Celis']} converted to {:first_name => 'Ismael', :last_name => 'Celis'}
+=== Mapping in reverse
 
-Do this:
+Cool, you can map one hash into another, but what if I want the opposite operation?
 
-   map from('/names[0]'), to('/first_name')
-   map from('/names[1]'), to('/last_name')
+Just use the denormalize() method instead:
 
+	input = {:first => 'Mark', :last => 'Evans'}
+	
+	output = NameMapper.normalize(input) # => {:first_name => 'Mark', :last_name => 'Evans'}
+	
+	NameMapper.denormalize(output) # => input
+	
+This will work with your block filters and even nested mappers (see below).
+	
 === Advanced usage
 ==== Nested mappers
 
@@ -145,17 +152,17 @@ Define an UserMapper separate from your ProjectMapper, so you reuse them combine
      extend HashMapper
      map from('/project'), 		to('/project_name')
      map from('/url'),			to('/url')
-     map from('/author_names'),	to('/author'), &UserMapper
+     map from('/author_names'),	to('/author'), using(UserMapper)
    end
 
 Now ProjectMapper will delegate parsing of :author_names to UserMapper
 
-   ProjectMapper.translate( input ) # => output
+   ProjectMapper.normalize( input ) # => output
 
 * Note the ampersand in &UserMapper. This is important if you are passing custom classes instead of procs.
 * If you want to implement your own filter class just define to_proc in it.
 
-Let's say you have a CompanyMapper which maps a hash with an array of employees, and you want to reuse UserMapper to map each employee:
+Let's say you have a CompanyMapper which maps a hash with an array of employees, and you want to reuse UserMapper to map each employee. You could:
 
    class CompanyMapper
      map from('/info/name'), 			to('/company_name')
@@ -163,12 +170,31 @@ Let's say you have a CompanyMapper which maps a hash with an array of employees,
      map from('/info/year_founded'),	to('year_founded', :to_i)
 
      map from('/employees'),			to('employees') do |employees_array|
-       employees_array.collect {|emp_hash| UserMapper.translate(emp_hash)}
+       employees_array.collect {|emp_hash| UserMapper.normalize(emp_hash)}
      end
    end
 
+But HashMapper's nested mappers will actually do that for you if a value is an array, so:
+	
+	map from('/employees'),	to('employees'), using(UserMapper)
+	
+... Will map each employee using UserMapper.
+   
 == REQUIREMENTS:
 
+== TODO:
+=== Array access
+
+* See pending specs
+
+You want:
+
+{:names => ['Ismael', 'Celis']} converted to {:first_name => 'Ismael', :last_name => 'Celis'}
+
+Do this:
+
+   map from('/names[0]'), to('/first_name')
+   map from('/names[1]'), to('/last_name')
 
 == INSTALL:
 

data/lib/hash_mapper.rb

@@ -1,84 +1,124 @@
 $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
+# This allows us to call blah(&:some_method) instead of blah{|i| i.some_method }
+unless Symbol.instance_methods.include?('to_proc')
+  class Symbol
+    def to_proc
+      Proc.new {|obj| obj.send(self) }
+    end
+  end
+end
+
 module HashMapper
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
   
   def maps
     @maps ||= []
   end
   
-  def map(from, to, &blk)
-    to.filter = blk if block_given?
-    self.maps << [from, to]
+  def map(from, to, using=nil, &filter)
+    self.maps << Map.new(from, to, using)
+    to.filter = filter if block_given? # Useful if just one block given
   end
   
-  def from(path, coerce_method = nil)
-    PathMap.new(path, coerce_method)
+  def from(path, &filter)
+    path_map = PathMap.new(path)
+    path_map.filter = filter if block_given? # Useful if two blocks given
+    path_map
   end
   
   alias :to :from
   
-  def translate(incoming_hash)
+  def using(mapper_class)
+    mapper_class
+  end
+  
+  def normalize(a_hash)
+    perform_hash_mapping a_hash, :normalize
+  end
+
+  def denormalize(a_hash)
+    perform_hash_mapping a_hash, :denormalize
+  end
+
+  protected
+  
+  def perform_hash_mapping(a_hash, meth)
     output = {}
-    incoming_hash = simbolize_keys(incoming_hash)
-    maps.each do |path_from, path_to|
-        path_to.inject(output){|h,e|
-          if h[e]
-            h[e]
-          else
-            h[e] = (e == path_to.last ? path_to.resolve_value(path_from, incoming_hash) : {})
-          end
-        }
+    a_hash = symbolize_keys(a_hash)
+    maps.each do |m|
+      m.process_into(output, a_hash, meth)
     end
     output
   end
   
   # from http://www.geekmade.co.uk/2008/09/ruby-tip-normalizing-hash-keys-as-symbols/
   #
-  def simbolize_keys(hash)
+  def symbolize_keys(hash)
     hash.inject({}) do |options, (key, value)|
       options[(key.to_sym rescue key) || key] = value
       options
     end
   end
   
-  # This allows us to pass mapper classes as block arguments
+  # Contains PathMaps
+  # Makes them interact
   #
-  def to_proc
-    Proc.new{|*args| self.translate(*args)}
+  class Map
+    
+    attr_reader :path_from, :path_to, :delegated_mapper
+    
+    def initialize(path_from, path_to, delegated_mapper = nil)
+      @path_from, @path_to, @delegated_mapper = path_from, path_to, delegated_mapper
+    end
+    
+    def process_into(output, incoming_hash, meth = :normalize)
+      paths = [path_from, path_to]
+      paths.reverse! unless meth == :normalize
+      value = paths.first.inject(incoming_hash){|h,e| h[e]}
+      value = delegate_to_nested_mapper(value, meth) if delegated_mapper
+      add_value_to_hash!(output, paths.last, value)
+    end
+    
+    protected
+    
+    def delegate_to_nested_mapper(value, meth)
+      v = if value.kind_of?(Array)
+        value.map {|h| delegated_mapper.send(meth, h)}
+      else
+        delegated_mapper.send(meth, value)
+      end
+    end
+    
+    def add_value_to_hash!(hash, path, value)
+      path.inject(hash) do |h,e|
+        if h[e]
+          h[e]
+        else
+          h[e] = (e == path.last ? path.apply_filter(value) : {})
+        end
+      end
+    end
+    
   end
   
+  # contains array of path segments
+  #
   class PathMap
-    
     include Enumerable
     
     attr_reader :segments
-    
     attr_writer :filter
     
-    def initialize(path, coerce_method = nil)
+    def initialize(path)
       @path = path.dup
-      @coerce_method = coerce_method
-      @index = extract_array_index!(path)
       @segments = parse(path)
       @filter = lambda{|value| value}# default filter does nothing
     end
     
-    def resolve_value(another_path, incoming_hash)
-      coerce another_path.extract_from(incoming_hash)
-    end
-    
-    def coerce(value)
-      value = @filter.call(value)
-      return value unless @coerce_method
-      value.send(@coerce_method) rescue value
-    end
-    
-    def extract_from(incoming_hash)
-      value = inject(incoming_hash){|hh,ee| hh[ee]}
-      return value unless @index
-      value.to_a[@index]
+    def apply_filter(value)
+      @filter.call(value)
     end
     
     def each(&blk)
@@ -91,19 +131,8 @@ module HashMapper
     
     private
     
-    def extract_array_index!(path)
-      path.gsub! /(\[[0-9]+\])/, ''
-      if idx = $1
-        idx.gsub(/(\[|\])/, '').to_i
-      else
-        nil
-      end
-    end
-    
     def parse(path)
-      p = path.split('/')
-      p.shift
-      p.collect{|e| e.to_sym}
+      path.sub(/^\//,'').split('/').map(&:to_sym)
     end
     
   end

data/spec/hash_mapper_spec.rb

@@ -13,11 +13,15 @@ describe 'mapping a hash wit one level' do
   end
   
   it "should map to" do
-    OneLevel.translate(@from).should == @to
+    OneLevel.normalize(@from).should == @to
   end
   
   it "should have indifferent access" do
-    OneLevel.translate({'name' => 'ismael'}).should == @to
+    OneLevel.normalize({'name' => 'ismael'}).should == @to
+  end
+  
+  it "should map back the other way" do
+    OneLevel.denormalize(@to).should == @from
   end
   
 end
@@ -53,15 +57,19 @@ describe 'mapping from one nested hash to another' do
   end
   
   it "should map from and to different depths" do
-    ManyLevels.translate(@from).should == @to
+    ManyLevels.normalize(@from).should == @to
+  end
+  
+  it "should map back the other way" do
+    ManyLevels.denormalize(@to).should == @from
   end
   
 end
 
 class DifferentTypes
   extend HashMapper
-  map from('/strings/a'),      to('/integers/a',:to_i)
-  map from('/integers/b'),     to('/strings/b',:to_s)
+  map from('/strings/a',  &:to_s),      to('/integers/a', &:to_i)
+  map from('/integers/b', &:to_i),     to('/strings/b',   &:to_s)
 end
 
 describe 'coercing types' do
@@ -79,7 +87,11 @@ describe 'coercing types' do
   end
   
   it "should coerce values to specified types" do
-    DifferentTypes.translate(@from).should == @to
+    DifferentTypes.normalize(@from).should == @to
+  end
+  
+  it "should coerce the other way if specified" do
+    DifferentTypes.denormalize(@to).should == @from
   end
   
 end
@@ -107,7 +119,7 @@ describe 'arrays in hashes' do
   end
   
   it "should map array values as normal" do
-    ManyLevels.translate(@from).should == @to
+    ManyLevels.normalize(@from).should == @to
   end
 end
 
@@ -117,7 +129,7 @@ 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 = {
@@ -134,16 +146,26 @@ describe "array indexes" do
   end
   
   it "should extract defined array values" do
-    WithArrays.translate(@from).should == @to
+    pending "must reimplement for normalize and denormalize"
+    WithArrays.normalize(@from).should == @to
+  end
+  
+  it "should map the other way restoring arrays" do
+    pending "must reimplement for normalize and denormalize"
+    WithArrays.denormalize(@from).should == @to
   end
 end
 
 class PersonWithBlock
   extend HashMapper
-  
-  map from('/names/first'), to('/first_name') do |name|
-    "+++ #{name} +++"
+  def self.normalize(h)
+    super
   end
+  map from('/names/first'){|n| n.gsub('+','')}, to('/first_name'){|n| "+++#{n}+++"}
+end
+class PersonWithBlockOneWay
+  extend HashMapper
+  map from('/names/first'), to('/first_name') do |n| "+++#{n}+++" end
 end
 
 describe "with blocks filters" do
@@ -152,20 +174,29 @@ describe "with blocks filters" do
       :names => {:first => 'Ismael'}
     }
     @to = {
-      :first_name => '+++ Ismael +++'
+      :first_name => '+++Ismael+++'
     }
   end
   
   it "should pass final value through given block" do
-    PersonWithBlock.translate(@from).should == @to
+    PersonWithBlock.normalize(@from).should == @to
+  end
+  
+  it "should be able to map the other way using a block" do
+    PersonWithBlock.denormalize(@to).should == @from
   end
+  
+  it "should accept a block for just one direction" do
+    PersonWithBlockOneWay.normalize(@from).should == @to
+  end
+  
 end
 
 class ProjectMapper
   extend HashMapper
   
   map from('/name'),        to('/project_name')
-  map from('/author_hash'), to('/author'), &PersonWithBlock
+  map from('/author_hash'), to('/author'), using(PersonWithBlock)
 end
 
 describe "with nested mapper" do
@@ -178,13 +209,18 @@ describe "with nested mapper" do
     }
     @to = {
       :project_name => 'HashMapper',
-      :author => {:first_name => '+++ Ismael +++'}
+      :author => {:first_name => '+++Ismael+++'}
     }
   end
   
   it "should delegate nested hashes to another mapper" do
-    ProjectMapper.translate(@from).should == @to
+    ProjectMapper.normalize(@from).should == @to
   end
+  
+  it "should translate the other way using nested hashes" do
+    ProjectMapper.denormalize(@to).should == @from
+  end
+  
 end
 
 class CompanyMapper
@@ -192,10 +228,17 @@ class CompanyMapper
   
   map from('/name'),      to('/company_name')
   map from('/employees'), to('/employees') do |employees_array|
-    employees_array.collect{|emp_hash| PersonWithBlock.translate(emp_hash)}
+    employees_array.collect{|emp_hash| PersonWithBlock.normalize(emp_hash)}
   end
 end
 
+class CompanyEmployeesMapper
+  extend HashMapper
+  
+  map from('/name'),      to('/company_name')
+  map from('/employees'), to('/employees'), using(PersonWithBlock)
+end
+
 describe "with arrays of nested hashes" do
   before :each do
     @from = {
@@ -209,15 +252,19 @@ describe "with arrays of nested hashes" do
     @to = {
       :company_name => 'New Bamboo',
       :employees => [
-        {:first_name => '+++ Ismael +++'},
-        {:first_name => '+++ Sachiyo +++'},
-        {:first_name => '+++ Pedro +++'}
+        {:first_name => '+++Ismael+++'},
+        {:first_name => '+++Sachiyo+++'},
+        {:first_name => '+++Pedro+++'}
       ]
     }
   end
   
   it "should pass array value though given block mapper" do
-    CompanyMapper.translate(@from).should == @to
+    CompanyMapper.normalize(@from).should == @to
+  end
+  
+  it "should map array elements automatically" do
+    CompanyEmployeesMapper.normalize(@from).should == @to
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ismasan-hash_mapper
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Ismael Celis
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-31 00:00:00 -08:00
+date: 2009-02-03 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency