zerobearing-hashie 0.1.9

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,6 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+*.gem

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Intridea, Inc.
+
+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/README.rdoc

@@ -0,0 +1,81 @@
+= Hashie
+
+Hashie is a growing collection of tools that extend Hashes and make
+them more useful.
+
+== Installation
+
+Hashie is a gem and is available on Gemcutter. If you don't have Gemcutter,
+install it:
+
+    gem install gemcutter
+    gem tumble
+    
+Then you can install Hashie:
+
+    gem install hashie
+
+== Mash
+
+Mash is an extended Hash that gives simple pseudo-object functionality
+that can be built from hashes and easily extended. It is designed to
+be used in RESTful API libraries to provide easy object-like access 
+to JSON and XML parsed hashes.
+
+=== Example:
+  
+    mash = Hashie::Mash.new
+    mash.name? # => false
+    mash.name # => nil
+    mash.name = "My Mash"
+    mash.name # => "My Mash"
+    mash.name? # => true
+    mash.inspect # => <Hashie::Mash name="My Mash">
+  
+    mash = Mash.new
+    # use bang methods for multi-level assignment
+    mash.author!.name = "Michael Bleigh"
+    mash.author # => <Hashie::Mash name="Michael Bleigh">
+  
+== Dash
+
+Dash is an extended Hash that has a discrete set of defined properties
+and only those properties may be set on the hash. Additionally, you
+can set defaults for each property.
+
+=== Example:
+
+    class Person < Hashie::Dash
+      property :name
+      property :email
+      property :occupation, :default => 'Rubyist'
+    end
+
+    p = Person.new
+    p.name # => nil
+    p.email = 'abc@def.com'
+    p.occupation   # => 'Rubyist'
+    p.email        # => 'abc@def.com'
+    p[:awesome]    # => NoMethodError
+    p[:occupation] # => 'Rubyist'
+    
+    p = Person.new(:name => "Bob")
+    p.name       # => 'Bob'
+    p.occupation # => 'Rubyist'
+  
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Authors
+
+* Michael Bleigh
+
+== Copyright
+
+Copyright (c) 2009 Intridea, Inc (http://intridea.com/). See LICENSE for details.

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "hashie"
+    gem.summary = %Q{Your friendly neighborhood hash toolkit.}
+    gem.description = %Q{Hashie is a small collection of tools that make hashes more powerful. Currently includes Mash (Mocking Hash) and Dash (Discrete Hash).}
+    gem.email = "michael@intridea.com"
+    gem.homepage = "http://github.com/intridea/hashie"
+    gem.authors = ["Michael Bleigh"]
+    gem.add_development_dependency "rspec"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "hashie #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.9

data/hashie.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{zerobearing-hashie}
+  s.version = "0.1.9"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael Bleigh"]
+  s.date = %q{2010-01-20}
+  s.description = %q{Hashie is a small collection of tools that make hashes more powerful. Currently includes Mash (Mocking Hash) and Dash (Discrete Hash).}
+  s.email = %q{michael@intridea.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "hashie.gemspec",
+     "lib/hashie.rb",
+     "lib/hashie/dash.rb",
+     "lib/hashie/hash.rb",
+     "lib/hashie/hash_extensions.rb",
+     "lib/hashie/mash.rb",
+     "spec/hashie/dash_spec.rb",
+     "spec/hashie/hash_spec.rb",
+     "spec/hashie/mash_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/intridea/hashie}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Your friendly neighborhood hash toolkit.}
+  s.test_files = [
+    "spec/hashie/dash_spec.rb",
+     "spec/hashie/hash_spec.rb",
+     "spec/hashie/mash_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::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end
+

data/lib/hashie.rb

@@ -0,0 +1,4 @@
+require 'hashie/hash_extensions'
+require 'hashie/hash'
+require 'hashie/mash'
+require 'hashie/dash'

data/lib/hashie/dash.rb

@@ -0,0 +1,108 @@
+require 'hashie/hash'
+
+module Hashie
+  include Hashie::PrettyInspect
+  # A Dash is a 'defined' or 'discrete' Hash, that is, a Hash
+  # that has a set of defined keys that are accessible (with
+  # optional defaults) and only those keys may be set or read.
+  #
+  # Dashes are useful when you need to create a very simple
+  # lightweight data object that needs even fewer options and
+  # resources than something like a DataMapper resource.
+  #
+  # It is preferrable to a Struct because of the in-class
+  # API for defining properties as well as per-property defaults.
+  class Dash < Hashie::Hash
+    include Hashie::PrettyInspect
+    alias_method :to_s, :inspect
+
+    # Defines a property on the Dash. Options are
+    # as follows:
+    #
+    # * <tt>:default</tt> - Specify a default value for this property,
+    #   to be returned before a value is set on the property in a new
+    #   Dash.
+    #
+    def self.property(property_name, options = {})
+      property_name = property_name.to_sym
+
+      (@properties ||= []) << property_name
+      (@defaults ||= {})[property_name] = options.delete(:default)
+
+      class_eval <<-RUBY
+        def #{property_name}
+          self[:#{property_name}]
+        end
+
+        def #{property_name}=(val)
+          self[:#{property_name}] = val
+        end
+      RUBY
+    end
+
+    # Get a String array of the currently defined
+    # properties on this Dash.
+    def self.properties
+      properties = []
+      ancestors.each do |elder| 
+        if elder.instance_variable_defined?("@properties")
+          properties << elder.instance_variable_get("@properties")
+        end
+      end
+
+      properties.flatten.map{|p| p.to_s}
+    end
+
+    # Check to see if the specified property has already been
+    # defined.
+    def self.property?(prop)
+      properties.include?(prop.to_s)
+    end
+
+    # The default values that have been set for this Dash
+    def self.defaults
+      properties = {}
+      ancestors.each do |elder|
+        if elder.instance_variable_defined?("@defaults")
+          properties.merge! elder.instance_variable_get("@defaults")
+        end
+      end
+      
+      properties
+    end
+
+    # You may initialize a Dash with an attributes hash
+    # just like you would many other kinds of data objects.
+    def initialize(attributes = {})
+      self.class.properties.each do |prop|
+        self.send("#{prop}=", self.class.defaults[prop.to_sym])
+      end
+
+      attributes.each_pair do |att, value|
+        self.send("#{att}=", value)
+      end
+    end
+
+    # Retrieve a value from the Dash (will return the
+    # property's default value if it hasn't been set).
+    def [](property)
+      super(property.to_sym) if property_exists? property
+    end
+
+    # Set a value on the Dash in a Hash-like way. Only works
+    # on pre-existing properties.
+    def []=(property, value)
+      super if property_exists? property
+    end
+    
+    private 
+      # Raises an NoMethodError if the property doesn't exist
+      #
+      def property_exists?(property)
+        unless self.class.property?(property.to_sym)
+          raise NoMethodError, "The property '#{property}' is not defined for this Dash."
+        end
+        true
+      end
+  end
+end

data/lib/hashie/hash.rb

@@ -0,0 +1,8 @@
+module Hashie
+  # A Hashie Hash is simply a Hash that has convenience
+  # functions baked in such as stringify_keys that may
+  # not be available in all libraries.
+  class Hash < Hash
+    include Hashie::HashExtensions
+  end
+end

data/lib/hashie/hash_extensions.rb

@@ -0,0 +1,49 @@
+module Hashie
+  module HashExtensions
+    def self.included(base)
+      # Don't tread on existing extensions of Hash by
+      # adding methods that are likely to exist.
+      %w(stringify_keys stringify_keys!).each do |hashie_method|
+        base.send :alias_method, hashie_method, "hashie_#{hashie_method}" unless base.instance_methods.include?(hashie_method)
+      end
+    end
+
+    # Destructively convert all of the keys of a Hash
+    # to their string representations.
+    def hashie_stringify_keys!
+      self.keys.each do |k|
+        unless String === k
+          self[k.to_s] = self.delete(k)
+        end
+      end
+      self
+    end
+
+    # Convert all of the keys of a Hash
+    # to their string representations.
+    def hashie_stringify_keys
+      self.dup.stringify_keys!
+    end
+
+    # Convert this hash into a Mash
+    def to_mash
+      Hashie::Mash.new(self)
+    end
+  end
+
+  module PrettyInspect
+    def self.included(base)
+      base.send :alias_method, :hash_inspect, :inspect
+      base.send :alias_method, :inspect, :hashie_inspect
+    end
+
+    def hashie_inspect
+      ret = "<##{self.class.to_s}"
+      stringify_keys.keys.sort.each do |key|
+        ret << " #{key}=#{self[key].inspect}"
+      end
+      ret << ">"
+      ret
+    end
+  end
+end

data/lib/hashie/mash.rb

@@ -0,0 +1,166 @@
+module Hashie
+  # Mash allows you to create pseudo-objects that have method-like
+  # accessors for hash keys. This is useful for such implementations
+  # as an API-accessing library that wants to fake robust objects
+  # without the overhead of actually doing so. Think of it as OpenStruct
+  # with some additional goodies.
+  #
+  # A Mash will look at the methods you pass it and perform operations
+  # based on the following rules:
+  #
+  # * No punctuation: Returns the value of the hash for that key, or nil if none exists.
+  # * Assignment (<tt>=</tt>): Sets the attribute of the given method name.
+  # * Existence (<tt>?</tt>): Returns true or false depending on whether that key has been set.
+  # * Bang (<tt>!</tt>): Forces the existence of this key, used for deep Mashes. Think of it as "touch" for mashes.
+  #
+  # == Basic Example
+  #
+  #   mash = Mash.new
+  #   mash.name? # => false
+  #   mash.name = "Bob"
+  #   mash.name # => "Bob"
+  #   mash.name? # => true
+  #
+  # == Hash Conversion  Example
+  #
+  #   hash = {:a => {:b => 23, :d => {:e => "abc"}}, :f => [{:g => 44, :h => 29}, 12]}
+  #   mash = Mash.new(hash)
+  #   mash.a.b # => 23
+  #   mash.a.d.e # => "abc"
+  #   mash.f.first.g # => 44
+  #   mash.f.last # => 12
+  #
+  # == Bang Example
+  #
+  #   mash = Mash.new
+  #   mash.author # => nil
+  #   mash.author! # => <Mash>
+  #
+  #   mash = Mash.new
+  #   mash.author!.name = "Michael Bleigh"
+  #   mash.author # => <Mash name="Michael Bleigh">
+  #
+  class Mash < Hashie::Hash
+    include Hashie::PrettyInspect
+    alias_method :to_s, :inspect
+
+    # If you pass in an existing hash, it will
+    # convert it to a Mash including recursively
+    # descending into arrays and hashes, converting
+    # them as well.
+    def initialize(source_hash = nil, default = nil, &blk)
+      deep_update(source_hash) if source_hash
+      default ? super(default) : super(&blk)
+    end
+
+    class << self; alias [] new; end
+
+    def id #:nodoc:
+      key?("id") ? self["id"] : super
+    end
+
+    alias_method :regular_reader, :[]
+    alias_method :regular_writer, :[]=
+
+    # Retrieves an attribute set in the Mash. Will convert
+    # any key passed in to a string before retrieving.
+    def [](key)
+      regular_reader(convert_key(key))
+    end
+
+    # Sets an attribute in the Mash. Key will be converted to
+    # a string before it is set, and Hashes will be converted
+    # into Mashes for nesting purposes.
+    def []=(key,value) #:nodoc:
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    # This is the bang method reader, it will return a new Mash
+    # if there isn't a value already assigned to the key requested.
+    def initializing_reader(key)
+      ck = convert_key(key)
+      regular_writer(ck, Hashie::Mash.new) unless key?(ck)
+      regular_reader(ck)
+    end
+
+    alias_method :regular_dup, :dup
+    # Duplicates the current mash as a new mash.
+    def dup
+      Mash.new(self, self.default)
+    end
+
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    # Performs a deep_update on a duplicate of the
+    # current mash.
+    def deep_merge(other_hash)
+      dup.deep_merge!(other_hash)
+    end
+
+    # Recursively merges this mash with the passed
+    # in hash, merging each hash in the hierarchy.
+    def deep_update(other_hash)
+      other_hash.each_pair do |k,v|
+        regular_writer(convert_key(k), convert_value(other_hash[k], true))
+      end
+      self
+    end
+    alias_method :deep_merge!, :deep_update
+    alias_method :update, :deep_update
+    alias_method :merge!, :update
+
+    # Converts a mash back to a hash (with stringified keys)
+    def to_hash
+      h = Hash.new(default).merge(self)
+      h.each {|key,val| h[key] = convert_value_to_hash(val)}
+      h
+    end
+
+   def method_missing(method_name, *args)
+     return self[method_name] if key?(method_name)
+     match = method_name.to_s.match(/(.*?)([?=!]?)$/)
+     case match[2]
+     when "="
+       self[match[1]] = args.first
+     when "?"
+       key?(match[1])
+     when "!"
+       initializing_reader(match[1])
+     else
+       default(method_name)
+     end
+   end
+
+    protected
+
+    def convert_key(key) #:nodoc:
+      key.to_s
+    end
+
+    #------------------
+    def convert_value_to_hash(val)
+      case val
+      when Mash
+        val.to_hash
+      when Array
+        val.collect(&:to_hash)
+      else
+        val
+      end
+    end
+
+    def convert_value(val, duping=false) #:nodoc:
+      case val
+        when ::Hash
+          val = val.dup if duping
+          self.class.new(val)
+        when Array
+          val.collect{ |e| convert_value(e) }
+        else
+          val
+      end
+    end
+  end
+end

data/spec/hashie/dash_spec.rb

@@ -0,0 +1,103 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class DashTest < Hashie::Dash
+  property :first_name
+  property :email
+  property :count, :default => 0
+end
+
+class Subclassed < DashTest
+  property :last_name
+end
+
+describe Hashie::Dash do
+  it 'should be a subclass of Hashie::Hash' do
+    (Hashie::Dash < Hash).should be_true
+  end
+  
+  it '#inspect should be ok!' do
+    dash = DashTest.new
+    dash.email = "abd@abc.com"
+    dash.inspect.should == "<#DashTest count=0 email=\"abd@abc.com\" first_name=nil>"
+  end
+   
+  describe ' creating properties' do
+    it 'should add the property to the list' do
+      DashTest.property :not_an_att
+      DashTest.properties.include?('not_an_att').should be_true
+    end
+    
+    it 'should create a method for reading the property' do
+      DashTest.new.respond_to?(:first_name).should be_true
+    end
+    
+    it 'should create a method for writing the property' do
+      DashTest.new.respond_to?(:first_name=).should be_true
+    end
+  end
+  
+  describe 'reading properties' do
+    it 'should raise an error when reading a non-existent property' do 
+      lambda{@dash['abc']}.should raise_error(NoMethodError)
+    end
+  end
+  
+  describe ' writing to properties' do
+    before do
+      @dash = DashTest.new
+    end
+    
+    it 'should not be able to write to a non-existent property using []=' do
+      lambda{@dash['abc'] = 123}.should raise_error(NoMethodError)
+    end
+    
+    it 'should be able to write to an existing property using []=' do
+      lambda{@dash['first_name'] = 'Bob'}.should_not raise_error
+    end
+    
+    it 'should be able to read/write to an existing property using a method call' do
+      @dash.first_name = 'Franklin'
+      @dash.first_name.should == 'Franklin'
+    end
+  end
+  
+  describe ' initializing with a Hash' do
+    it 'should not be able to initialize non-existent properties' do
+      lambda{DashTest.new(:bork => 'abc')}.should raise_error(NoMethodError)
+    end
+    
+    it 'should set properties that it is able to' do
+      DashTest.new(:first_name => 'Michael').first_name.should == 'Michael'
+    end
+  end
+  
+  describe ' defaults' do
+    before do
+      @dash = DashTest.new
+    end
+    
+    it 'should return the default value for defaulted' do
+      DashTest.property :defaulted, :default => 'abc'
+      DashTest.new.defaulted.should == 'abc'
+    end
+  end
+end
+
+describe Subclassed do
+  it "should inherit all properties from DashTest" do
+    Subclassed.properties.size.should == 6
+  end
+  
+  it "should inherit all defaults from DashTest" do
+    Subclassed.defaults.size.should == 6
+  end
+  
+  it "should init without raising" do
+    lambda { Subclassed.new }.should_not raise_error
+    lambda { Subclassed.new(:first_name => 'Michael') }.should_not raise_error
+  end
+  
+  it "should share defaults from DashTest" do
+    Subclassed.new.count.should == 0
+  end
+end

data/spec/hashie/hash_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Hash do
+  it "should be convertible to a Hashie::Mash" do
+    mash = Hashie::Hash[:some => "hash"].to_mash
+    mash.is_a?(Hashie::Mash).should be_true
+    mash.some.should == "hash"
+  end
+  
+  it "#stringify_keys! should turn all keys into strings" do
+    hash = Hashie::Hash[:a => "hey", 123 => "bob"]
+    hash.stringify_keys!
+    hash.should == Hashie::Hash["a" => "hey", "123" => "bob"]
+  end
+  
+  it "#stringify_keys should return a hash with stringified keys" do
+    hash = Hashie::Hash[:a => "hey", 123 => "bob"]
+    stringified_hash = hash.stringify_keys
+    hash.should == Hashie::Hash[:a => "hey", 123 => "bob"]
+    stringified_hash.should == Hashie::Hash["a" => "hey", "123" => "bob"]
+  end
+end

data/spec/hashie/mash_spec.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Hashie::Mash do
+  before(:each) do
+    @mash = Hashie::Mash.new
+  end
+  
+  it "should inherit from hash" do
+    @mash.is_a?(Hash).should be_true
+  end
+  
+  it "should be able to set hash values through method= calls" do
+    @mash.test = "abc"
+    @mash["test"].should == "abc"
+  end
+  
+  it "should be able to retrieve set values through method calls" do
+    @mash["test"] = "abc"
+    @mash.test.should == "abc"
+  end
+  
+  it "should test for already set values when passed a ? method" do
+    @mash.test?.should be_false
+    @mash.test = "abc"
+    @mash.test?.should be_true
+  end
+  
+  it "should make all [] and []= into strings for consistency" do
+    @mash["abc"] = 123
+    @mash.key?('abc').should be_true
+    @mash["abc"].should == 123
+  end
+  
+  it "should have a to_s that is identical to its inspect" do
+    @mash.abc = 123
+    @mash.to_s.should == @mash.inspect
+  end
+  
+  it "should return nil instead of raising an error for attribute-esque method calls" do
+    @mash.abc.should be_nil
+  end
+  
+  it "should return a Hashie::Mash when passed a bang method to a non-existenct key" do
+    @mash.abc!.is_a?(Hashie::Mash).should be_true
+  end
+  
+  it "should return the existing value when passed a bang method for an existing key" do
+    @mash.name = "Bob"
+    @mash.name!.should == "Bob"
+  end
+  
+  it "#initializing_reader should return a Hashie::Mash when passed a non-existent key" do
+    @mash.initializing_reader(:abc).is_a?(Hashie::Mash).should be_true
+  end
+  
+  it "should allow for multi-level assignment through bang methods" do
+    @mash.author!.name = "Michael Bleigh"
+    @mash.author.should == Hashie::Mash.new(:name => "Michael Bleigh")
+    @mash.author!.website!.url = "http://www.mbleigh.com/"
+    @mash.author.website.should == Hashie::Mash.new(:url => "http://www.mbleigh.com/")
+  end
+  
+  it "#deep_update should recursively Hashie::Mash Hashie::Mashes and hashes together" do
+    @mash.first_name = "Michael"
+    @mash.last_name = "Bleigh"
+    @mash.details = Hashie::Hash[:email => "michael@asf.com"].to_mash
+    @mash.deep_update({:details => {:email => "michael@intridea.com"}})
+    @mash.details.email.should == "michael@intridea.com"
+  end
+  
+  it "should convert hash assignments into Hashie::Mashes" do
+    @mash.details = {:email => 'randy@asf.com', :address => {:state => 'TX'} }
+    @mash.details.email.should == 'randy@asf.com'
+    @mash.details.address.state.should == 'TX'
+  end
+  
+  it "should not convert the type of Hashie::Mashes childs to Hashie::Mash" do
+    class MyMash < Hashie::Mash
+    end
+    
+    record = MyMash.new
+    record.son = MyMash.new
+    record.son.class.should == MyMash
+  end
+  
+  context "#initialize" do
+    it "should convert an existing hash to a Hashie::Mash" do
+      converted = Hashie::Mash.new({:abc => 123, :name => "Bob"})
+      converted.abc.should == 123
+      converted.name.should == "Bob"
+    end
+  
+    it "should convert hashes recursively into Hashie::Mashes" do
+      converted = Hashie::Mash.new({:a => {:b => 1, :c => {:d => 23}}})
+      converted.a.is_a?(Hashie::Mash).should be_true
+      converted.a.b.should == 1
+      converted.a.c.d.should == 23
+    end
+  
+    it "should convert hashes in arrays into Hashie::Mashes" do
+      converted = Hashie::Mash.new({:a => [{:b => 12}, 23]})
+      converted.a.first.b.should == 12
+      converted.a.last.should == 23
+    end
+    
+    it "should convert an existing Hashie::Mash into a Hashie::Mash" do
+      initial = Hashie::Mash.new(:name => 'randy', :address => {:state => 'TX'})
+      copy = Hashie::Mash.new(initial)
+      initial.name.should == copy.name      
+      initial.object_id.should_not == copy.object_id
+      copy.address.state.should == 'TX'
+      copy.address.state = 'MI'
+      initial.address.state.should == 'TX'
+      copy.address.object_id.should_not == initial.address.object_id
+    end
+    
+    it "should accept a default block" do
+      initial = Hashie::Mash.new { |h,i| h[i] = []}
+      initial.default_proc.should_not be_nil
+      initial.default.should be_nil
+      initial.test.should == []
+      initial.test?.should be_true
+    end
+  end
+  
+  context "#to_hash" do
+    it "convert to hash (deeply)" do
+      @mash.test = 1
+      @mash.a = Hashie::Mash.new(:name => "testa")
+      @mash.b = [{:c => 1}, {:d => {:name => "hello"}}]
+      h = @mash.to_hash
+      h['test'].should == 1
+      h['a']['name'].should == "testa"
+      h['b'][0]['c'].should == 1
+      h['b'][1]['d']['name'].should == "hello"
+    end
+  end
+  
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--colour
+--format progress

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'hashie'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: zerobearing-hashie
+version: !ruby/object:Gem::Version 
+  version: 0.1.9
+platform: ruby
+authors: 
+- Michael Bleigh
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-20 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Hashie is a small collection of tools that make hashes more powerful. Currently includes Mash (Mocking Hash) and Dash (Discrete Hash).
+email: michael@intridea.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- hashie.gemspec
+- lib/hashie.rb
+- lib/hashie/dash.rb
+- lib/hashie/hash.rb
+- lib/hashie/hash_extensions.rb
+- lib/hashie/mash.rb
+- spec/hashie/dash_spec.rb
+- spec/hashie/hash_spec.rb
+- spec/hashie/mash_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/intridea/hashie
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Your friendly neighborhood hash toolkit.
+test_files: 
+- spec/hashie/dash_spec.rb
+- spec/hashie/hash_spec.rb
+- spec/hashie/mash_spec.rb
+- spec/spec_helper.rb