gorillib 0.0.7 → 0.0.8

data/test/array/extract_options_test.rb

@@ -1,39 +0,0 @@
-require File.dirname(__FILE__)+'/../abstract_unit'
-require 'gorillib/array/extract_options'
-
-class ArrayExtractOptionsTests < Test::Unit::TestCase
-  class HashSubclass < Hash
-  end
-
-  class ExtractableHashSubclass < Hash
-    def extractable_options?
-      true
-    end
-  end
-
-  def test_extract_options
-    assert_equal({}, [].extract_options!)
-    assert_equal({}, [1].extract_options!)
-    assert_equal({:a=>:b}, [{:a=>:b}].extract_options!)
-    assert_equal({:a=>:b}, [1, {:a=>:b}].extract_options!)
-  end
-
-  def test_extract_options_doesnt_extract_hash_subclasses
-    hash = HashSubclass.new
-    hash[:foo] = 1
-    array = [hash]
-    options = array.extract_options!
-    assert_equal({}, options)
-    assert_equal [hash], array
-  end
-
-  def test_extract_options_extracts_extractable_subclass
-    hash = ExtractableHashSubclass.new
-    hash[:foo] = 1
-    array = [hash]
-    options = array.extract_options!
-    assert_equal({:foo => 1}, options)
-    assert_equal [], array
-  end
-
-end

data/test/enumerable/sum_test.rb

@@ -1,50 +0,0 @@
-require File.dirname(__FILE__)+'/../abstract_unit'
-require 'gorillib/enumerable/sum'
-
-Payment = Struct.new(:price)
-class SummablePayment < Payment
-  def +(p) self.class.new(price + p.price) end
-end
-
-class EnumerableTests < Test::Unit::TestCase
-  def test_sums
-    assert_equal 30, [5, 15, 10].sum
-    assert_equal 30, [5, 15, 10].sum { |i| i }
-
-    assert_equal 'abc', %w(a b c).sum
-    assert_equal 'abc', %w(a b c).sum { |i| i }
-
-    payments = [ Payment.new(5), Payment.new(15), Payment.new(10) ]
-    assert_equal 30, payments.sum(&:price)
-    assert_equal 60, payments.sum { |p| p.price * 2 }
-
-    payments = [ SummablePayment.new(5), SummablePayment.new(15) ]
-    assert_equal SummablePayment.new(20), payments.sum
-    assert_equal SummablePayment.new(20), payments.sum { |p| p }
-  end
-
-  def test_nil_sums
-    expected_raise = TypeError
-
-    assert_raise(expected_raise) { [5, 15, nil].sum }
-
-    payments = [ Payment.new(5), Payment.new(15), Payment.new(10), Payment.new(nil) ]
-    assert_raise(expected_raise) { payments.sum(&:price) }
-
-    assert_equal 60, payments.sum { |p| p.price.to_i * 2 }
-  end
-
-  def test_empty_sums
-    assert_equal 0, [].sum
-    assert_equal 0, [].sum { |i| i }
-    assert_equal Payment.new(0), [].sum(Payment.new(0))
-  end
-
-  def test_enumerable_sums
-    assert_equal 20, (1..4).sum { |i| i * 2 }
-    assert_equal 10, (1..4).sum
-    assert_equal 10, (1..4.5).sum
-    assert_equal 6, (1...4).sum
-    assert_equal 'abc', ('a'..'c').sum
-  end
-end

data/test/hash/compact_test.rb

@@ -1,38 +0,0 @@
-require File.dirname(__FILE__)+'/../abstract_unit'
-require 'gorillib/hash/compact'
-
-class HashCompactTests < Test::Unit::TestCase
-
-  def test_compact_blank_with_empty
-    [ { 1 => nil}, { 1 => nil, 2 => false, 3 => {}, 4 => ""} ].each do |hsh|
-      assert_equal({}, hsh.compact_blank)
-      assert_not_equal(0,  hsh.length)
-    end
-  end
-
-  def test_compact_blank_with_empty
-    [ { 1 => nil}, { 1 => nil, 2 => false, 3 => {}, 4 => ""} ].each do |hsh|
-      assert_equal({}, hsh.compact_blank!)
-      assert_equal(0,  hsh.length)
-    end
-  end
-
-  def test_compact_blank_with_full
-    assert_equal(
-      { nil => 2 },
-      { 1 => nil, nil => 2 }.compact_blank  )
-    assert_equal(
-      { 2 => :val_2, 4 => :val_4 },
-      { 1 => nil, 2 => :val_2, 3 => {}, 4 => :val_4}.compact_blank  )
-  end
-
-  def test_compact_blank_bang_with_full
-    assert_equal(
-      { nil => 2 },
-      { 1 => nil, nil => 2 }.compact_blank!  )
-    assert_equal(
-      { 2 => :val_2, 4 => :val_4 },
-      { 1 => nil, 2 => :val_2, 3 => {}, 4 => :val_4}.compact_blank!  )
-  end
-
-end

data/test/hash/deep_merge_test.rb

@@ -1,30 +0,0 @@
-require File.dirname(__FILE__)+'/../abstract_unit'
-require 'gorillib/hash/deep_merge'
-
-class HashDeepMergeTest < Test::Unit::TestCase
-
-  def test_deep_merge
-    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" } } }
-    assert_equal expected, hash_1.deep_merge(hash_2)
-
-    hash_1.deep_merge!(hash_2)
-    assert_equal expected, hash_1
-  end
-
-  # def test_deep_dup
-  #   hash = { :a => { :b => 'b' } }
-  #   dup = hash.deep_dup
-  #   dup[:a][:c] = 'c'
-  #   assert_equal nil, hash[:a][:c]
-  #   assert_equal 'c', dup[:a][:c]
-  # end
-  #
-  # def test_deep_dup_initialize
-  #   zero_hash = Hash.new 0
-  #   hash = { :a => zero_hash }
-  #   dup = hash.deep_dup
-  #   assert_equal 0, dup[:a][44]
-  # end
-end

data/test/hash/keys_test.rb

@@ -1,110 +0,0 @@
-require File.dirname(__FILE__)+'/../abstract_unit'
-require 'gorillib/hash/keys'
-
-class HashSymbolizeKeysTest < Test::Unit::TestCase
-
-  class IndifferentHash < HashWithIndifferentAccess
-  end
-
-  class SubclassingArray < Array
-  end
-
-  class SubclassingHash < Hash
-  end
-
-
-  def setup
-    @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
-
-  def test_methods
-    h = {}
-    assert_respond_to h, :symbolize_keys
-    assert_respond_to h, :symbolize_keys!
-    assert_respond_to h, :stringify_keys
-    assert_respond_to h, :stringify_keys!
-  end
-
-  def test_symbolize_keys
-    assert_equal @symbols, @symbols.symbolize_keys
-    assert_equal @symbols, @strings.symbolize_keys
-    assert_equal @symbols, @mixed.symbolize_keys
-  end
-
-  def test_symbolize_keys!
-    assert_equal @symbols, @symbols.dup.symbolize_keys!
-    assert_equal @symbols, @strings.dup.symbolize_keys!
-    assert_equal @symbols, @mixed.dup.symbolize_keys!
-  end
-
-  def test_symbolize_keys_preserves_keys_that_cant_be_symbolized
-    assert_equal @illegal_symbols, @illegal_symbols.symbolize_keys
-    assert_equal @illegal_symbols, @illegal_symbols.dup.symbolize_keys!
-  end
-
-  def test_symbolize_keys_preserves_fixnum_keys
-    assert_equal @fixnums, @fixnums.symbolize_keys
-    assert_equal @fixnums, @fixnums.dup.symbolize_keys!
-  end
-
-  def test_stringify_keys
-    assert_equal @strings, @symbols.stringify_keys
-    assert_equal @strings, @strings.stringify_keys
-    assert_equal @strings, @mixed.stringify_keys
-  end
-
-  def test_stringify_keys!
-    assert_equal @strings, @symbols.dup.stringify_keys!
-    assert_equal @strings, @strings.dup.stringify_keys!
-    assert_equal @strings, @mixed.dup.stringify_keys!
-  end
-
-  def test_symbolize_keys_for_hash_with_indifferent_access
-    assert_instance_of Hash, @symbols.with_indifferent_access.symbolize_keys
-    assert_equal @symbols, @symbols.with_indifferent_access.symbolize_keys
-    assert_equal @symbols, @strings.with_indifferent_access.symbolize_keys
-    assert_equal @symbols, @mixed.with_indifferent_access.symbolize_keys
-  end
-
-  def test_symbolize_keys_bang_for_hash_with_indifferent_access
-    assert_raise(NoMethodError) { @symbols.with_indifferent_access.dup.symbolize_keys! }
-    assert_raise(NoMethodError) { @strings.with_indifferent_access.dup.symbolize_keys! }
-    assert_raise(NoMethodError) { @mixed.with_indifferent_access.dup.symbolize_keys! }
-  end
-
-  def test_symbolize_keys_preserves_keys_that_cant_be_symbolized_for_hash_with_indifferent_access
-    assert_equal @illegal_symbols, @illegal_symbols.with_indifferent_access.symbolize_keys
-    assert_raise(NoMethodError) { @illegal_symbols.with_indifferent_access.dup.symbolize_keys! }
-  end
-
-  def test_symbolize_keys_preserves_fixnum_keys_for_hash_with_indifferent_access
-    assert_equal @fixnums, @fixnums.with_indifferent_access.symbolize_keys
-    assert_raise(NoMethodError) { @fixnums.with_indifferent_access.dup.symbolize_keys! }
-  end
-
-  def test_hash_subclass
-    flash = { "foo" => SubclassingHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
-    assert_kind_of SubclassingHash, flash["foo"]
-  end
-
-  def test_assert_valid_keys
-    assert_nothing_raised do
-      { :failure => "stuff", :funny => "business" }.assert_valid_keys([ :failure, :funny ])
-      { :failure => "stuff", :funny => "business" }.assert_valid_keys(:failure, :funny)
-    end
-
-    assert_raise(ArgumentError, "Unknown key: failore") do
-      { :failore => "stuff", :funny => "business" }.assert_valid_keys([ :failure, :funny ])
-      { :failore => "stuff", :funny => "business" }.assert_valid_keys(:failure, :funny)
-    end
-  end
-
-end

data/test/hash/reverse_merge_test.rb

@@ -1,20 +0,0 @@
-require File.dirname(__FILE__)+'/../abstract_unit'
-require 'gorillib/hash/reverse_merge'
-
-class HashReverseMergeTest < Test::Unit::TestCase
-
-  def test_reverse_merge
-    defaults = { :a => "x", :b => "y", :c => 10 }.freeze
-    options  = { :a => 1, :b => 2 }
-    expected = { :a => 1, :b => 2, :c => 10 }
-
-    # Should merge defaults into options, creating a new hash.
-    assert_equal expected, options.reverse_merge(defaults)
-    assert_not_equal expected, options
-
-    # Should merge! defaults into options, replacing options.
-    merged = options.dup
-    assert_equal expected, merged.reverse_merge!(defaults)
-    assert_equal expected, merged
-  end
-end

data/test/hash/slice_test.rb

@@ -1,47 +0,0 @@
-require File.dirname(__FILE__)+'/../abstract_unit'
-require 'gorillib/hash/slice'
-
-class HashSliceTest < Test::Unit::TestCase
-
-  def test_slice
-    original = { :a => 'x', :b => 'y', :c => 10 }
-    expected = { :a => 'x', :b => 'y' }
-
-    # Should return a new hash with only the given keys.
-    assert_equal expected, original.slice(:a, :b)
-    assert_not_equal expected, original
-  end
-
-  def test_slice_inplace
-    original = { :a => 'x', :b => 'y', :c => 10 }
-    expected = { :c => 10 }
-
-    # Should replace the hash with only the given keys.
-    assert_equal expected, original.slice!(:a, :b)
-  end
-
-  def test_slice_with_an_array_key
-    original = { :a => 'x', :b => 'y', :c => 10, [:a, :b] => "an array key" }
-    expected = { [:a, :b] => "an array key", :c => 10 }
-
-    # Should return a new hash with only the given keys when given an array key.
-    assert_equal expected, original.slice([:a, :b], :c)
-    assert_not_equal expected, original
-  end
-
-  def test_slice_inplace_with_an_array_key
-    original = { :a => 'x', :b => 'y', :c => 10, [:a, :b] => "an array key" }
-    expected = { :a => 'x', :b => 'y' }
-
-    # Should replace the hash with only the given keys when given an array key.
-    assert_equal expected, original.slice!([:a, :b], :c)
-  end
-
-  def test_slice_with_splatted_keys
-    original = { :a => 'x', :b => 'y', :c => 10, [:a, :b] => "an array key" }
-    expected = { :a => 'x', :b => "y" }
-
-    # Should grab each of the splatted keys.
-    assert_equal expected, original.slice(*[:a, :b])
-  end
-end

data/test/metaprogramming/aliasing_test.rb

@@ -1,188 +0,0 @@
-require File.dirname(__FILE__)+'/../abstract_unit'
-require 'gorillib/aliasing'
-
-module BarMethodAliaser
-  def self.included(foo_class)
-    foo_class.class_eval do
-      include BarMethods
-      alias_method_chain :bar, :baz
-    end
-  end
-end
-
-module BarMethods
-  def bar_with_baz
-    bar_without_baz << '_with_baz'
-  end
-
-  def quux_with_baz!
-    quux_without_baz! << '_with_baz'
-  end
-
-  def quux_with_baz?
-    false
-  end
-
-  def quux_with_baz=(v)
-    send(:quux_without_baz=, v) << '_with_baz'
-  end
-
-  def duck_with_orange
-    duck_without_orange << '_with_orange'
-  end
-end
-
-class MethodAliasingTest < Test::Unit::TestCase
-  def setup
-    Object.const_set :FooClassWithBarMethod, Class.new { def bar() 'bar' end }
-    @instance = FooClassWithBarMethod.new
-  end
-
-  def teardown
-    Object.instance_eval { remove_const :FooClassWithBarMethod }
-  end
-
-  def test_alias_method_chain
-    assert @instance.respond_to?(:bar)
-    feature_aliases = [:bar_with_baz, :bar_without_baz]
-
-    feature_aliases.each do |method|
-      assert !@instance.respond_to?(method)
-    end
-
-    assert_equal 'bar', @instance.bar
-
-    FooClassWithBarMethod.class_eval { include BarMethodAliaser }
-
-    feature_aliases.each do |method|
-      assert_respond_to @instance, method
-    end
-
-    assert_equal 'bar_with_baz', @instance.bar
-    assert_equal 'bar', @instance.bar_without_baz
-  end
-
-  def test_alias_method_chain_with_punctuation_method
-    FooClassWithBarMethod.class_eval do
-      def quux!; 'quux' end
-    end
-
-    assert !@instance.respond_to?(:quux_with_baz!)
-    FooClassWithBarMethod.class_eval do
-      include BarMethodAliaser
-      alias_method_chain :quux!, :baz
-    end
-    assert_respond_to @instance, :quux_with_baz!
-
-    assert_equal 'quux_with_baz', @instance.quux!
-    assert_equal 'quux', @instance.quux_without_baz!
-  end
-
-  def test_alias_method_chain_with_same_names_between_predicates_and_bang_methods
-    FooClassWithBarMethod.class_eval do
-      def quux!; 'quux!' end
-      def quux?; true end
-      def quux=(v); 'quux=' end
-    end
-
-    assert !@instance.respond_to?(:quux_with_baz!)
-    assert !@instance.respond_to?(:quux_with_baz?)
-    assert !@instance.respond_to?(:quux_with_baz=)
-
-    FooClassWithBarMethod.class_eval { include BarMethodAliaser }
-    assert_respond_to @instance, :quux_with_baz!
-    assert_respond_to @instance, :quux_with_baz?
-    assert_respond_to @instance, :quux_with_baz=
-
-
-    FooClassWithBarMethod.alias_method_chain :quux!, :baz
-    assert_equal 'quux!_with_baz', @instance.quux!
-    assert_equal 'quux!', @instance.quux_without_baz!
-
-    FooClassWithBarMethod.alias_method_chain :quux?, :baz
-    assert_equal false, @instance.quux?
-    assert_equal true,  @instance.quux_without_baz?
-
-    FooClassWithBarMethod.alias_method_chain :quux=, :baz
-    assert_equal 'quux=_with_baz', @instance.send(:quux=, 1234)
-    assert_equal 'quux=', @instance.send(:quux_without_baz=, 1234)
-  end
-
-  def test_alias_method_chain_with_feature_punctuation
-    FooClassWithBarMethod.class_eval do
-      def quux; 'quux' end
-      def quux?; 'quux?' end
-      include BarMethodAliaser
-      alias_method_chain :quux, :baz!
-    end
-
-    assert_nothing_raised do
-      assert_equal 'quux_with_baz', @instance.quux_with_baz!
-    end
-
-    assert_raise(NameError) do
-      FooClassWithBarMethod.alias_method_chain :quux?, :baz!
-    end
-  end
-
-  def test_alias_method_chain_yields_target_and_punctuation
-    args = nil
-
-    FooClassWithBarMethod.class_eval do
-      def quux?; end
-      include BarMethods
-
-      FooClassWithBarMethod.alias_method_chain :quux?, :baz do |target, punctuation|
-        args = [target, punctuation]
-      end
-    end
-
-    assert_not_nil args
-    assert_equal 'quux', args[0]
-    assert_equal '?', args[1]
-  end
-
-  def test_alias_method_chain_preserves_private_method_status
-    FooClassWithBarMethod.class_eval do
-      def duck; 'duck' end
-      include BarMethodAliaser
-      private :duck
-      alias_method_chain :duck, :orange
-    end
-
-    assert_raise NoMethodError do
-      @instance.duck
-    end
-
-    assert_equal 'duck_with_orange', @instance.instance_eval { duck }
-    assert FooClassWithBarMethod.private_method_defined?(:duck)
-  end
-
-  def test_alias_method_chain_preserves_protected_method_status
-    FooClassWithBarMethod.class_eval do
-      def duck; 'duck' end
-      include BarMethodAliaser
-      protected :duck
-      alias_method_chain :duck, :orange
-    end
-
-    assert_raise NoMethodError do
-      @instance.duck
-    end
-
-    assert_equal 'duck_with_orange', @instance.instance_eval { duck }
-    assert FooClassWithBarMethod.protected_method_defined?(:duck)
-  end
-
-  def test_alias_method_chain_preserves_public_method_status
-    FooClassWithBarMethod.class_eval do
-      def duck; 'duck' end
-      include BarMethodAliaser
-      public :duck
-      alias_method_chain :duck, :orange
-    end
-
-    assert_equal 'duck_with_orange', @instance.duck
-    assert FooClassWithBarMethod.public_method_defined?(:duck)
-  end
-end

data/test/metaprogramming/cattr_accessor_test.rb

@@ -1,38 +0,0 @@
-require File.dirname(__FILE__)+'/../abstract_unit'
-require 'gorillib/metaprogramming/cattr_accessor'
-
-class ClassAttributeAccessorTest < Test::Unit::TestCase
-  def setup
-    @class = Class.new do
-      cattr_accessor :foo
-      cattr_accessor :bar,  :instance_writer => false
-      cattr_reader   :shaq, :instance_reader => false
-    end
-    @object = @class.new
-  end
-
-  def test_should_use_mattr_default
-    assert_nil @class.foo
-    assert_nil @object.foo
-  end
-
-  def test_should_set_mattr_value
-    @class.foo = :test
-    assert_equal :test, @object.foo
-
-    @object.foo = :test2
-    assert_equal :test2, @class.foo
-  end
-
-  def test_should_not_create_instance_writer
-    assert_respond_to @class, :foo
-    assert_respond_to @class, :foo=
-    assert_respond_to @object, :bar
-    assert !@object.respond_to?(:bar=)
-  end
-
-  def test_should_not_create_instance_reader
-    assert_respond_to @class, :shaq
-    assert !@object.respond_to?(:shaq)
-  end
-end

data/test/metaprogramming/class_attribute_test.rb

@@ -1,73 +0,0 @@
-require File.dirname(__FILE__)+'/../abstract_unit'
-require 'gorillib/metaprogramming/class_attribute'
-
-class ClassAttributeTest < ActiveSupport::TestCase
-  def setup
-    @klass = Class.new { class_attribute :setting }
-    @sub = Class.new(@klass)
-  end
-
-  test 'defaults to nil' do
-    assert_nil @klass.setting
-    assert_nil @sub.setting
-  end
-
-  test 'inheritable' do
-    @klass.setting = 1
-    assert_equal 1, @sub.setting
-  end
-
-  test 'overridable' do
-    @sub.setting = 1
-    assert_nil @klass.setting
-
-    @klass.setting = 2
-    assert_equal 1, @sub.setting
-
-    assert_equal 1, Class.new(@sub).setting
-  end
-
-  test 'query method' do
-    assert_equal false, @klass.setting?
-    @klass.setting = 1
-    assert_equal true, @klass.setting?
-  end
-
-  test 'instance reader delegates to class' do
-    assert_nil @klass.new.setting
-
-    @klass.setting = 1
-    assert_equal 1, @klass.new.setting
-  end
-
-  test 'instance override' do
-    object = @klass.new
-    object.setting = 1
-    assert_nil @klass.setting
-    @klass.setting = 2
-    assert_equal 1, object.setting
-  end
-
-  test 'instance query' do
-    object = @klass.new
-    assert_equal false, object.setting?
-    object.setting = 1
-    assert_equal true, object.setting?
-  end
-
-  test 'disabling instance writer' do
-    object = Class.new { class_attribute :setting, :instance_writer => false }.new
-    assert_raise(NoMethodError) { object.setting = 'boom' }
-  end
-
-  test 'works well with singleton classes' do
-    object = @klass.new
-    object.singleton_class.setting = 'foo'
-    assert_equal 'foo', object.setting
-  end
-
-  test 'setter returns set value' do
-    val = @klass.send(:setting=, 1)
-    assert_equal 1, val
-  end
-end