newbamboo-hash_mapper 0.0.5

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2009-01-29
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,13 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+lib/hash_mapper.rb
+script/console
+script/destroy
+script/generate
+spec/hash_mapper_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/rspec.rake

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on hash_mapper, see http://hash_mapper.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,261 @@
+= hash_mapper
+
+* http://github.com/ismasan/hash_mapper
+
+== 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:
+
+It is a module so it doesn't get in the way of your inheritance tree.
+
+== SYNOPSIS:
+
+   class ManyLevels
+     extend HashMapper
+     map from('/name'),            to('/tag_attributes/name')
+     map from('/properties/type'), to('/tag_attributes/type')
+     map from('/tagid'),           to('/tag_id')
+     map from('/properties/egg'),  to('/chicken')
+   end
+
+   input = 	{
+     :name => 'ismael',
+     :tagid => 1,
+     :properties => {
+       :type => 'BLAH',
+       :egg => 33
+     }
+   }
+
+   ManyLevels.normalize(input)
+
+   # outputs:
+   	{
+     :tag_id => 1,
+     :chicken => 33,
+     :tag_attributes => {
+       :name => 'ismael',
+       :type => 'BLAH'
+     }
+   }
+
+=== Uses:
+
+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.normalize(params[:weird_article_data]) )
+
+You can use HashMapper in your own little hash-like objects:
+
+   class NiceHash
+     include Enumerable
+     extend HashMap
+     
+     map from('/names/first'), to('/first_name')
+     map from('/names/last'), to('/last_name')
+
+     def initialize(input_hash)
+       @hash = self.class.normalize(input_hash)
+     end
+
+     def [](k)
+       @hash[k]
+     end
+
+     def []=(k,v)
+       @hash[k] = v
+     end
+
+     def each(&block)
+       @hash.each(&block)
+     end
+   end
+
+   @user = User.new(NiceHash.new(params))
+
+=== Options:
+
+==== Coercing values
+
+You want to make sure an incoming value get converted to a certain type, so 
+
+{'one' => '1', 'two' => '2'} gets translated to {:one => 1, :two => 2}
+
+Do this:
+
+   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. 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
+
+You want to pass the final value of a key through a custom filter:
+
+{:names => {:first => 'Ismael', :last => 'Celis'}} gets translated to {:user => 'Mr. Celis, Ismael'}
+
+Do this:
+
+   map from('/names'), to('/user') do |names|
+     "Mr. #{names[1]}, #{names[0]}"
+   end
+
+=== Mapping in reverse
+
+Cool, you can map one hash into another, but what if I want the opposite operation?
+
+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
+==== Array access
+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')
+==== Nested mappers
+
+You want to map nested structures delegating to different mappers:
+
+From this:
+input = {
+	:project 		=> 'HashMapper',
+	:url			=> 'http://github.com/ismasan/hash_mapper',
+	:author_names	=> {:first => 'Ismael', :last => 'Celis'}
+}
+To this:
+output = {
+	:project_name	=> 'HashMapper',
+	:url			=> 'http://github.com/ismasan/hash_mapper',
+	:author			=> {:first_name => 'Ismael', :last_name => 'Celis'}
+}
+
+Define an UserMapper separate from your ProjectMapper, so you reuse them combined or standalone
+
+   class UserMapper
+     extend HashMapper
+     map from('/first'),	to('/first_name')
+     map from('/last'),		to('/lastt_name')
+   end
+
+   class ProjectMapper
+     extend HashMapper
+     map from('/project'), 		to('/project_name')
+     map from('/url'),			to('/url')
+     map from('/author_names'),	to('/author'), using(UserMapper)
+   end
+
+Now ProjectMapper will delegate parsing of :author_names to UserMapper
+
+   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. You could:
+
+   class CompanyMapper
+     map from('/info/name'), 			to('/company_name')
+     map form('/info/address'),			to('/company_address')
+     map from('/info/year_founded'),	to('year_founded', :to_i)
+
+     map from('/employees'),			to('employees') do |employees_array|
+       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.
+
+==== 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|
+      output[:time] = Time.now     # the normalized hash will now be {:fried => 'blah', :time => <time object> }
+      output
+    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 you need to return the output each time.
+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:
+
+== TODO:
+
+== INSTALL:
+
+# If you haven't done this already:
+
+   gem sources -a http://gems.github.com
+
+# Now install
+
+   sudo gem install ismasan-hash_mapper
+
+== Credits:
+
+* Ismael Celis (Author - http://www.estadobeta.com)
+* Mark Evans (Contributor - http://github.com/markevans)
+* Jdeveloper (Contributor - http://github.com/jdeveloper)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Ismael Celis
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,28 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/hash_mapper'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('hash_mapper', HashMapper::VERSION) do |p|
+  p.developer('Ismael Celis', 'ismaelct@gmail.com')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  p.rubyforge_name       = p.name # TODO this is default value
+  # p.extra_deps         = [
+  #   ['activesupport','>= 2.0.2'],
+  # ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/lib/hash_mapper.rb

@@ -0,0 +1,197 @@
+$:.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.5'
+  
+  def maps
+    @maps ||= []
+  end
+  
+  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, &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 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
+  
+  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}"
+    output = 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
+  
+  # from http://www.geekmade.co.uk/2008/09/ruby-tip-normalizing-hash-keys-as-symbols/
+  #
+  def symbolize_keys(hash)
+    hash.inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+  
+  # Contains PathMaps
+  # Makes them interact
+  #
+  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, input, meth = :normalize)
+      path_1, path_2 = (meth == :normalize ? [path_from, path_to] : [path_to, path_from])
+      catch :no_value do
+        value = get_value_from_input(output, input, path_1, meth)
+        add_value_to_hash!(output, path_2, value)
+      end
+    end
+    
+    protected
+    
+    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]
+      end
+      value = delegate_to_nested_mapper(value, meth) if delegated_mapper
+      value
+    end
+    
+    
+    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 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
+        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
+        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
+  #
+  class PathMap
+    include Enumerable
+    
+    attr_reader :segments
+    attr_writer :filter
+    
+    def initialize(path)
+      @path = path.dup
+      @segments = parse(path)
+      @filter = lambda{|value| value}# default filter does nothing
+    end
+    
+    def apply_filter(value)
+      @filter.call(value)
+    end
+    
+    def each(&blk)
+      @segments.each(&blk)
+    end
+    
+    def last
+      @segments.last
+    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]
+    end
+    
+  end
+  
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/hash_mapper.rb'}"
+puts "Loading hash_mapper gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/hash_mapper_spec.rb

@@ -0,0 +1,342 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+class OneLevel
+  extend HashMapper
+  map from('/name'),            to('/nombre')
+end
+
+describe 'mapping a hash wit one level' do
+  
+  before :each do
+    @from = {:name => 'ismael'}
+    @to   = {:nombre => 'ismael'}
+  end
+  
+  it "should map to" do
+    OneLevel.normalize(@from).should == @to
+  end
+  
+  it "should have indifferent access" do
+    OneLevel.normalize({'name' => 'ismael'}).should == @to
+  end
+  
+  it "should map back the other way" do
+    OneLevel.denormalize(@to).should == @from
+  end
+  
+end
+
+class ManyLevels
+  extend HashMapper
+  map from('/name'),            to('/tag_attributes/name')
+  map from('/properties/type'), to('/tag_attributes/type')
+  map from('/tagid'),           to('/tag_id')
+  map from('/properties/egg'),  to('/chicken')
+end
+
+describe 'mapping from one nested hash to another' do
+  
+  before :each do
+    @from = {
+      :name => 'ismael',
+      :tagid => 1,
+      :properties => {
+        :type => 'BLAH',
+        :egg => 33
+      }
+    }
+    
+    @to   = {
+      :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
+  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_s),      to('/integers/a', &:to_i)
+  map from('/integers/b', &:to_i),     to('/strings/b',   &:to_s)
+end
+
+describe 'coercing types' do
+  
+  before :each do
+    @from = {
+      :strings => {:a => '10'},
+      :integers =>{:b => 20}
+    }
+    
+    @to   = {
+      :integers => {:a => 10},
+      :strings  => {:b => '20'}
+    }
+  end
+  
+  it "should coerce values to specified types" do
+    DifferentTypes.normalize(@from).should == @to
+  end
+  
+  it "should coerce the other way if specified" do
+    DifferentTypes.denormalize(@to).should == @from
+  end
+  
+end
+
+
+describe 'arrays in hashes' do
+  before :each do
+    @from = {
+      :name => ['ismael','sachiyo'],
+      :tagid => 1,
+      :properties => {
+        :type => 'BLAH',
+        :egg => 33
+      }
+    }
+    
+    @to   = {
+      :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
+  end
+end
+
+class WithArrays
+  extend HashMapper
+  map from('/arrays/names[0]'),      to('/first_name')
+  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'
+      }
+    }
+    @to ={
+      :first_name => 'ismael',
+      :last_name => 'celis',
+      :work       => {:company => 'New Bamboo'}
+    }
+  end
+  
+  it "should extract defined array values" do
+    WithArrays.normalize(@from).should == @to
+  end
+  
+  it "should map the other way restoring arrays" do
+    WithArrays.denormalize(@to).should == @from
+  end
+end
+
+class PersonWithBlock
+  extend HashMapper
+  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
+  before :each do
+    @from = {
+      :names => {:first => 'Ismael'}
+    }
+    @to = {
+      :first_name => '+++Ismael+++'
+    }
+  end
+  
+  it "should pass final value through given block" do
+    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'), using(PersonWithBlock)
+end
+
+describe "with nested mapper" do
+  before :each do
+    @from ={
+      :name => 'HashMapper',
+      :author_hash => {
+        :names => {:first => 'Ismael'}
+      }
+    }
+    @to = {
+      :project_name => 'HashMapper',
+      :author => {:first_name => '+++Ismael+++'}
+    }
+  end
+  
+  it "should delegate nested hashes to another mapper" do
+    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
+  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)}
+  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 = {
+      :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+++'}
+      ]
+    }
+  end
+  
+  it "should pass array value though given block mapper" do
+    CompanyMapper.normalize(@from).should == @to
+  end
+  
+  it "should map array elements automatically" do
+    CompanyEmployeesMapper.normalize(@from).should == @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
+    }
+    @output = {
+      :exists_yahoo => 1,
+      :exists_nil => nil
+    }
+  end
+  
+  it "should ignore maps that don't exist" do
+    NoKeys.normalize(@input).should == @output
+  end
+end
+
+class WithBeforeFilters
+  extend HashMapper
+  map from('/hello'), to('/goodbye')
+
+  before_normalize do |input, output|
+    output[:this_is] = "extra #{input[:hello]} innit"
+    output
+  end
+  before_denormalize do |input, output|
+    input[:goodbye] = 'changed'
+    output
+  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?!', :this_is => '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

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'hash_mapper'

data/tasks/rspec.rake

@@ -0,0 +1,21 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  require 'spec'
+end
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts <<-EOS
+To use rspec for testing you must install rspec gem:
+    gem install rspec
+EOS
+  exit(0)
+end
+
+desc "Run the specs under spec/models"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: newbamboo-hash_mapper
+version: !ruby/object:Gem::Version 
+  version: 0.0.5
+platform: ruby
+authors: 
+- Ismael Celis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-08 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+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.
+email: 
+- ismaelct@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- lib/hash_mapper.rb
+- script/console
+- script/destroy
+- script/generate
+- spec/hash_mapper_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/rspec.rake
+has_rdoc: true
+homepage: http://github.com/ismasan/hash_mapper
+post_install_message: PostInstall.txt
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: hash_mapper
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Maps values from hashes with different structures and/or key names
+test_files: []
+