gorillib 0.1.4 → 0.1.5

data/.gitignore

@@ -47,3 +47,7 @@ pkg/*
 
 ## PROJECT::SPECIFIC
 *.rdb
+
+.vendor
+.bundle
+Gemfile.lock

data/Rakefile

@@ -32,7 +32,7 @@ Jeweler::Tasks.new do |gem|
   gem.files = dotfiles + Dir["**/*"].
     reject{|f| f =~ %r{^(vendor|coverage)/} }.
     reject{|f| File.directory?(f) }.
-    reject{|f| ignores.any?{|i| File.fnmatch(i, f) || File.fnmatch(i+'/**/*', f) } }
+    reject{|f| ignores.any?{|i| File.fnmatch(i, f) || File.fnmatch(i+'/**/*', f) || File.fnmatch(i+'/*', f) } }
   gem.test_files = gem.files.grep(/^spec\//)
   gem.require_paths = ['lib']
 end

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.1.5

data/gorillib.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{gorillib}
-  s.version = "0.1.4"
+  s.version = "0.1.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Infochimps"]
-  s.date = %q{2011-07-06}
+  s.authors = [%q{Infochimps}]
+  s.date = %q{2011-08-02}
   s.description = %q{Gorillib: infochimps lightweight subset of ruby convenience methods}
   s.email = %q{coders@infochimps.org}
   s.extra_rdoc_files = [
@@ -21,7 +21,6 @@ Gem::Specification.new do |s|
     ".rspec",
     "CHANGELOG.textile",
     "Gemfile",
-    "Gemfile.lock",
     "LICENSE.textile",
     "README.textile",
     "Rakefile",
@@ -49,6 +48,7 @@ Gem::Specification.new do |s|
     "lib/gorillib/hashlike/compact.rb",
     "lib/gorillib/hashlike/deep_compact.rb",
     "lib/gorillib/hashlike/deep_dup.rb",
+    "lib/gorillib/hashlike/deep_hash.rb",
     "lib/gorillib/hashlike/deep_merge.rb",
     "lib/gorillib/hashlike/hashlike_via_accessors.rb",
     "lib/gorillib/hashlike/keys.rb",
@@ -98,6 +98,7 @@ Gem::Specification.new do |s|
     "spec/hash/slice_spec.rb",
     "spec/hash/zip_spec.rb",
     "spec/hashlike/behave_same_as_hash_spec.rb",
+    "spec/hashlike/deep_hash_spec.rb",
     "spec/hashlike/hashlike_behavior_spec.rb",
     "spec/hashlike/hashlike_via_accessors_spec.rb",
     "spec/hashlike_spec.rb",
@@ -133,9 +134,9 @@ Gem::Specification.new do |s|
     "spec/support/matchers/evaluate_to_true.rb"
   ]
   s.homepage = %q{http://infochimps.com/labs}
-  s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
+  s.licenses = [%q{MIT}]
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.6}
   s.summary = %q{include only what you need. No dependencies, no creep}
   s.test_files = [
     "spec/array/compact_blank_spec.rb",
@@ -152,6 +153,7 @@ Gem::Specification.new do |s|
     "spec/hash/slice_spec.rb",
     "spec/hash/zip_spec.rb",
     "spec/hashlike/behave_same_as_hash_spec.rb",
+    "spec/hashlike/deep_hash_spec.rb",
     "spec/hashlike/hashlike_behavior_spec.rb",
     "spec/hashlike/hashlike_via_accessors_spec.rb",
     "spec/hashlike_spec.rb",
@@ -188,7 +190,6 @@ Gem::Specification.new do |s|
   ]
 
   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

data/lib/gorillib/hashlike/deep_hash.rb

@@ -0,0 +1,156 @@
+require 'gorillib/hashlike/deep_merge'
+require 'gorillib/hashlike/deep_compact'
+require 'gorillib/hashlike/deep_dup'
+
+module Gorillib
+  module Hashlike
+    module DeepHash
+
+      include Gorillib::Hashlike::DeepMerge
+      include Gorillib::Hashlike::DeepCompact
+      include Gorillib::Hashlike::DeepDup
+
+      # @param constructor<Object>
+      #   The default value for the DeepHash. Defaults to an empty hash.
+      #   If constructor is a Hash, adopt its values.
+      def initialize(constructor = {})
+        if constructor.is_a?(Hash)
+          super()
+          deep_merge!(constructor) unless constructor.empty?
+        else
+          super(constructor)
+        end
+      end
+
+      def self.included(base)
+        base.class_eval do
+          unless method_defined?(:regular_writer) then alias_method :regular_writer, :[]=  ; end
+          unless method_defined?(:regular_update) then alias_method :regular_update, :update  ; end
+        end
+      end
+
+      # Sets a member value.
+      #
+      # Given a deep key (one that contains '.'), uses it as a chain of hash
+      # memberships. Otherwise calls the normal hash member setter
+      #
+      # @example
+      #   foo = DeepHash.new :hi => 'there'
+      #   foo['howdy.doody'] = 3
+      #   foo # => { :hi => 'there', :howdy => { :doody => 3 } }
+      #
+      def []= attr, val
+        attr = convert_key(attr)
+        val  = convert_value(val)
+        attr.is_a?(Array) ? deep_set(*(attr | [val])) : super(attr, val)
+      end
+
+
+      # Gets a member value.
+      #
+      # Given a deep key (one that contains '.'), uses it as a chain of hash
+      # memberships. Otherwise calls the normal hash member getter
+      #
+      # @example
+      #   foo = DeepHash.new({ :hi => 'there', :howdy => { :doody => 3 } })
+      #   foo['howdy.doody'] # => 3
+      #   foo['hi']          # => 'there'
+      #   foo[:hi]           # => 'there'
+      #
+      def [] attr
+        attr = convert_key(attr)
+        attr.is_a?(Array) ? deep_get(*attr) : super(attr)
+      end
+
+      #
+      # Treat hash as tree of hashes:
+      #
+      #     x = { :a => :val, :subhash => { :b => :val_b } }
+      #     x.deep_set(:subhash, :cat, :hat)
+      #     # => { :a => :val, :subhash => { :b => :val_b,   :cat => :hat } }
+      #     x.deep_set(:subhash, :b, :newval)
+      #     # => { :a => :val, :subhash => { :b => :newval, :cat => :hat } }
+      #
+      #
+      def deep_set *args
+        val      = args.pop
+        last_key = args.pop
+        # dig down to last subtree (building out if necessary)
+        hsh = self
+        args.each  do |key|
+          hsh.regular_writer(key, self.class.new) unless hsh.has_key?(key)
+          hsh = hsh[key]
+        end
+        # set leaf value
+        hsh[last_key] = val
+      end
+
+      #
+      # Treat hash as tree of hashes:
+      #
+      #     x = { :a => :val_a, :subhash => { :b => :val_b } }
+      #     x.deep_get(:a)
+      #     # => :val_a
+      #     x.deep_get(:subhash, :c)
+      #     # => nil
+      #     x.deep_get(:subhash, :c, :f)
+      #     # => nil
+      #     x.deep_get(:subhash, :b)
+      #     # => nil
+      #
+      def deep_get *args
+        last_key = args.pop
+        # dig down to last subtree (building out if necessary)
+        hsh = args.inject(self){|h, k| h[k] || self.class.new }
+        # get leaf value
+        hsh[last_key]
+      end
+
+      #
+      # Treat hash as tree of hashes:
+      #
+      #     x = { :a => :val, :subhash => { :a => :val1, :b => :val2 } }
+      #     x.deep_delete(:subhash, :a)
+      #     #=> :val
+      #     x
+      #     #=> { :a => :val, :subhash => { :b => :val2 } }
+      #
+      def deep_delete *args
+        last_key  = args.pop                                   # key to delete
+        last_hsh  = args.empty? ? self : (deep_get(*args)||{}) # hsh containing that key
+        last_hsh.delete(last_key)
+      end
+
+      protected
+      # @attr key<Object> The key to convert.
+      #
+      # @attr [Object]
+      #   The converted key. A dotted attr ('moon.cheese.type') becomes
+      #   an array of sequential keys for deep_set and deep_get
+      #
+      # @private
+      def convert_key(attr)
+        case
+        when attr.to_s.include?('.')   then attr.to_s.split(".").map{|sub_attr| sub_attr.to_sym }
+        when attr.is_a?(Array)         then attr.map{|sub_attr| sub_attr.to_sym }
+        else                                attr.to_sym
+        end
+      end
+
+      # @param value<Object> The value to convert.
+      #
+      # @return [Object]
+      #   The converted value. A Hash or an Array of hashes, will be converted to
+      #   their DeepHash equivalents.
+      #
+      # @private
+      def convert_value(value)
+        if value.class == Hash   then self.class.new(value)
+        elsif value.is_a?(Array) then value.collect{|e| convert_value(e) }
+        else                          value
+        end
+      end
+    end
+
+  end
+end

data/lib/gorillib/hashlike/deep_merge.rb

@@ -9,9 +9,10 @@ module Gorillib
       # Returns a new hash with +self+ and +other_hash+ merged recursively.
       # Modifies the receiver in place.
       def deep_merge!(other_hash)
-        other_hash.each_pair do |k,v|
-          tv = self[k]
-          self[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_merge(v) : v
+        other_hash.each_pair do |ok, ov|
+          ov = convert_value(ov) if respond_to?(:convert_value)
+          sv = self[ok]
+          self[ok] = sv.is_a?(Hash) && ov.is_a?(Hash) ? sv.deep_merge(ov) : ov
         end
         self
       end unless method_defined?(:deep_merge!)

data/lib/gorillib/receiver.rb

@@ -1,6 +1,7 @@
 require 'gorillib/object/blank'
 require 'gorillib/object/try'
 require 'gorillib/array/extract_options'
+require 'gorillib/metaprogramming/class_attribute'
 
 # dummy type for receiving True or False
 class Boolean ; end unless defined?(Boolean)
@@ -126,7 +127,7 @@ module Receiver
   #
   def receive! hsh={}
     raise ArgumentError, "Can't receive (it isn't hashlike): {#{hsh.inspect}}" unless hsh.respond_to?(:[]) && hsh.respond_to?(:has_key?)
-    self.class.receiver_attr_names.each do |attr|
+    _receiver_fields.each do |attr|
       if    hsh.has_key?(attr.to_sym) then val = hsh[attr.to_sym]
       elsif hsh.has_key?(attr.to_s)   then val = hsh[attr.to_s]
       else  next ; end
@@ -153,8 +154,20 @@ protected
     self.send("receive_#{attr}", val)
   end
 
+  def _receiver_fields
+    self.class.receiver_attr_names
+  end
+
+  def _receiver_defaults
+    self.class.receiver_defaults
+  end
+
+  def _after_receivers
+    self.class.after_receivers
+  end
+
   def impose_defaults!(hsh)
-    self.class.receiver_defaults.each do |attr, val|
+    _receiver_defaults.each do |attr, val|
       next if attr_set?(attr)
       self.instance_variable_set "@#{attr}", val
     end
@@ -180,7 +193,7 @@ protected
 
 
   def run_after_receivers(hsh)
-    self.class.after_receivers.each do |after_receiver|
+    _after_receivers.each do |after_receiver|
       self.instance_exec(hsh, &after_receiver)
     end
   end
@@ -192,13 +205,14 @@ public
     #
     # Returns a new instance with the given hash used to set all rcvrs.
     #
-    # All args after the first are passed to the initializer.
+    # All args up to the last one are passed to the initializer.
+    # The last arg must be a hash -- its attributes are set on the newly-created object
     #
-    # @param hsh [Hash] attr-value pairs to set on the newly created object
+    # @param hsh [Hash] attr-value pairs to set on the newly created object.
     # @param *args [Array] arguments to pass to the constructor
     # @return [Object] a new instance
     def receive *args
-      hsh = args.extract_options!
+      hsh = args.pop
       raise ArgumentError, "Can't receive (it isn't hashlike): {#{hsh.inspect}} -- the hsh should be the *last* arg" unless hsh.respond_to?(:[]) && hsh.respond_to?(:has_key?)
       obj = self.new(*args)
       obj.receive!(hsh)
@@ -384,4 +398,5 @@ public
       end
     end
   end
+
 end

data/spec/hashlike/deep_hash_spec.rb

@@ -0,0 +1,579 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'gorillib/receiver_model'
+require 'gorillib/hashlike/deep_hash'
+
+
+class AwesomeHash < Hash
+  # include Gorillib::ReceiverModel
+  include Gorillib::Hashlike::DeepHash
+end
+class AwesomeHashSubclass < AwesomeHash ; end
+
+describe Gorillib::Hashlike::DeepHash do
+
+  before(:each) do
+    @deep_hash = AwesomeHash.new({ :nested_1 => { :nested_2 => { :leaf_3 => "val3" }, :leaf_2 => ['arr'] }, :leaf_at_top => 'val1b' })
+    @hash = { "str_key" => "strk_val", :sym_key => "symk_val"}
+    @sub  = AwesomeHashSubclass.new("str_key" => "strk_val", :sym_key => "symk_val")
+  end
+
+  describe "examples" do
+    it 'merges with a nested dotted nested hash' do
+      y = {"a.b.c"=>{"d"=>3, "f.g"=>7}, "p"=>9}
+      x = AwesomeHash.new({ :a => { :b => { :c => { :d => 7, :e => 99 } } }, :p => 5, 'z' => 7, :z => 7 })
+      x.deep_merge(y).should == {:a=>{:b=>{:c=>{:d=>3, :e=>99, :f=>{:g=>7}}}}, :p=>9, :z=>7}
+    end
+
+    it 'breaks if the structures are incommensurate, so do not do that' do
+      y = { 'a.b.c' => 7 }
+      x = AwesomeHash.new({ :a => { :b => 69 }})
+      lambda{ x.deep_merge(y) }.should raise_error(TypeError, /Symbol into Integer/)
+    end
+  end
+
+  # describe "#initialize" do
+  #   it 'adopts a Hash when given' do
+  #     deep_hash = AwesomeHash.new(@hash)
+  #     @hash.each{|k,v| deep_hash[k].should == v }
+  #     deep_hash.keys.any?{|key| key.is_a?(String) }.should be_false
+  #   end
+  #
+  #   it 'converts all pure Hash values into AwesomeHashes if param is a Hash' do
+  #     deep_hash = AwesomeHash.new :sym_key => @hash
+  #     deep_hash[:sym_key].should be_an_instance_of(AwesomeHash)
+  #     # sanity check
+  #     deep_hash[:sym_key][:sym_key].should == "symk_val"
+  #   end
+  #
+  #   it 'does not convert Hash subclass values into AwesomeHashes' do
+  #     deep_hash = AwesomeHash.new :sub => @sub
+  #     deep_hash[:sub].should be_an_instance_of(AwesomeHashSubclass)
+  #   end
+  #
+  #   it 'converts all value items if value is an Array' do
+  #     deep_hash = AwesomeHash.new :arry => { :sym_key => [@hash] }
+  #     deep_hash[:arry].should be_an_instance_of(AwesomeHash)
+  #     # sanity check
+  #     deep_hash[:arry][:sym_key].first[:sym_key].should == "symk_val"
+  #   end
+  #
+  #   it 'delegates to superclass constructor if param is not a Hash' do
+  #     deep_hash = AwesomeHash.new("dash berlin")
+  #
+  #     deep_hash["unexisting key"].should == "dash berlin"
+  #   end
+  # end # describe "#initialize"
+  #
+  # describe "#update" do
+  #   it 'converts all keys into symbols when param is a Hash' do
+  #     deep_hash = AwesomeHash.new(@hash)
+  #     deep_hash.update("starry" => "night")
+  #
+  #     deep_hash.keys.any?{|key| key.is_a?(String) }.should be_false
+  #   end
+  #
+  #   it 'converts all Hash values into AwesomeHashes if param is a Hash' do
+  #     deep_hash = AwesomeHash.new :hash => @hash
+  #     deep_hash.update(:hash => { :sym_key => "is buggy in Ruby 1.8.6" })
+  #
+  #     deep_hash[:hash].should be_an_instance_of(AwesomeHash)
+  #   end
+  # end # describe "#update"
+  #
+  # describe '#[]=' do
+  #   it 'symbolizes keys' do
+  #     @deep_hash['leaf_at_top'] = :fedora
+  #     @deep_hash['new']         = :unseen
+  #     @deep_hash.should == {:nested_1 => {:nested_2 => {:leaf_3 => "val3"}, :leaf_2 => ['arr']}, :leaf_at_top => :fedora, :new => :unseen}
+  #   end
+  #   it 'deep-sets dotted vals, replacing values' do
+  #     @deep_hash['moon.man'] = :cheesy
+  #     @deep_hash[:moon][:man].should == :cheesy
+  #   end
+  #   it 'deep-sets dotted vals, creating new values' do
+  #     @deep_hash['moon.cheese.type'] = :tilsit
+  #     @deep_hash[:moon][:cheese][:type].should == :tilsit
+  #   end
+  #   it 'deep-sets dotted vals, auto-vivifying intermediate hashes' do
+  #     @deep_hash['this.that.the_other'] = :fuhgeddaboudit
+  #     @deep_hash[:this][:that][:the_other].should == :fuhgeddaboudit
+  #   end
+  #   it 'converts all Hash value into AwesomeHash' do
+  #     deep_hash = AwesomeHash.new :hash => @hash
+  #     deep_hash[:hash] = { :sym_key => "is buggy in Ruby 1.8.6" }
+  #     deep_hash[:hash].should be_an_instance_of(AwesomeHash)
+  #   end
+  #
+  #   it "only accepts #to_sym'bolizable things as keys" do
+  #     lambda{ @deep_hash[1] = 'hi'            }.should raise_error(NoMethodError, /undefined method `to_sym'/)
+  #     lambda{ @deep_hash[{ :a => :b }] = 'hi' }.should raise_error(NoMethodError, /undefined method `to_sym'/)
+  #     lambda{ @deep_hash[Object.new] = 'hi'   }.should raise_error(NoMethodError, /undefined method `to_sym'/)
+  #     lambda{ @deep_hash[:a] = 'hi'           }.should_not raise_error
+  #   end
+  # end
+  #
+  # describe '#[]' do
+  #   it 'deep-gets dotted vals' do
+  #     hsh = { :hat => :cat, :basket => :lotion, :moon => { :man => :smiling, :cheese => {:type => :tilsit} } }
+  #     @deep_hash = Configliere::Param.new hsh.dup
+  #     @deep_hash['moon.man'].should == :smiling
+  #     @deep_hash['moon.cheese.type'].should == :tilsit
+  #     @deep_hash['moon.cheese.smell'].should be_nil
+  #     @deep_hash['moon.non.existent.interim.values'].should be_nil
+  #     @deep_hash['moon.non'].should be_nil
+  #     if (RUBY_VERSION >= '1.9') then lambda{ @deep_hash['hat.cat'] }.should raise_error(TypeError)
+  #     else                            lambda{ @deep_hash['hat.cat'] }.should raise_error(NoMethodError, 'undefined method `[]\' for :cat:Symbol') end
+  #     @deep_hash.should == hsh # shouldn't change from reading (specifically, shouldn't autovivify)
+  #   end
+  #
+  #   it "only accepts #to_sym'bolizable things as keys" do
+  #     lambda{ @deep_hash[1]            }.should raise_error(NoMethodError, /undefined method `to_sym'/)
+  #     lambda{ @deep_hash[{ :a => :b }] }.should raise_error(NoMethodError, /undefined method `to_sym'/)
+  #     lambda{ @deep_hash[Object.new]   }.should raise_error(NoMethodError, /undefined method `to_sym'/)
+  #   end
+  # end
+  #
+  # def arrays_should_be_equal arr1, arr2
+  #   arr1.sort_by{|s| s.to_s }.should == arr2.sort_by{|s| s.to_s }
+  # end
+  #
+  # describe "#to_hash" do
+  #   it 'returns instance of Hash' do
+  #     AwesomeHash.new(@hash).to_hash.should be_an_instance_of(Hash)
+  #   end
+  #
+  #   it 'preserves keys' do
+  #     deep_hash = AwesomeHash.new(@hash)
+  #     converted  = deep_hash.to_hash
+  #     arrays_should_be_equal deep_hash.keys, converted.keys
+  #   end
+  #
+  #   it 'preserves value' do
+  #     deep_hash = AwesomeHash.new(@hash)
+  #     converted = deep_hash.to_hash
+  #     arrays_should_be_equal deep_hash.values, converted.values
+  #   end
+  # end
+  #
+  # describe '#compact' do
+  #   it 'removes nils but not empties or falsehoods' do
+  #     AwesomeHash.new({ :a => nil }).compact.should == {}
+  #     AwesomeHash.new({ :a => nil, :b => false, :c => {}, :d => "", :remains => true }).compact.should == { :b => false, :c => {}, :d => "", :remains => true }
+  #   end
+  #
+  #   it 'leaves original alone' do
+  #     deep_hash = AwesomeHash.new({ :a => nil, :remains => true })
+  #     deep_hash.compact.should == { :remains => true }
+  #     deep_hash.should == { :a => nil, :remains => true }
+  #   end
+  # end
+  #
+  # describe '#compact!' do
+  #   it 'removes nils but not empties or falsehoods' do
+  #     AwesomeHash.new({ :a => nil}).compact!.should == {}
+  #     AwesomeHash.new({ :a => nil, :b => false, :c => {}, :d => "", :remains => true }).compact!.should == { :b => false, :c => {}, :d => "", :remains => true }
+  #   end
+  #
+  #   it 'modifies in-place' do
+  #     deep_hash = AwesomeHash.new({ :a => nil, :remains => true })
+  #     deep_hash.compact!.should == { :remains => true }
+  #     deep_hash.should == { :remains => true }
+  #   end
+  # end
+  #
+  # describe '#slice' do
+  #   before do
+  #     @deep_hash = AwesomeHash.new({ :a => 'x', :b => 'y', :c => 10 })
+  #   end
+  #
+  #   it 'returns a new hash with only the given keys' do
+  #     @deep_hash.slice(:a, :b).should == { :a => 'x', :b => 'y' }
+  #     @deep_hash.should == { :a => 'x', :b => 'y', :c => 10 }
+  #   end
+  #
+  #   it 'with bang replaces the hash with only the given keys' do
+  #     @deep_hash.slice!(:a, :b).should == { :c => 10 }
+  #     @deep_hash.should == { :a => 'x', :b => 'y' }
+  #   end
+  #
+  #   it 'ignores an array key' do
+  #     @deep_hash.slice([:a, :b], :c).should == { :c => 10 }
+  #     @deep_hash.should == { :a => 'x', :b => 'y', :c => 10 }
+  #   end
+  #
+  #   it 'with bang ignores an array key' do
+  #     @deep_hash.slice!([:a, :b], :c).should == { :a => 'x', :b => 'y' }
+  #     @deep_hash.should == { :c => 10 }
+  #   end
+  #
+  #   it 'uses splatted keys individually' do
+  #     @deep_hash.slice(*[:a, :b]).should == { :a => 'x', :b => 'y' }
+  #     @deep_hash.should == { :a => 'x', :b => 'y', :c => 10 }
+  #   end
+  #
+  #   it 'with bank uses splatted keys individually' do
+  #     @deep_hash.slice!(*[:a, :b]).should == { :c => 10 }
+  #     @deep_hash.should == { :a => 'x', :b => 'y' }
+  #   end
+  # end
+  #
+  # describe '#extract' do
+  #   before do
+  #     @deep_hash = AwesomeHash.new({ :a => 'x', :b => 'y', :c => 10 })
+  #   end
+  #
+  #   it 'replaces the hash with only the given keys' do
+  #     @deep_hash.extract!(:a, :b).should == { :a => 'x', :b => 'y' }
+  #     @deep_hash.should == { :c => 10 }
+  #   end
+  #
+  #   it 'leaves the hash empty if all keys are gone' do
+  #     @deep_hash.extract!(:a, :b, :c).should == { :a => 'x', :b => 'y', :c => 10 }
+  #     @deep_hash.should == {}
+  #   end
+  #
+  #   it 'gets values for all given keys even if missing' do
+  #     @deep_hash.extract!(:bob, :c).should == { :bob => nil, :c => 10 }
+  #     @deep_hash.should == { :a => 'x', :b => 'y' }
+  #   end
+  #
+  #   it 'is OK when empty' do
+  #     AwesomeHash.new.slice!(:a, :b, :c).should == {}
+  #   end
+  #
+  #   it 'returns an instance of the same class' do
+  #     @deep_hash.slice(:a).should be_a(AwesomeHash)
+  #   end
+  # end
+  #
+  # describe "#delete" do
+  #   it 'converts Symbol key into String before deleting' do
+  #     deep_hash = AwesomeHash.new(@hash)
+  #
+  #     deep_hash.delete(:sym_key)
+  #     deep_hash.key?("hash").should be_false
+  #   end
+  #
+  #   it 'works with String keys as well' do
+  #     deep_hash = AwesomeHash.new(@hash)
+  #
+  #     deep_hash.delete("str_key")
+  #     deep_hash.key?("str_key").should be_false
+  #   end
+  # end
+  #
+  # describe "#fetch" do
+  #   before(:each) do
+  #     @deep_hash = AwesomeHash.new(:no => "in between")
+  #   end
+  #
+  #   it 'converts key before fetching' do
+  #     @deep_hash.fetch("no").should == "in between"
+  #   end
+  #
+  #   it 'returns alternative value if key lookup fails' do
+  #     @deep_hash.fetch("flying", "screwdriver").should == "screwdriver"
+  #   end
+  # end
+  #
+  # describe "#values_at" do
+  #   before(:each) do
+  #     @deep_hash = AwesomeHash.new(@hash).merge(:no => "in between")
+  #   end
+  #
+  #   it 'is indifferent to whether keys are strings or symbols' do
+  #     @deep_hash.values_at("sym_key", :str_key, :no).should == ["symk_val", "strk_val", "in between"]
+  #   end
+  # end
+  #
+  # it 'responds to #symbolize_keys, #symbolize_keys! and #stringify_keys but not #stringify_keys!' do
+  #   AwesomeHash.new.should respond_to(:symbolize_keys )
+  #   AwesomeHash.new.should respond_to(:symbolize_keys!)
+  #   AwesomeHash.new.should respond_to(:stringify_keys )
+  #   AwesomeHash.new.should_not respond_to(:stringify_keys!)
+  # end
+  #
+  # describe '#symbolize_keys' do
+  #   it 'returns a dup of itself' do
+  #     deep_hash = AwesomeHash.new(@hash)
+  #     deep_hash.symbolize_keys.should == deep_hash
+  #   end
+  # end
+  #
+  # describe '#symbolize_keys!' do
+  #   it 'with bang returns the deep_hash itself' do
+  #     deep_hash = AwesomeHash.new(@hash)
+  #     deep_hash.symbolize_keys!.object_id.should == deep_hash.object_id
+  #   end
+  # end
+  #
+  # describe '#stringify_keys' do
+  #   it 'converts keys that are all symbols' do
+  #     @deep_hash.stringify_keys.should ==
+  #       { 'nested_1' => { :nested_2 => { :leaf_3 => "val3" }, :leaf_2 => ['arr'] }, 'leaf_at_top' => 'val1b' }
+  #   end
+  #
+  #   it 'returns a Hash, not a AwesomeHash' do
+  #     @deep_hash.stringify_keys.class.should == Hash
+  #     @deep_hash.stringify_keys.should_not be_a(AwesomeHash)
+  #   end
+  #
+  #   it 'only stringifies and hashifies the top level' do
+  #     stringified = @deep_hash.stringify_keys
+  #     stringified.should == { 'nested_1' => { :nested_2 => { :leaf_3 => "val3" }, :leaf_2 => ['arr'] }, 'leaf_at_top' => 'val1b' }
+  #     stringified['nested_1'].should be_a(AwesomeHash)
+  #   end
+  # end
+  #
+  # describe '#assert_valid_keys' do
+  #   before do
+  #     @deep_hash = AwesomeHash.new({ :failure => "stuff", :funny => "business" })
+  #   end
+  #
+  #   it 'is true and does not raise when valid' do
+  #     @deep_hash.assert_valid_keys([ :failure, :funny ]).should be_nil
+  #     @deep_hash.assert_valid_keys(:failure, :funny).should be_nil
+  #   end
+  #
+  #   it 'fails when invalid' do
+  #     @deep_hash[:failore] = @deep_hash.delete(:failure)
+  #     lambda{ @deep_hash.assert_valid_keys([ :failure, :funny ]) }.should raise_error(ArgumentError, "Unknown key(s): failore")
+  #     lambda{ @deep_hash.assert_valid_keys(:failure, :funny)     }.should raise_error(ArgumentError, "Unknown key(s): failore")
+  #   end
+  # end
+  #
+  # describe "#merge" do
+  #   it 'merges given Hash' do
+  #     merged = @deep_hash.merge(:no => "in between")
+  #     merged.should == { :nested_1 => { :nested_2 => { :leaf_3 => "val3" }, :leaf_2 => ['arr'] }, :leaf_at_top => 'val1b', :no => 'in between' }
+  #   end
+  #
+  #   it 'returns a new instance' do
+  #     merged = @deep_hash.merge(:no => "in between")
+  #     merged.should_not equal(@deep_hash)
+  #   end
+  #
+  #   it 'returns instance of AwesomeHash' do
+  #     merged = @deep_hash.merge(:no => "in between")
+  #     merged.should be_an_instance_of(AwesomeHash)
+  #     merged[:no].should  == "in between"
+  #     merged["no"].should == "in between"
+  #   end
+  #
+  #   it "converts all Hash values into AwesomeHashes"  do
+  #     merged = @deep_hash.merge({ :nested_1 => { 'nested_2' => { :leaf_3_also => "val3a" } }, :other1 => { "other2" => "other_val2" }})
+  #     merged[:nested_1].should be_an_instance_of(AwesomeHash)
+  #     merged[:nested_1][:nested_2].should be_an_instance_of(AwesomeHash)
+  #     merged[:other1].should be_an_instance_of(AwesomeHash)
+  #   end
+  #
+  #   it "converts string keys to symbol keys even if they occur deep in the given hash" do
+  #     merged = @deep_hash.merge({   'a' => { 'b' => { 'c' => { :d => :e }}}})
+  #     merged[:a].should     == { :b  => { :c  => { :d => :e }}}
+  #     merged[:a].should_not == { 'b' => { 'c' => { :d => :e }}}
+  #   end
+  #
+  #   it "DOES merge values where given hash has nil value" do
+  #     merged = @deep_hash.merge(:a => { :b => nil }, :c => nil, :leaf_3_also => nil)
+  #     merged[:a][:b].should be_nil
+  #     merged[:c].should be_nil
+  #     merged[:leaf_3_also].should be_nil
+  #   end
+  #
+  #   it "replaces child hashes, and does not merge them"  do
+  #     merged = @deep_hash.merge({ :nested_1 => { 'nested_2' => { :leaf_3_also => "val3a" } }, :other1 => { "other2" => "other_val2" }})
+  #     merged.should          == { :nested_1 => { :nested_2  => { :leaf_3_also => "val3a" } }, :other1 => { :other2 => "other_val2" }, :leaf_at_top => 'val1b' }
+  #   end
+  # end
+  #
+  # describe "#merge!" do
+  #   it 'merges given Hash' do
+  #     @deep_hash.merge!(:no => "in between")
+  #     @deep_hash.should == { :nested_1 => { :nested_2 => { :leaf_3 => "val3" }, :leaf_2 => ['arr'] }, :leaf_at_top => 'val1b', :no => 'in between' }
+  #   end
+  #
+  #   it 'returns a new instance' do
+  #     @deep_hash.merge!(:no => "in between")
+  #     @deep_hash.should equal(@deep_hash)
+  #   end
+  #
+  #   it 'returns instance of AwesomeHash' do
+  #     @deep_hash.merge!(:no => "in between")
+  #     @deep_hash.should be_an_instance_of(AwesomeHash)
+  #     @deep_hash[:no].should  == "in between"
+  #     @deep_hash["no"].should == "in between"
+  #   end
+  #
+  #   it "converts all Hash values into AwesomeHashes"  do
+  #     @deep_hash.merge!({ :nested_1 => { 'nested_2' => { :leaf_3_also => "val3a" } }, :other1 => { "other2" => "other_val2" }})
+  #     @deep_hash[:nested_1].should be_an_instance_of(AwesomeHash)
+  #     @deep_hash[:nested_1][:nested_2].should be_an_instance_of(AwesomeHash)
+  #     @deep_hash[:other1].should be_an_instance_of(AwesomeHash)
+  #   end
+  #
+  #   it "converts string keys to symbol keys even if they occur deep in the given hash" do
+  #     @deep_hash.merge!({   'a' => { 'b' => { 'c' => { :d => :e }}}})
+  #     @deep_hash[:a].should     == { :b  => { :c  => { :d => :e }}}
+  #     @deep_hash[:a].should_not == { 'b' => { 'c' => { :d => :e }}}
+  #   end
+  #
+  #   it "DOES merge values where given hash has nil value" do
+  #     @deep_hash.merge!(:a => { :b => nil }, :c => nil, :leaf_3_also => nil)
+  #     @deep_hash[:a][:b].should be_nil
+  #     @deep_hash[:c].should be_nil
+  #     @deep_hash[:leaf_3_also].should be_nil
+  #   end
+  #
+  #   it "replaces child hashes, and does not merge them"  do
+  #     @deep_hash = @deep_hash.merge!({ :nested_1 => { 'nested_2' => { :leaf_3_also => "val3a" } }, :other1 => { "other2" => "other_val2" }})
+  #     @deep_hash.should           == { :nested_1 => { :nested_2  => { :leaf_3_also => "val3a" } }, :other1 => { :other2  => "other_val2" }, :leaf_at_top => 'val1b' }
+  #     @deep_hash.should_not       == { :nested_1 => { 'nested_2' => { :leaf_3_also => "val3a" } }, :other1 => { "other2" => "other_val2" }, :leaf_at_top => 'val1b' }
+  #   end
+  # end
+  #
+  # describe "#reverse_merge" do
+  #   it 'merges given Hash' do
+  #     @deep_hash.reverse_merge!(:no => "in between", :leaf_at_top => 'NOT_USED')
+  #     @deep_hash.should == { :nested_1 => { :nested_2 => { :leaf_3 => "val3" }, :leaf_2 => ['arr'] }, :leaf_at_top => 'val1b', :no => 'in between' }
+  #   end
+  #
+  #   it 'returns a new instance' do
+  #     @deep_hash.reverse_merge!(:no => "in between")
+  #     @deep_hash.should equal(@deep_hash)
+  #   end
+  #
+  #   it 'returns instance of AwesomeHash' do
+  #     @deep_hash.reverse_merge!(:no => "in between")
+  #     @deep_hash.should be_an_instance_of(AwesomeHash)
+  #     @deep_hash[:no].should  == "in between"
+  #     @deep_hash["no"].should == "in between"
+  #   end
+  #
+  #   it "converts all Hash values into AwesomeHashes"  do
+  #     @deep_hash.reverse_merge!({ :nested_1 => { 'nested_2' => { :leaf_3_also => "val3a" } }, :other1 => { "other2" => "other_val2" }})
+  #     @deep_hash[:nested_1].should be_an_instance_of(AwesomeHash)
+  #     @deep_hash[:nested_1][:nested_2].should be_an_instance_of(AwesomeHash)
+  #     @deep_hash[:other1].should be_an_instance_of(AwesomeHash)
+  #   end
+  #
+  #   it "converts string keys to symbol keys even if they occur deep in the given hash" do
+  #     merged = @deep_hash.reverse_merge({   'a' => { 'b' => { 'c' => { :d => :e }}}})
+  #     merged[:a].should     == { :b  => { :c  => { :d => :e }}}
+  #     merged[:a].should_not == { 'b' => { 'c' => { :d => :e }}}
+  #   end
+  #
+  #   it "DOES merge values where given hash has nil value" do
+  #     @deep_hash.reverse_merge!(:a => { :b => nil }, :c => nil)
+  #     @deep_hash[:a][:b].should be_nil
+  #     @deep_hash[:c].should     be_nil
+  #   end
+  #
+  #   it "replaces child hashes, and does not merge them"  do
+  #     @deep_hash = @deep_hash.reverse_merge!({ :nested_1 => { 'nested_2' => { :leaf_3_also => "val3a" } },                     :other1 => { "other2" => "other_val2" }})
+  #     @deep_hash.should                   == { :nested_1 => { :nested_2  => { :leaf_3      => "val3"  }, :leaf_2 => ['arr'] }, :other1 => { :other2 => "other_val2" }, :leaf_at_top => 'val1b' }
+  #   end
+  # end
+  #
+  # describe "#deep_merge!" do
+  #   it "merges two subhashes when they share a key" do
+  #     @deep_hash.deep_merge!(:nested_1 => { :nested_2  => { :leaf_3_also  => "val3a" } })
+  #     @deep_hash.should == { :nested_1 => { :nested_2  => { :leaf_3_also  => "val3a", :leaf_3 => "val3" }, :leaf_2 => ['arr'] }, :leaf_at_top => 'val1b' }
+  #   end
+  #
+  #   it "merges two subhashes when they share a symbolized key" do
+  #     @deep_hash.deep_merge!(:nested_1 => { "nested_2" => { "leaf_3_also" => "val3a" } })
+  #     @deep_hash.should == { :nested_1 => { :nested_2  => { :leaf_3_also  => "val3a", :leaf_3 => "val3" }, :leaf_2 => ['arr'] }, :leaf_at_top => "val1b" }
+  #   end
+  #
+  #   it "preserves values in the original" do
+  #     @deep_hash.deep_merge! :other_key => "other_val"
+  #     @deep_hash[:nested_1][:leaf_2].should == ['arr']
+  #     @deep_hash[:other_key].should == "other_val"
+  #   end
+  #
+  #   it "converts all Hash values into AwesomeHashes"  do
+  #     @deep_hash.deep_merge!({:nested_1 => { :nested_2 => { :leaf_3_also => "val3a" } }, :other1 => { "other2" => "other_val2" }})
+  #     @deep_hash[:nested_1].should be_an_instance_of(AwesomeHash)
+  #     @deep_hash[:nested_1][:nested_2].should be_an_instance_of(AwesomeHash)
+  #     @deep_hash[:other1].should be_an_instance_of(AwesomeHash)
+  #   end
+  #
+  #   it "converts string keys to symbol keys even if they occur deep in the given hash" do
+  #     @deep_hash.deep_merge!({   'a' => { 'b' => { 'c' => { :d => :e }}}})
+  #     @deep_hash[:a].should     == { :b  => { :c  => { :d => :e }}}
+  #     @deep_hash[:a].should_not == { 'b' => { 'c' => { :d => :e }}}
+  #   end
+  #
+  #   it "replaces values from the given hash" do
+  #     @deep_hash.deep_merge!(:nested_1 => { :nested_2 => { :leaf_3 => "new_val3" }, :leaf_2 => { "other2" => "other_val2" }})
+  #     @deep_hash[:nested_1][:nested_2][:leaf_3].should == 'new_val3'
+  #     @deep_hash[:nested_1][:leaf_2].should == { :other2 => "other_val2" }
+  #   end
+  #
+  #   it "replaces arrays and does not append to them" do
+  #     @deep_hash.deep_merge!(:nested_1 => { :nested_2 => { :leaf_3 => [] }, :leaf_2 => ['val2'] })
+  #     @deep_hash[:nested_1][:nested_2][:leaf_3].should == []
+  #     @deep_hash[:nested_1][:leaf_2].should == ['val2']
+  #   end
+  #
+  #   it "does not replaces values where given hash has nil value" do
+  #     @deep_hash.deep_merge!(:nested_1 => { :leaf_2 => nil }, :leaf_at_top => '')
+  #     @deep_hash[:nested_1][:leaf_2].should == ['arr']
+  #     @deep_hash[:leaf_at_top].should == ""
+  #   end
+  # end
+  #
+  #
+  # describe "#deep_set" do
+  #   it 'should set a new value (single arg)' do
+  #     @deep_hash.deep_set :new_key, 'new_val'
+  #     @deep_hash[:new_key].should == 'new_val'
+  #   end
+  #   it 'should set a new value (multiple args)' do
+  #     @deep_hash.deep_set :nested_1, :nested_2, :new_key, 'new_val'
+  #     @deep_hash[:nested_1][:nested_2][:new_key].should == 'new_val'
+  #   end
+  #   it 'should replace an existing value (single arg)' do
+  #     @deep_hash.deep_set :leaf_at_top, 'new_val'
+  #     @deep_hash[:leaf_at_top].should == 'new_val'
+  #   end
+  #   it 'should replace an existing value (multiple args)' do
+  #     @deep_hash.deep_set :nested_1, :nested_2, 'new_val'
+  #     @deep_hash[:nested_1][:nested_2].should == 'new_val'
+  #   end
+  #   it 'should auto-vivify intermediate hashes' do
+  #     @deep_hash.deep_set :one, :two, :three, :four, 'new_val'
+  #     @deep_hash[:one][:two][:three][:four].should == 'new_val'
+  #   end
+  # end
+  #
+  # describe "#deep_delete" do
+  #   it 'should remove the key from the array (multiple args)' do
+  #     @deep_hash.deep_delete(:nested_1)
+  #     @deep_hash[:nested_1].should be_nil
+  #     @deep_hash.should == { :leaf_at_top => 'val1b'}
+  #   end
+  #   it 'should remove the key from the array (multiple args)' do
+  #     @deep_hash.deep_delete(:nested_1, :nested_2, :leaf_3)
+  #     @deep_hash[:nested_1][:nested_2][:leaf_3].should be_nil
+  #     @deep_hash.should == {:leaf_at_top => "val1b", :nested_1 => {:leaf_2 => ['arr'], :nested_2 => {}}}
+  #   end
+  #   it 'should return the value if present (single args)' do
+  #     returned_val = @deep_hash.deep_delete(:leaf_at_top)
+  #     returned_val.should == 'val1b'
+  #   end
+  #   it 'should return the value if present (multiple args)' do
+  #     returned_val = @deep_hash.deep_delete(:nested_1, :nested_2, :leaf_3)
+  #     returned_val.should == 'val3'
+  #   end
+  #   it 'should return nil if the key is absent (single arg)' do
+  #     returned_val = @deep_hash.deep_delete(:nested_1, :nested_2, :missing_key)
+  #     returned_val.should be_nil
+  #   end
+  #   it 'should return nil if the key is absent (multiple args)' do
+  #     returned_val = @deep_hash.deep_delete(:missing_key)
+  #     returned_val.should be_nil
+  #   end
+  # end
+
+end

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: gorillib
 version: !ruby/object:Gem::Version 
-  hash: 19
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 4
-  version: 0.1.4
+  prerelease: 
+  version: 0.1.5
 platform: ruby
 authors: 
 - Infochimps
@@ -15,243 +10,171 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-06 00:00:00 -05:00
-default_executable: 
+date: 2011-08-02 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
+  name: bundler
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 1
-        - 0
-        - 12
         version: 1.0.12
   type: :development
-  name: bundler
   prerelease: false
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
+  name: yard
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 9
-        segments: 
-        - 0
-        - 6
-        - 7
         version: 0.6.7
   type: :development
-  name: yard
   prerelease: false
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
+  name: jeweler
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 1
-        - 5
-        - 2
         version: 1.5.2
   type: :development
-  name: jeweler
   prerelease: false
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
+  name: rspec
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 27
-        segments: 
-        - 2
-        - 5
-        - 0
         version: 2.5.0
   type: :development
-  name: rspec
   prerelease: false
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
+  name: spork
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 977940482
-        segments: 
-        - 0
-        - 9
-        - 0
-        - rc5
         version: 0.9.0.rc5
   type: :development
-  name: spork
   prerelease: false
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
+  name: RedCloth
   requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
   type: :development
-  name: RedCloth
   prerelease: false
   version_requirements: *id006
 - !ruby/object:Gem::Dependency 
+  name: rcov
   requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 41
-        segments: 
-        - 0
-        - 9
-        - 9
         version: 0.9.9
   type: :development
-  name: rcov
   prerelease: false
   version_requirements: *id007
 - !ruby/object:Gem::Dependency 
+  name: watchr
   requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
   type: :development
-  name: watchr
   prerelease: false
   version_requirements: *id008
 - !ruby/object:Gem::Dependency 
+  name: bundler
   requirement: &id009 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 1
-        - 0
-        - 12
         version: 1.0.12
   type: :development
-  name: bundler
   prerelease: false
   version_requirements: *id009
 - !ruby/object:Gem::Dependency 
+  name: yard
   requirement: &id010 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 9
-        segments: 
-        - 0
-        - 6
-        - 7
         version: 0.6.7
   type: :development
-  name: yard
   prerelease: false
   version_requirements: *id010
 - !ruby/object:Gem::Dependency 
+  name: jeweler
   requirement: &id011 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 1
-        - 5
-        - 2
         version: 1.5.2
   type: :development
-  name: jeweler
   prerelease: false
   version_requirements: *id011
 - !ruby/object:Gem::Dependency 
+  name: rspec
   requirement: &id012 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 27
-        segments: 
-        - 2
-        - 5
-        - 0
         version: 2.5.0
   type: :development
-  name: rspec
   prerelease: false
   version_requirements: *id012
 - !ruby/object:Gem::Dependency 
+  name: rcov
   requirement: &id013 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 41
-        segments: 
-        - 0
-        - 9
-        - 9
         version: 0.9.9
   type: :development
-  name: rcov
   prerelease: false
   version_requirements: *id013
 - !ruby/object:Gem::Dependency 
+  name: spork
   requirement: &id014 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 977940482
-        segments: 
-        - 0
-        - 9
-        - 0
-        - rc5
         version: 0.9.0.rc5
   type: :development
-  name: spork
   prerelease: false
   version_requirements: *id014
 - !ruby/object:Gem::Dependency 
+  name: watchr
   requirement: &id015 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
   type: :development
-  name: watchr
   prerelease: false
   version_requirements: *id015
 description: "Gorillib: infochimps lightweight subset of ruby convenience methods"
@@ -268,7 +191,6 @@ files:
 - .rspec
 - CHANGELOG.textile
 - Gemfile
-- Gemfile.lock
 - LICENSE.textile
 - README.textile
 - Rakefile
@@ -296,6 +218,7 @@ files:
 - lib/gorillib/hashlike/compact.rb
 - lib/gorillib/hashlike/deep_compact.rb
 - lib/gorillib/hashlike/deep_dup.rb
+- lib/gorillib/hashlike/deep_hash.rb
 - lib/gorillib/hashlike/deep_merge.rb
 - lib/gorillib/hashlike/hashlike_via_accessors.rb
 - lib/gorillib/hashlike/keys.rb
@@ -345,6 +268,7 @@ files:
 - spec/hash/slice_spec.rb
 - spec/hash/zip_spec.rb
 - spec/hashlike/behave_same_as_hash_spec.rb
+- spec/hashlike/deep_hash_spec.rb
 - spec/hashlike/hashlike_behavior_spec.rb
 - spec/hashlike/hashlike_via_accessors_spec.rb
 - spec/hashlike_spec.rb
@@ -378,7 +302,6 @@ files:
 - spec/support/matchers/be_hash_eql.rb
 - spec/support/matchers/enumerate_method.rb
 - spec/support/matchers/evaluate_to_true.rb
-has_rdoc: true
 homepage: http://infochimps.com/labs
 licenses: 
 - MIT
@@ -392,7 +315,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 168082518924887953
       segments: 
       - 0
       version: "0"
@@ -401,14 +324,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: include only what you need. No dependencies, no creep
@@ -427,6 +347,7 @@ test_files:
 - spec/hash/slice_spec.rb
 - spec/hash/zip_spec.rb
 - spec/hashlike/behave_same_as_hash_spec.rb
+- spec/hashlike/deep_hash_spec.rb
 - spec/hashlike/hashlike_behavior_spec.rb
 - spec/hashlike/hashlike_via_accessors_spec.rb
 - spec/hashlike_spec.rb

data/Gemfile.lock

@@ -1,36 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    RedCloth (4.2.7)
-    diff-lcs (1.1.2)
-    git (1.2.5)
-    jeweler (1.5.2)
-      bundler (~> 1.0.0)
-      git (>= 1.2.5)
-      rake
-    rake (0.8.7)
-    rcov (0.9.9)
-    rspec (2.5.0)
-      rspec-core (~> 2.5.0)
-      rspec-expectations (~> 2.5.0)
-      rspec-mocks (~> 2.5.0)
-    rspec-core (2.5.2)
-    rspec-expectations (2.5.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.5.0)
-    spork (0.9.0.rc7)
-    watchr (0.7)
-    yard (0.6.8)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  RedCloth
-  bundler (~> 1.0.12)
-  jeweler (~> 1.5.2)
-  rcov (>= 0.9.9)
-  rspec (~> 2.5.0)
-  spork (~> 0.9.0.rc5)
-  watchr
-  yard (~> 0.6.7)