hash_mapper 0.0.10 → 0.1.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in hash_mapper.gemspec
+gemspec

data/History.txt

@@ -1,3 +1,9 @@
+== 0.1.0 2012-02-10
+
+* 1 enhancement:
+  * Update version of activesupport
+  * Replace usage of deprecated activesupport methods
+
 == 0.0.1 2009-01-29
 
 * 1 major enhancement:

data/{README.rdoc → README.md}

@@ -1,192 +1,241 @@
-= hash_mapper
+# hash_mapper
 
-* http://github.com/ismasan/hash_mapper
+* http://ismasan.github.com/hash_mapper/
 
-== DESCRIPTION:
+## 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:
+## 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:
+## SYNOPSIS:
+
+```ruby
+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]) )
+```ruby
+@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')
+```ruby
+class NiceHash
+  include Enumerable
+  extend HashMapper
+  
+  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 initialize(input_hash)
+    @hash = self.class.normalize(input_hash)
+  end
 
-     def [](k)
-       @hash[k]
-     end
+  def [](k)
+    @hash[k]
+  end
 
-     def []=(k,v)
-       @hash[k] = v
-     end
+  def []=(k,v)
+    @hash[k] = v
+  end
 
-     def each(&block)
-       @hash.each(&block)
-     end
-   end
+  def each(&block)
+    @hash.each(&block)
+  end
+end
 
-   @user = User.new(NiceHash.new(params))
+@user = User.new(NiceHash.new(params))
+```
 
-=== Options:
+### Options:
 
-==== Coercing values
+#### Coercing values
 
 You want to make sure an incoming value gets converted to a certain type, so 
 
-{'one' => '1', 'two' => '2'} gets translated to {:one => 1, :two => 2}
+```ruby
+{'one' => '1', 'two' => '2'}
+```
+
+gets translated to
+
+```ruby`
+{:one => 1, :two => 2}
+```
 
 Do this:
 
-   map from('/one'), to('/one', &:to_i)
-   map from('/two'), to('/two', &:to_i)
+```ruby
+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}
+```ruby
+map from('/one), to('/one'){|value| value.to_i}
+```
 
-==== Custom value filtering
+#### Custom value filtering
 
 You want to pass the final value of a key through a custom filter:
 
+```ruby
 {: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
+```ruby
+map from('/names'), to('/user') do |names|
+  "Mr. #{names[1]}, #{names[0]}"
+end
+```
 
-=== Mapping in reverse
+### 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
+```ruby
+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
+### Advanced usage
+#### Array access
 You want:
 
-{:names => ['Ismael', 'Celis']} converted to {:first_name => 'Ismael', :last_name => 'Celis'}
+```ruby
+{:names => ['Ismael', 'Celis']}
+```
+
+converted to
+
+```ruby
+{:first_name => 'Ismael', :last_name => 'Celis'}
+```
 
 Do this:
 
-   map from('/names[0]'), to('/first_name')
-   map from('/names[1]'), to('/last_name')
-==== Nested mappers
+```ruby
+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:
+
+```ruby
 input = {
 	:project 		=> 'HashMapper',
 	:url			=> 'http://github.com/ismasan/hash_mapper',
 	:author_names	=> {:first => 'Ismael', :last => 'Celis'}
 }
+```
+
 To this:
+
+```ruby
 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
+```ruby
+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
+```ruby
+ProjectMapper.normalize( input ) # => output
+```
 
 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)
+```ruby
+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
+  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)
-	
+
+```ruby	
+map from('/employees'),	to('employees'), using(UserMapper)
+```
 ... Will map each employee using UserMapper.
 
-==== Before and after filters
+#### Before and after filters
 
 Sometimes you will need some slightly more complex processing on the whole hash, either before or after normalizing/denormalizing.
 
@@ -194,40 +243,41 @@ For this you can use the class methods before_normalize, before_denormalize, aft
 
 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
-
+```ruby
+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:
+## REQUIREMENTS:
 
-== TODO:
+## TODO:
 
 
-==== Optimizations
+#### Optimizations
 
 * Get rid of ActiveSupport (used for inherited class variables and HashWithIndifferentAccess)
 
-== INSTALL:
+## INSTALL:
 
-# Now install
 
-   sudo gem install hash_mapper
+   gem install hash_mapper
 
-== Credits:
+## Credits:
 
 * Ismael Celis (Author - http://www.estadobeta.com)
 * Mark Evans (Contributor - http://github.com/markevans)
@@ -235,7 +285,7 @@ Note also that 'output' is correct at the time of the filter, i.e. before_normal
 * nightscape (Contributor - http://github.com/nightscape)
 * radamanthus (Contributor - http://github.com/radamanthus)
 
-== LICENSE:
+## LICENSE:
 
 (The MIT License)
 

data/Rakefile

@@ -1,23 +1 @@
-require 'rubygems'
-require File.dirname(__FILE__) + '/lib/hash_mapper'
-
-Dir['tasks/**/*.rake'].each { |t| load t }
-
-# TODO - want other tests/tasks run by default? Add them to the list
-task :default => [:spec]
-
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name = "hash_mapper"
-    gemspec.summary = "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)"
-    gemspec.description = "Tiny module that allows you to easily adapt from one hash structure to another with a simple declarative DSL."
-    gemspec.email = "ismaelct@gmail.com"
-    gemspec.homepage = "http://github.com/ismasan/hash_mapper"
-    gemspec.add_dependency('active_support', '>= 3.0.0.beta')
-    gemspec.authors = ["Ismael Celis"]
-  end
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
-end
+require "bundler/gem_tasks"

data/hash_mapper.gemspec

@@ -1,58 +1,31 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
 # -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'hash_mapper/version'
 
 Gem::Specification.new do |s|
-  s.name = %q{hash_mapper}
-  s.version = "0.0.10"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Ismael Celis"]
-  s.date = %q{2010-09-21}
+  s.name        = %q{hash_mapper}
+  s.version     = HashMapper::VERSION
+  s.authors     = ['Ismael Celis']
   s.description = %q{Tiny module that allows you to easily adapt from one hash structure to another with a simple declarative DSL.}
-  s.email = %q{ismaelct@gmail.com}
-  s.extra_rdoc_files = [
-    "README.rdoc"
-  ]
-  s.files = [
-    "History.txt",
-     "Manifest.txt",
-     "PostInstall.txt",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "hash_mapper.gemspec",
-     "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"
-  ]
-  s.homepage = %q{http://github.com/ismasan/hash_mapper}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{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)}
-  s.test_files = [
-    "spec/hash_mapper_spec.rb",
-     "spec/spec_helper.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<active_support>, [">= 3.0.0.beta"])
-    else
-      s.add_dependency(%q<active_support>, [">= 3.0.0.beta"])
-    end
+  s.date        = %q{2010-09-21}
+  s.email       = %q{ismaelct@gmail.com}
+  
+  s.files         = `git ls-files`.split("\n")
+  s.homepage      = %q{http://github.com/ismasan/hash_mapper}
+  s.rdoc_options  = ['--charset=UTF-8']
+  s.require_paths = ['lib']
+  s.summary       = %q{Maps input hashes to a normalized format}
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+  
+  if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    s.add_runtime_dependency("activesupport", "~> 3")
   else
-    s.add_dependency(%q<active_support>, [">= 3.0.0.beta"])
+    s.add_dependency("activesupport", "~> 3")
   end
+  
+  # specify any dependencies here; for example:
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rake'
 end
-

data/lib/hash_mapper/version.rb

@@ -0,0 +1,3 @@
+module HashMapper
+  VERSION = "0.1.1"
+end

data/lib/hash_mapper.rb

@@ -1,11 +1,13 @@
+require 'hash_mapper/version'
+
 $:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$:.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/object/duplicable'
-  require 'active_support/core_ext/class/inheritable_attributes'
+  require 'active_support/core_ext/class/attribute'
 end
 
 begin
@@ -18,7 +20,7 @@ end
 
 
 # This allows us to call blah(&:some_method) instead of blah{|i| i.some_method }
-unless Symbol.instance_methods.include?('to_proc')
+unless :symbol.respond_to?(:to_proc)
   class Symbol
     def to_proc
       Proc.new {|obj| obj.send(self) }
@@ -27,7 +29,7 @@ unless Symbol.instance_methods.include?('to_proc')
 end
 
 # http://rpheath.com/posts/341-ruby-inject-with-index
-unless Array.instance_methods.include?("inject_with_index")
+unless [].respond_to?(:inject_with_index)
   module Enumerable
     def inject_with_index(injected)
       each_with_index{ |obj, index| injected = yield(injected, obj, index) }
@@ -38,16 +40,15 @@ end
 
 module HashMapper
 
-  # 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
+      class_attribute :maps
+      self.maps = []
     end
   end
 
   def map(from, to, using=nil, &filter)
+    self.maps = self.maps.dup
     self.maps << Map.new(from, to, using)
     to.filter = filter if block_given? # Useful if just one block given
   end
@@ -97,7 +98,7 @@ module HashMapper
     before_filter = instance_eval "@before_#{meth}"
     a_hash = before_filter.call(a_hash, output) if before_filter
     # Do the mapping
-    maps.each do |m|
+    self.maps.each do |m|
       m.process_into(output, a_hash, meth)
     end
     # After filter
@@ -210,7 +211,6 @@ module HashMapper
     KEY_NAME_REGEXP = /([^\[]*)(\[(\d+)+\])?/
 
     def parse(path)
-
       segments = path.sub(/^\//,'').split('/')
       segments = segments.collect do |segment|
         matches = segment.to_s.scan(KEY_NAME_REGEXP).flatten.compact

data/spec/hash_mapper_spec.rb

@@ -1,11 +1,11 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'spec_helper.rb'
 
 class OneLevel
   extend HashMapper
   map from('/name'),            to('/nombre')
 end
 
-describe 'mapping a hash wit one level' do
+describe 'mapping a hash with one level' do
   
   before :each do
     @from = {:name => 'ismael'}

data/spec/spec_helper.rb

@@ -1,9 +1,13 @@
-begin
-  require 'spec'
-rescue LoadError
-  require 'rubygems'
-  gem 'rspec'
-  require 'spec'
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper.rb"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
 end
 
 $:.unshift(File.dirname(__FILE__) + '/../lib')

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: hash_mapper
 version: !ruby/object:Gem::Version 
-  hash: 11
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 10
-  version: 0.0.10
+  prerelease: 
+  version: 0.1.1
 platform: ruby
 authors: 
 - Ismael Celis
@@ -15,51 +10,60 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-21 00:00:00 +01:00
-default_executable: 
+date: 2010-09-21 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: active_support
+  name: activesupport
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 31098225
-        segments: 
-        - 3
-        - 0
-        - 0
-        - beta
-        version: 3.0.0.beta
+        version: "3"
   type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
 description: 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: 
-- README.rdoc
+extra_rdoc_files: []
+
 files: 
+- .gitignore
+- Gemfile
 - History.txt
-- Manifest.txt
-- PostInstall.txt
-- README.rdoc
+- README.md
 - Rakefile
-- VERSION
 - hash_mapper.gemspec
 - lib/hash_mapper.rb
-- script/console
-- script/destroy
-- script/generate
+- lib/hash_mapper/version.rb
 - 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: []
 
@@ -73,26 +77,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
-summary: 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)
+summary: Maps input hashes to a normalized format
 test_files: 
 - spec/hash_mapper_spec.rb
 - spec/spec_helper.rb

data/Manifest.txt

@@ -1,13 +0,0 @@
-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

@@ -1,7 +0,0 @@
-
-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/VERSION

@@ -1 +0,0 @@
-0.0.10

data/script/console

@@ -1,10 +0,0 @@
-#!/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

@@ -1,14 +0,0 @@
-#!/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

@@ -1,14 +0,0 @@
-#!/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/spec.opts

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

data/tasks/rspec.rake

@@ -1,21 +0,0 @@
-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