gorillib 0.0.2

data/test/hash/keys_test.rb

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,188 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,73 @@
+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

data/test/metaprogramming/delegation_test.rb

@@ -0,0 +1,166 @@
+require File.dirname(__FILE__)+'/../abstract_unit'
+require 'gorillib/delegation'
+
+module One
+  Constant1 = "Hello World"
+  Constant2 = "What\'s up?"
+end
+
+class Ab
+  include One
+  Constant1 = "Hello World" # Will have different object id than One::Constant1
+  Constant3 = "Goodbye World"
+end
+
+module Xy
+  class Bc
+    include One
+  end
+end
+
+module Yz
+  module Zy
+    class Cd
+      include One
+    end
+  end
+end
+
+Somewhere = Struct.new(:street, :city)
+
+Someone   = Struct.new(:name, :place) do
+  delegate :street, :city, :to_f, :to => :place
+  delegate :upcase, :to => "place.city"
+end
+
+Invoice   = Struct.new(:client) do
+  delegate :street, :city, :name, :to => :client, :prefix => true
+  delegate :street, :city, :name, :to => :client, :prefix => :customer
+end
+
+Project   = Struct.new(:description, :person) do
+  delegate :name, :to => :person, :allow_nil => true
+  delegate :to_f, :to => :description, :allow_nil => true
+end
+
+Developer = Struct.new(:client) do
+  delegate :name, :to => :client, :prefix => nil
+end
+
+Tester = Struct.new(:client) do
+  delegate :name, :to => :client, :prefix => false
+end
+
+class Name
+  delegate :upcase, :to => :@full_name
+
+  def initialize(first, last)
+    @full_name = "#{first} #{last}"
+  end
+end
+
+class ModuleTest < Test::Unit::TestCase
+  def setup
+    @david = Someone.new("David", Somewhere.new("Paulina", "Chicago"))
+  end
+
+  def test_delegation_to_methods
+    assert_equal "Paulina", @david.street
+    assert_equal "Chicago", @david.city
+  end
+
+  def test_delegation_down_hierarchy
+    assert_equal "CHICAGO", @david.upcase
+  end
+
+  def test_delegation_to_instance_variable
+    david = Name.new("David", "Hansson")
+    assert_equal "DAVID HANSSON", david.upcase
+  end
+
+  def test_missing_delegation_target
+    assert_raise(ArgumentError) do
+      Name.send :delegate, :nowhere
+    end
+    assert_raise(ArgumentError) do
+      Name.send :delegate, :noplace, :tos => :hollywood
+    end
+  end
+
+  def test_delegation_prefix
+    invoice = Invoice.new(@david)
+    assert_equal invoice.client_name, "David"
+    assert_equal invoice.client_street, "Paulina"
+    assert_equal invoice.client_city, "Chicago"
+  end
+
+  def test_delegation_custom_prefix
+    invoice = Invoice.new(@david)
+    assert_equal invoice.customer_name, "David"
+    assert_equal invoice.customer_street, "Paulina"
+    assert_equal invoice.customer_city, "Chicago"
+  end
+
+  def test_delegation_prefix_with_nil_or_false
+    assert_equal Developer.new(@david).name, "David"
+    assert_equal Tester.new(@david).name, "David"
+  end
+
+  def test_delegation_prefix_with_instance_variable
+    assert_raise ArgumentError do
+      Class.new do
+        def initialize(client)
+          @client = client
+        end
+        delegate :name, :address, :to => :@client, :prefix => true
+      end
+    end
+  end
+
+  def test_delegation_with_allow_nil
+    rails = Project.new("Rails", Someone.new("David"))
+    assert_equal rails.name, "David"
+  end
+
+  def test_delegation_with_allow_nil_and_nil_value
+    rails = Project.new("Rails")
+    assert_nil rails.name
+  end
+
+  def test_delegation_with_allow_nil_and_nil_value_and_prefix
+    Project.class_eval do
+      delegate :name, :to => :person, :allow_nil => true, :prefix => true
+    end
+    rails = Project.new("Rails")
+    assert_nil rails.person_name
+  end
+
+  def test_delegation_without_allow_nil_and_nil_value
+    david = Someone.new("David")
+    assert_raise(RuntimeError) { david.street }
+  end
+
+  def test_delegation_to_method_that_exists_on_nil
+    nil_person = Someone.new(nil)
+    assert_equal 0.0, nil_person.to_f
+  end
+
+  def test_delegation_to_method_that_exists_on_nil_when_allowing_nil
+    nil_project = Project.new(nil)
+    assert_equal 0.0, nil_project.to_f
+  end
+
+  def test_delegation_does_not_raise_error_when_removing_singleton_instance_methods
+    parent = Class.new do
+      def self.parent_method; end
+    end
+
+    assert_nothing_raised do
+      Class.new(parent) do
+        class << self
+          delegate :parent_method, :to => :superclass
+        end
+      end
+    end
+  end
+end

data/test/metaprogramming/mattr_accessor_test.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__)+'/../abstract_unit'
+require 'gorillib/metaprogramming/cattr_accessor'
+
+class ModuleAttributeAccessorTest < Test::Unit::TestCase
+  def setup
+    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
+
+  def test_should_use_mattr_default
+    assert_nil @module.foo
+    assert_nil @object.foo
+  end
+
+  def test_should_set_mattr_value
+    @module.foo = :test
+    assert_equal :test, @object.foo
+
+    @object.foo = :test2
+    assert_equal :test2, @module.foo
+  end
+
+  def test_should_not_create_instance_writer
+    assert_respond_to @module, :foo
+    assert_respond_to @module, :foo=
+    assert_respond_to @object, :bar
+    assert !@object.respond_to?(:bar=)
+  end
+
+  def test_should_not_create_instance_reader
+    assert_respond_to @module, :shaq
+    assert !@object.respond_to?(:shaq)
+  end
+end

data/test/metaprogramming/singleton_class_test.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__)+'/../abstract_unit'
+require 'gorillib/metaprogramming/singleton_class'
+
+class KernelTest < Test::Unit::TestCase
+  def test_singleton_class
+    o = Object.new
+    assert_equal class << o; self end, o.singleton_class
+  end
+end