gorillib 0.1.11 → 0.4.0pre

data/spec/hash/indifferent_access_spec.rb

@@ -1,391 +0,0 @@
-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/metaprogramming/cattr_accessor_spec.rb

@@ -1,43 +0,0 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
-require 'gorillib/metaprogramming/cattr_accessor'
-
-describe 'metaprogramming' do
-  describe 'cattr_accessor' do
-    before do
-      @class = Class.new do
-        cattr_accessor :foo
-        cattr_accessor :bar,  :instance_writer => false
-        cattr_reader   :shaq, :instance_reader => false
-      end
-      @object = @class.new
-    end
-
-    it 'does not have an effect if already provided by another library.'
-
-    it 'uses mattr default' do
-      @class.foo.should be_nil
-      @object.foo.should be_nil
-    end
-
-    it 'sets mattr value' do
-      @class.foo = :test
-      @object.foo.should == :test
-
-      @object.foo = :test2
-      @class.foo.should == :test2
-    end
-
-    it 'with instance_writer => false, does not create an instance writer' do
-      @class.should respond_to(:foo)
-      @class.should respond_to(:foo=)
-      @object.should respond_to(:bar)
-      @object.should_not respond_to(:bar=)
-    end
-
-    it 'with instance_reader => false, does not create an instance reader' do
-      @class.should respond_to(:shaq)
-      @object.should_not respond_to(:shaq)
-      @object.should_not respond_to(:shaq=)
-    end
-  end
-end

data/spec/metaprogramming/mattr_accessor_spec.rb

@@ -1,45 +0,0 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
-require 'gorillib/metaprogramming/mattr_accessor'
-
-describe Module do
-  describe 'mattr_accessor' do
-    before do
-      m = @module = Module.new do
-        mattr_accessor :foo
-        mattr_accessor :bar, :instance_writer => false
-        mattr_reader   :shaq, :instance_reader => false
-      end
-      @class = Class.new
-      @class.instance_eval { include m }
-      @object = @class.new
-    end
-
-    it 'does not have an effect if already provided by another library.'
-
-    it 'uses mattr default' do
-      @module.foo.should be_nil
-      @object.foo.should be_nil
-    end
-
-    it 'sets mattr value' do
-      @module.foo = :test
-      @object.foo.should == :test
-
-      @object.foo = :test2
-      @module.foo.should == :test2
-    end
-
-    it 'with :instance_writer => false, does not create instance writer' do
-      @module.should respond_to(:foo)
-      @module.should respond_to(:foo=)
-      @object.should respond_to(:bar)
-      @object.should_not respond_to(:bar=)
-    end
-
-    it 'with :instance_writer => false, does not create instance reader' do
-      @module.should respond_to(:shaq)
-      @object.should_not respond_to(:shaq)
-      @object.should_not respond_to(:shaq=)
-    end
-  end
-end