gorillib 0.0.8 → 0.1.0

data/spec/hash/deep_merge_spec.rb

@@ -96,8 +96,6 @@ describe Hash do
     end
   end
 
-
-
   describe '#deep_dup' do
     # def test_deep_dup
     #   hash = { :a => { :b => 'b' } }

data/spec/hash/indifferent_access_spec.rb

@@ -0,0 +1,391 @@
+require 'gorillib/hash/indifferent_access'
+require 'gorillib/hash/slice'
+require 'gorillib/hash/reverse_merge'
+require 'gorillib/hash/deep_merge'
+require 'gorillib/hash/deep_dup'
+
+describe Gorillib::HashWithIndifferentAccess do
+  class IndifferentHash < Gorillib::HashWithIndifferentAccess
+  end
+
+  class SubclassingArray < Array
+  end
+
+  class SubclassingHash < Hash
+  end
+
+  class NonIndifferentHash < Hash
+    def nested_under_indifferent_access
+      self
+    end
+  end
+
+  before do
+    @strings = { 'a' => 1, 'b' => 2 }
+    @symbols = { :a  => 1, :b  => 2 }
+    @mixed   = { :a  => 1, 'b' => 2 }
+    @fixnums = {  0  => 1,  1  => 2 }
+    if RUBY_VERSION < '1.9.0'
+      @illegal_symbols = { "\0" => 1, "" => 2, [] => 3 }
+    else
+      @illegal_symbols = { [] => 3 }
+    end
+  end
+
+  it 'symbolize_keys_for_hash_with_indifferent_access' do
+    @symbols.with_indifferent_access.symbolize_keys.should be_an_instance_of(Hash)
+    @symbols.with_indifferent_access.symbolize_keys.should == @symbols
+    @strings.with_indifferent_access.symbolize_keys.should == @symbols
+    @mixed.with_indifferent_access.symbolize_keys.should == @symbols
+  end
+
+  it 'symbolize_keys_bang_for_hash_with_indifferent_access' do
+    lambda{ @symbols.with_indifferent_access.dup.symbolize_keys! }.should raise_error(NoMethodError)
+    lambda{ @strings.with_indifferent_access.dup.symbolize_keys! }.should raise_error(NoMethodError)
+    lambda{ @mixed.with_indifferent_access.dup.symbolize_keys! }.should raise_error(NoMethodError)
+  end
+
+  it 'symbolize_keys_preserves_keys_that_cant_be_symbolized_for_hash_with_indifferent_access' do
+    @illegal_symbols.with_indifferent_access.symbolize_keys.should == @illegal_symbols
+    lambda{ @illegal_symbols.with_indifferent_access.dup.symbolize_keys! }.should raise_error(NoMethodError)
+  end
+
+  it 'symbolize_keys_preserves_fixnum_keys_for_hash_with_indifferent_access' do
+    @fixnums.with_indifferent_access.symbolize_keys.should == @fixnums
+    lambda{ @fixnums.with_indifferent_access.dup.symbolize_keys! }.should raise_error(NoMethodError)
+  end
+
+  it 'stringify_keys_for_hash_with_indifferent_access' do
+    @symbols.with_indifferent_access.stringify_keys.should be_an_instance_of(Gorillib::HashWithIndifferentAccess)
+    @symbols.with_indifferent_access.stringify_keys.should == @strings
+    @strings.with_indifferent_access.stringify_keys.should == @strings
+    @mixed.with_indifferent_access.stringify_keys.should == @strings
+  end
+
+  it 'stringify_keys_bang_for_hash_with_indifferent_access' do
+    @symbols.with_indifferent_access.dup.stringify_keys!.should be_an_instance_of(Gorillib::HashWithIndifferentAccess)
+    @symbols.with_indifferent_access.dup.stringify_keys!.should == @strings
+    @strings.with_indifferent_access.dup.stringify_keys!.should == @strings
+    @mixed.with_indifferent_access.dup.stringify_keys!.should == @strings
+  end
+
+  it 'nested_under_indifferent_access' do
+    foo = { "foo" => SubclassingHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
+    foo["foo"].should be_a(Gorillib::HashWithIndifferentAccess)
+
+    foo = { "foo" => NonIndifferentHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
+    foo["foo"].should be_a(NonIndifferentHash)
+  end
+
+  it 'indifferent_assorted' do
+    @strings = @strings.with_indifferent_access
+    @symbols = @symbols.with_indifferent_access
+    @mixed   = @mixed.with_indifferent_access
+
+    @strings.__send__(:convert_key, :a).should == 'a'
+
+    @strings.fetch('a').should == 1
+    @strings.fetch(:a.to_s).should == 1
+    @strings.fetch(:a).should == 1
+
+    hashes = { :@strings => @strings, :@symbols => @symbols, :@mixed => @mixed }
+    method_map = { :'[]' => 1, :fetch => 1, :values_at => [1],
+      :has_key? => true, :include? => true, :key? => true,
+      :member? => true }
+
+    hashes.each do |name, hash|
+      method_map.sort_by { |m| m.to_s }.each do |meth, expected|
+        hash.__send__(meth, 'a').should == expected
+        hash.__send__(meth, :a).should == expected
+      end
+    end
+
+    @strings.values_at('a', 'b').should == [1, 2]
+    @strings.values_at(:a, :b).should == [1, 2]
+    @symbols.values_at('a', 'b').should == [1, 2]
+    @symbols.values_at(:a, :b).should == [1, 2]
+    @mixed.values_at('a', 'b').should == [1, 2]
+    @mixed.values_at(:a, :b).should == [1, 2]
+  end
+
+  it 'indifferent_reading' do
+    hash = Gorillib::HashWithIndifferentAccess.new
+    hash["a"] = 1
+    hash["b"] = true
+    hash["c"] = false
+    hash["d"] = nil
+
+    hash[:a].should == 1
+    hash[:b].should == true
+    hash[:c].should == false
+    hash[:d].should == nil
+    hash[:e].should == nil
+  end
+
+  it 'indifferent_reading_with_nonnil_default' do
+    hash = Gorillib::HashWithIndifferentAccess.new(1)
+    hash["a"] = 1
+    hash["b"] = true
+    hash["c"] = false
+    hash["d"] = nil
+
+    hash[:a].should == 1
+    hash[:b].should == true
+    hash[:c].should == false
+    hash[:d].should == nil
+    hash[:e].should == 1
+  end
+
+  it 'indifferent_writing' do
+    hash = Gorillib::HashWithIndifferentAccess.new
+    hash[:a] = 1
+    hash['b'] = 2
+    hash[3] = 3
+
+    1.should == hash['a']
+    2.should == hash['b']
+    1.should == hash[:a]
+    2.should == hash[:b]
+    3.should == hash[3]
+  end
+
+  it 'indifferent_update' do
+    hash = Gorillib::HashWithIndifferentAccess.new
+    hash[:a] = 'a'
+    hash['b'] = 'b'
+
+    updated_with_strings = hash.update(@strings)
+    updated_with_symbols = hash.update(@symbols)
+    updated_with_mixed = hash.update(@mixed)
+
+    1.should == updated_with_strings[:a]
+    1.should == updated_with_strings['a']
+    2.should == updated_with_strings['b']
+
+    1.should == updated_with_symbols[:a]
+    2.should == updated_with_symbols['b']
+    2.should == updated_with_symbols[:b]
+
+    1.should == updated_with_mixed[:a]
+    2.should == updated_with_mixed['b']
+
+    [updated_with_strings, updated_with_symbols, updated_with_mixed].all?{ |h| h.keys.size == 2 }.should be_true
+  end
+
+  it 'indifferent_merging' do
+    hash = Gorillib::HashWithIndifferentAccess.new
+    hash[:a] = 'failure'
+    hash['b'] = 'failure'
+
+    other = { 'a' => 1, :b => 2 }
+
+    merged = hash.merge(other)
+
+    merged.class.should == Gorillib::HashWithIndifferentAccess
+    merged[:a].should == 1
+    merged['b'].should == 2
+
+    hash.update(other)
+
+    hash[:a].should == 1
+    hash['b'].should == 2
+  end
+
+  it 'indifferent_reverse_merging' do
+    hash = Gorillib::HashWithIndifferentAccess.new('some' => 'value', 'other' => 'value')
+    hash.reverse_merge!(:some => 'noclobber', :another => 'clobber')
+    hash[:some].should == 'value'
+    hash[:another].should == 'clobber'
+  end
+
+  it 'indifferent_deleting' do
+    get_hash = proc{ { :a => 'foo' }.with_indifferent_access }
+    hash = get_hash.call
+    'foo'.should == hash.delete(:a)
+    nil.should == hash.delete(:a)
+    hash = get_hash.call
+    'foo'.should == hash.delete('a')
+    nil.should == hash.delete('a')
+  end
+
+  it 'indifferent_to_hash' do
+    # Should convert to a Hash with String keys.
+    @mixed.with_indifferent_access.to_hash.should == @strings
+
+    # Should preserve the default value.
+    mixed_with_default = @mixed.dup
+    mixed_with_default.default = '1234'
+    roundtrip = mixed_with_default.with_indifferent_access.to_hash
+    roundtrip.should == @strings
+    roundtrip.default.should == '1234'
+  end
+
+  it 'indifferent_hash_with_array_of_hashes' do
+    hash = { "urls" => { "url" => [ { "address" => "1" }, { "address" => "2" } ] }}.with_indifferent_access
+    hash[:urls][:url].first[:address].should == "1"
+  end
+
+  it 'should_preserve_array_subclass_when_value_is_array' do
+    array = SubclassingArray.new
+    array << { "address" => "1" }
+    hash = { "urls" => { "url" => array }}.with_indifferent_access
+    hash[:urls][:url].class.should == SubclassingArray
+  end
+
+  it 'should_preserve_array_class_when_hash_value_is_frozen_array' do
+    array = SubclassingArray.new
+    array << { "address" => "1" }
+    hash = { "urls" => { "url" => array.freeze }}.with_indifferent_access
+    hash[:urls][:url].class.should == SubclassingArray
+  end
+
+  it 'stringify_and_symbolize_keys_on_indifferent_preserves_hash' do
+    h = Gorillib::HashWithIndifferentAccess.new
+    h[:first] = 1
+    h = h.stringify_keys
+    h['first'].should == 1
+    h = Gorillib::HashWithIndifferentAccess.new
+    h['first'] = 1
+    h = h.symbolize_keys
+    h[:first].should == 1
+  end
+
+  it 'to_options_on_indifferent_preserves_hash' do
+    h = Gorillib::HashWithIndifferentAccess.new
+    h['first'] = 1
+    h.to_options!
+    h['first'].should == 1
+  end
+
+  it 'indifferent_subhashes' do
+    h = {'user' => {'id' => 5}}.with_indifferent_access
+    ['user', :user].each{|user| [:id, 'id'].each{|id| h[user][id].should == 5 }}
+
+    h = {:user => {:id => 5}}.with_indifferent_access
+    ['user', :user].each{|user| [:id, 'id'].each{|id| h[user][id].should == 5 }}
+  end
+
+  it 'indifferent_duplication' do
+    # Should preserve default value
+    h = Gorillib::HashWithIndifferentAccess.new
+    h.default = '1234'
+    h.dup.default.should == h.default
+
+    # Should preserve class for subclasses
+    h = IndifferentHash.new
+    h.dup.class.should == h.class
+  end
+
+  it 'assorted_keys_not_stringified' do
+    original = {Object.new => 2, 1 => 2, [] => true}
+    indiff = original.with_indifferent_access
+    indiff.keys.any?{|k| k.kind_of? String }.should_not be_true
+  end
+
+  it 'deep_merge' do
+    hash_1 = { :a => "a", :b => "b", :c => { :c1 => "c1", :c2 => "c2", :c3 => { :d1 => "d1" } } }
+    hash_2 = { :a => 1, :c => { :c1 => 2, :c3 => { :d2 => "d2" } } }
+    expected = { :a => 1, :b => "b", :c => { :c1 => 2, :c2 => "c2", :c3 => { :d1 => "d1", :d2 => "d2" } } }
+    hash_1.deep_merge(hash_2).should == expected
+
+    hash_1.deep_merge!(hash_2)
+    hash_1.should == expected
+  end
+
+  it 'deep_merge_on_indifferent_access' do
+    hash_1 = Gorillib::HashWithIndifferentAccess.new({ :a => "a", :b => "b", :c => { :c1 => "c1", :c2 => "c2", :c3 => { :d1 => "d1" } } })
+    hash_2 = Gorillib::HashWithIndifferentAccess.new({ :a => 1, :c => { :c1 => 2, :c3 => { :d2 => "d2" } } })
+    hash_3 = { :a => 1, :c => { :c1 => 2, :c3 => { :d2 => "d2" } } }
+    expected = { "a" => 1, "b" => "b", "c" => { "c1" => 2, "c2" => "c2", "c3" => { "d1" => "d1", "d2" => "d2" } } }
+    hash_1.deep_merge(hash_2).should == expected
+    hash_1.deep_merge(hash_3).should == expected
+
+    hash_1.deep_merge!(hash_2)
+    hash_1.should == expected
+  end
+
+  it 'deep_dup' do
+    hash = { :a => { :b => 'b' } }
+    dup = hash.deep_dup
+    dup[:a][:c] = 'c'
+    hash[:a][:c].should == nil
+    dup[:a][:c].should == 'c'
+  end
+
+  it 'deep_dup_initialize' do
+    zero_hash = Hash.new 0
+    hash = { :a => zero_hash }
+    dup = hash.deep_dup
+    dup[:a][44].should == 0
+  end
+
+  it 'store_on_indifferent_access' do
+    hash = Gorillib::HashWithIndifferentAccess.new
+    hash.store(:test1, 1)
+    hash.store('test1', 11)
+    hash[:test2] = 2
+    hash['test2'] = 22
+    expected = { "test1" => 11, "test2" => 22 }
+    hash.should == expected
+  end
+
+  it 'indifferent_slice' do
+    original = { :a => 'x', :b => 'y', :c => 10 }.with_indifferent_access
+    expected = { :a => 'x', :b => 'y' }.with_indifferent_access
+
+    [['a', 'b'], [:a, :b]].each do |keys|
+      # Should return a new hash with only the given keys.
+      original.slice(*keys).should == expected
+      original.should_not == expected
+    end
+  end
+
+  it 'indifferent_slice_inplace' do
+    original = { :a => 'x', :b => 'y', :c => 10 }.with_indifferent_access
+    expected = { :c => 10 }.with_indifferent_access
+
+    [['a', 'b'], [:a, :b]].each do |keys|
+      # Should replace the hash with only the given keys.
+      copy = original.dup
+      copy.slice!(*keys).should == expected
+    end
+  end
+
+  it 'indifferent_slice_access_with_symbols' do
+    original = {'login' => 'bender', 'password' => 'shiny', 'stuff' => 'foo'}
+    original = original.with_indifferent_access
+
+    slice = original.slice(:login, :password)
+
+    slice[:login].should == 'bender'
+    slice['login'].should == 'bender'
+  end
+
+  it 'should_use_default_value_for_unknown_key' do
+    hash_wia = Gorillib::HashWithIndifferentAccess.new(3)
+    hash_wia[:new_key].should == 3
+  end
+
+  it 'should_use_default_value_if_no_key_is_supplied' do
+    hash_wia = Gorillib::HashWithIndifferentAccess.new(3)
+    hash_wia.default.should == 3
+  end
+
+  it 'should_nil_if_no_default_value_is_supplied' do
+    hash_wia = Gorillib::HashWithIndifferentAccess.new
+    hash_wia.default.should be_nil
+  end
+
+  it 'should_return_dup_for_with_indifferent_access' do
+    hash_wia = Gorillib::HashWithIndifferentAccess.new
+    hash_wia.with_indifferent_access.should == hash_wia
+    hash_wia.with_indifferent_access.should_not equal(hash_wia)
+  end
+
+  it 'should_copy_the_default_value_when_converting_to_hash_with_indifferent_access' do
+    hash = Hash.new(3)
+    hash_wia = hash.with_indifferent_access
+    hash_wia.default.should == 3
+  end
+
+end

data/spec/hash/slice_spec.rb

@@ -1,6 +1,8 @@
 require File.dirname(__FILE__)+'/../spec_helper'
 require 'gorillib/hash/slice'
 
+class HashSubclass < Hash ; end
+
 describe Hash do
   describe '#slice' do
     it 'should return a new hash with only the given keys' do
@@ -8,14 +10,7 @@ describe Hash do
       expected = { :a => 'x', :b => 'y' }
 
       original.slice(:a, :b).should == expected
-      original.should_not == expected
-    end
-
-    it 'Should replace the hash with only the given keys' do
-      original = { :a => 'x', :b => 'y', :c => 10 }
-      expected = { :c => 10 }
-
-      original.slice!(:a, :b).should == expected
+      original.should == { :a => 'x', :b => 'y', :c => 10 }
     end
 
     it 'should return a new hash with only the given keys when given an array key' do
@@ -26,18 +21,46 @@ describe Hash do
       original.should_not == expected
     end
 
+    it 'Should grab each of the splatted keys' do
+      original = { :a => 'x', :b => 'y', :c => 10, [:a, :b] => "an array key" }
+      expected = { :a => 'x', :b => "y" }
+
+      original.slice(*[:a, :b]).should == expected
+    end
+
+    it 'should have the same type as the original' do
+      hsh = HashSubclass.new.merge({ :a => 'x', :b => 'y', :c => 10 })
+      hsh.slice(:a, :b).should be_a(HashSubclass)
+    end
+  end
+
+  describe '#slice!' do
+    it 'Should replace the hash with only the given keys' do
+      original  = { :a => 'x', :b => 'y', :c => 10 }
+      expected  = { :c => 10 }
+      remaining = { :a => 'x', :b => 'y' }
+
+      original.slice!(:a, :b).should == expected
+      original.should == remaining
+    end
+
     it 'should replace the hash with only the given keys when given an array key' do
       original = { :a => 'x', :b => 'y', :c => 10, [:a, :b] => "an array key" }
       expected = { :a => 'x', :b => 'y' }
 
       original.slice!([:a, :b], :c).should == expected
     end
+  end
 
-    it 'Should grab each of the splatted keys' do
-      original = { :a => 'x', :b => 'y', :c => 10, [:a, :b] => "an array key" }
-      expected = { :a => 'x', :b => "y" }
+  describe '#extract!' do
+    it 'Should replace the hash with only the omitted keys' do
+      original  = { :a => 'x', :b => 'y', :c => 10 }
+      expected  = { :a => 'x', :b => 'y' }
+      remaining = { :c => 10 }
 
-      original.slice(*[:a, :b]).should == expected
+      original.extract!(:a, :b).should == expected
+      original.should == remaining
     end
   end
+
 end