hash_mapper 0.0.8

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,266 @@
+= 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
+==== 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|
+      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:
+
+== TODO:
+==== 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')
+
+==== Optimizations
+
+* Get rid of ActiveSupport (used for inherited class variables and HashWithIndifferentAccess)
+
+== 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)
+* nightscape (Contributor - http://github.com/nightscape)
+
+== 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]

data/lib/hash_mapper.rb

@@ -0,0 +1,211 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+def require_active_support
+  require 'active_support/core_ext/array/extract_options'
+  require 'active_support/core_ext/hash/indifferent_access'
+  require 'active_support/core_ext/duplicable'
+  Array.send(:include, ActiveSupport::CoreExtensions::Array::ExtractOptions)
+  Hash.send(:include, ActiveSupport::CoreExtensions::Hash::IndifferentAccess)
+  require 'active_support/core_ext/class/inheritable_attributes'
+
+end
+
+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
+    def to_proc
+      Proc.new {|obj| obj.send(self) }
+    end
+  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.8'
+  
+  # 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)
+    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}"
+    a_hash = before_filter.call(a_hash, output) if before_filter
+    # Do the mapping
+    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
+  
+  # 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|
+        v = h.with_indifferent_access[e] # this does it, but uses ActiveSupport
+        throw :no_value if v.nil?#.has_key?(e)
+        v
+      end
+      delegated_mapper ? delegate_to_nested_mapper(value, meth) : value
+    end
+    
+    
+    def delegate_to_nested_mapper(value, meth)
+      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_with_index(hash) do |h,e,i|
+        if !h[e].nil? # it can be FALSE
+          h[e]
+        else
+          h[e] = (i == path.size-1 ? 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)
+      @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 first
+      @segments.first
+    end
+    
+    def last
+      @segments.last
+    end
+    
+    def size
+      @segments.size
+    end
+    
+    private
+    
+    def parse(path)
+      path.sub(/^\//,'').split('/').map(&:to_sym)
+    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,430 @@
+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
+    pending
+    WithArrays.normalize(@from).should == @to
+  end
+  
+  it "should map the other way restoring arrays" do
+    pending
+    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
+    }
+  end
+  
+  it "should ignore maps that don't exist" do
+    NoKeys.normalize(@input).should == @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}
+  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 == {}
+  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
+
+class MixedMappings
+  extend HashMapper
+  map from('/big/jobs'), to('dodo')
+  map from('/timble'),   to('bingo/biscuit')
+end
+
+describe "dealing with strings and symbols" do
+  
+  it "should be able to normalize from a nested hash with string keys" do
+    MixedMappings.normalize(
+      'big' => {'jobs' => 5},
+      'timble' => 3.2
+    ).should ==   {:dodo  => 5,
+                   :bingo => {:biscuit => 3.2}}
+  end
+  
+  it "should not symbolized keys in value hashes" do
+    MixedMappings.normalize(
+      'big' => {'jobs' => 5},
+      'timble' => {'string key' => 'value'}
+    ).should ==   {:dodo  => 5,
+                   :bingo => {:biscuit => {'string key' => 'value'}}}
+  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,94 @@
+--- !ruby/object:Gem::Specification 
+name: hash_mapper
+version: !ruby/object:Gem::Version 
+  version: 0.0.8
+platform: ruby
+authors: 
+- Ismael Celis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-05 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  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
+licenses: []
+
+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.3.5
+signing_key: 
+specification_version: 3
+summary: Maps values from hashes with different structures and/or key names
+test_files: []
+