gorillib 0.0.7 → 0.0.8

data/spec/hash/keys_spec.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+require 'gorillib/hash/keys'
+
+describe Hash do
+  class SubclassingArray < Array
+  end
+
+  class SubclassingHash < Hash
+  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 'responds to #symbolize_keys, #symbolize_keys!, #stringify_keys, #stringify_keys!' do
+    {}.should respond_to(:symbolize_keys )
+    {}.should respond_to(:symbolize_keys!)
+    {}.should respond_to(:stringify_keys )
+    {}.should respond_to(:stringify_keys!)
+  end
+
+  describe '#symbolize_keys' do
+    it 'converts keys that are all symbols' do
+      @symbols.symbolize_keys.should == @symbols
+    end
+
+    it 'converts keys that are all strings' do
+      @strings.symbolize_keys.should == @symbols
+      @strings['a'].should == 1
+    end
+
+    it 'converts keys that are mixed' do
+      @mixed.symbolize_keys.should == @symbols
+      @mixed['b'].should == 2
+    end
+  end
+
+  describe '#symbolize_keys!' do
+    it 'converts keys that are all symbols' do
+      @symbols.symbolize_keys!.should == @symbols
+    end
+
+    it 'converts keys that are all strings' do
+      @strings.symbolize_keys!.should == @symbols
+      @strings[:a].should == 1
+    end
+
+    it 'converts keys that are mixed' do
+      @mixed.symbolize_keys!.should == @symbols
+      @mixed[:b].should == 2
+    end
+
+    it 'preserves keys that can not be symbolized' do
+      @illegal_symbols.symbolize_keys.should == @illegal_symbols
+      @illegal_symbols.dup.symbolize_keys!.should == @illegal_symbols
+    end
+
+    it 'preserves fixnum keys' do
+      @fixnums.symbolize_keys.should == @fixnums
+      @fixnums.dup.symbolize_keys!.should == @fixnums
+    end
+  end
+
+  describe '#stringify_keys' do
+    it 'converts keys that are all symbols' do
+      @symbols.stringify_keys.should == @strings
+    end
+
+    it 'converts keys that are all strings' do
+      @strings.stringify_keys.should == @strings
+    end
+
+    it 'converts keys that are mixed' do
+      @mixed.stringify_keys.should == @strings
+    end
+  end
+
+  describe '#stringify_keys!' do
+    it 'converts keys that are all symbols' do
+      @symbols.dup.stringify_keys!.should == @strings
+    end
+
+    it 'converts keys that are all strings' do
+      @strings.dup.stringify_keys!.should == @strings
+    end
+
+    it 'converts keys that are all mixed' do
+      @mixed.dup.stringify_keys!.should == @strings
+    end
+  end
+
+  describe '#assert_valid_keys' do
+    it 'succeeds when valid' do
+      { :failure => "stuff", :funny => "business" }.assert_valid_keys([ :failure, :funny ]).should be_nil
+      { :failure => "stuff", :funny => "business" }.assert_valid_keys(:failure, :funny).should be_nil
+    end
+    it 'raises when there are invalid keys' do
+      lambda{ { :failore => "stuff", :funny => "business" }.assert_valid_keys([ :failure, :funny ]) }.should raise_error(ArgumentError, "Unknown key(s): failore")
+      lambda{ { :failore => "stuff", :funny => "business" }.assert_valid_keys(:failure, :funny)     }.should raise_error(ArgumentError, "Unknown key(s): failore")
+    end
+  end
+
+end

data/spec/hash/reverse_merge_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+require 'gorillib/hash/reverse_merge'
+
+describe Hash do
+  describe 'reverse_merge' do
+
+    before do
+      @defaults = { :a => "x", :b => "y", :c => 10 }.freeze
+      @options  = { :a => 1, :b => 2 }
+      @expected = { :a => 1, :b => 2, :c => 10 }
+    end
+
+    it 'Should merge defaults into options, creating a new hash' do
+      @options.reverse_merge(@defaults).should == @expected
+      @options.should_not == @expected
+    end
+
+
+    it 'Should merge! defaults into options, replacing options.' do
+      @merged = @options.dup
+      @merged.reverse_merge!(@defaults).should == @expected
+      @merged.should == @expected
+    end
+  end
+end

data/spec/hash/slice_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+require 'gorillib/hash/slice'
+
+describe Hash do
+  describe '#slice' do
+    it 'should return a new hash with only the given keys' do
+      original = { :a => 'x', :b => 'y', :c => 10 }
+      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
+    end
+
+    it 'should return a new 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, :b] => "an array key", :c => 10 }
+
+      original.slice([:a, :b], :c).should == expected
+      original.should_not == expected
+    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
+
+    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
+  end
+end

data/spec/hash/zip_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+require 'gorillib/hash/zip'
+
+describe Hash do
+  describe '#zip' do
+    it 'builds a hash from keys and values' do
+      Hash.zip([:a, :b, :c], [1, 2, 3]).should == { :a => 1, :b => 2, :c => 3 }
+    end
+
+    it 'ignores extra values' do
+      Hash.zip([:a, :b, :c], [1, 2, 3, 4, 5]).should == { :a => 1, :b => 2, :c => 3 }
+    end
+
+    it 'supplies nil values for extra keys' do
+      Hash.zip([:a, :b, :c, :d], [1, 2, 3]).should == { :a => 1, :b => 2, :c => 3, :d => nil }
+    end
+
+    it 'uses the default block if given' do
+      hsh = Hash.zip([:a, :b, :c], [1, 2, 3]){|h,k| h[k] = :foo }
+      hsh.should == { :a => 1, :b => 2, :c => 3 }
+      hsh[:d].should == :foo
+    end
+
+    it 'uses the default value if given' do
+      hsh = Hash.zip([:a, :b, :c], [1, 2, 3], :bar)
+      hsh.should == { :a => 1, :b => 2, :c => 3 }
+      hsh[:d].should == :bar
+    end
+
+  end
+end

data/spec/logger/log_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+CODE_FILE = File.dirname(__FILE__)+'/../../lib/gorillib/logger/log.rb'
+require CODE_FILE
+
+describe 'Logger' do
+  describe '#dump' do
+    it 'inspects each arg and sends tab-separated to Log.debug' do
+      Log.should_receive(:debug).with(%Q{{:hi=>"there"}\t3\t"bye"})
+      Log.dump({ :hi => "there" }, 3, "bye")
+    end
+  end
+
+  it 'does not create a log if one exists' do
+    dummy = 'dummy'
+    Object.instance_eval{ remove_const(:Log) rescue nil ; ::Log = dummy }
+    load(CODE_FILE)
+    ::Log.should equal(dummy)
+    Object.instance_eval{ remove_const(:Log) rescue nil }
+  end
+
+  it 'creates a new log to STDERR' do
+    @old_stderr = $stderr
+    $stderr = StringIO.new
+    Object.instance_eval{ remove_const(:Log) rescue nil }
+    load(CODE_FILE)
+    Log.info 'hi mom'
+    $stderr.string.should =~ /hi mom/
+    $stderr = @old_stderr
+  end
+
+end

data/spec/metaprogramming/aliasing_spec.rb

@@ -0,0 +1,177 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+require 'gorillib/metaprogramming/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
+
+describe 'metaprogramming' do
+  before do
+    Object.const_set :FooClassWithBarMethod, Class.new{ def bar() 'bar' end }
+    @instance = FooClassWithBarMethod.new
+  end
+
+  after do
+    Object.instance_eval { remove_const :FooClassWithBarMethod }
+  end
+
+  describe 'alias_method_chain' do
+    it 'creates a with_ and without_ method that chain' do
+      @instance.should respond_to(:bar)
+      feature_aliases = [:bar_with_baz, :bar_without_baz]
+
+      feature_aliases.each do |method|
+        @instance.should_not respond_to(method)
+      end
+      @instance.bar.should == 'bar'
+
+      FooClassWithBarMethod.class_eval{ include BarMethodAliaser }
+      feature_aliases.each do |method|
+        @instance.should respond_to(method)
+      end
+      @instance.bar.should == 'bar_with_baz'
+      @instance.bar_without_baz.should == 'bar'
+    end
+
+    it 'with bang' do
+      FooClassWithBarMethod.class_eval do
+        def quux!; 'quux' end
+      end
+
+      @instance.should_not respond_to(:quux_with_baz!)
+      FooClassWithBarMethod.class_eval do
+        include BarMethodAliaser
+        alias_method_chain :quux!, :baz
+      end
+      @instance.should respond_to(:quux_with_baz!)
+
+      @instance.quux!.should == 'quux_with_baz'
+      @instance.quux_without_baz!.should == 'quux'
+    end
+
+    it 'with same names between predicates and bang methods' do
+      FooClassWithBarMethod.class_eval do
+        def quux!; 'quux!' end
+        def quux?; true end
+        def quux=(v); 'quux=' end
+      end
+
+      @instance.should_not respond_to(:quux_with_baz!)
+      @instance.should_not respond_to(:quux_with_baz?)
+      @instance.should_not respond_to(:quux_with_baz=)
+
+      FooClassWithBarMethod.class_eval { include BarMethodAliaser }
+      @instance.should respond_to(:quux_with_baz!)
+      @instance.should respond_to(:quux_with_baz?)
+      @instance.should respond_to(:quux_with_baz=)
+
+      FooClassWithBarMethod.alias_method_chain :quux!, :baz
+      @instance.quux!.should == 'quux!_with_baz'
+      @instance.quux_without_baz!.should == 'quux!'
+
+      FooClassWithBarMethod.alias_method_chain :quux?, :baz
+      @instance.quux?.should == false
+      @instance.quux_without_baz?.should == true
+
+      FooClassWithBarMethod.alias_method_chain :quux=, :baz
+      @instance.send(:quux=, 1234).should == 'quux=_with_baz'
+      @instance.send(:quux_without_baz=, 1234).should == 'quux='
+    end
+
+    it 'with_feature_punctuation' do
+      FooClassWithBarMethod.class_eval do
+        def quux; 'quux' end
+        def quux?; 'quux?' end
+        include BarMethodAliaser
+        alias_method_chain :quux, :baz!
+      end
+
+      @instance.quux_with_baz!.should == 'quux_with_baz'
+
+      lambda{ FooClassWithBarMethod.alias_method_chain :quux?, :baz! }.should raise_error(NameError)
+    end
+
+    it 'yields target and punctuation' do
+      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
+
+      args.should_not be_nil
+      args[0].should == 'quux'
+      args[1].should == '?'
+    end
+
+    it 'preserves private method status' do
+      FooClassWithBarMethod.class_eval do
+        def duck; 'duck' end
+        include BarMethodAliaser
+        private :duck
+        alias_method_chain :duck, :orange
+      end
+
+      lambda{ @instance.duck }.should raise_error(NoMethodError)
+
+      @instance.instance_eval{ duck }.should == 'duck_with_orange'
+      FooClassWithBarMethod.should be_private_method_defined(:duck)
+    end
+
+    it 'preserves protected method status' do
+      FooClassWithBarMethod.class_eval do
+        def duck; 'duck' end
+        include BarMethodAliaser
+        protected :duck
+        alias_method_chain :duck, :orange
+      end
+
+      lambda{ @instance.duck }.should raise_error(NoMethodError)
+
+      @instance.instance_eval{ duck }.should == 'duck_with_orange'
+      FooClassWithBarMethod.should be_protected_method_defined(:duck)
+    end
+
+    it 'preserves public method status' do
+      FooClassWithBarMethod.class_eval do
+        def duck; 'duck' end
+        include BarMethodAliaser
+        public :duck
+        alias_method_chain :duck, :orange
+      end
+
+      @instance.duck.should == 'duck_with_orange'
+      FooClassWithBarMethod.should be_public_method_defined(:duck)
+    end
+  end
+end

data/spec/metaprogramming/cattr_accessor_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+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 '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/class_attribute_spec.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+require 'gorillib/metaprogramming/class_attribute'
+
+describe 'metaprogramming' do
+  describe 'class_attribute' do
+    before do
+      @klass = Class.new { class_attribute :setting }
+      @sub = Class.new(@klass)
+    end
+
+    it 'defaults to nil' do
+      @klass.setting.should be_nil
+      @sub.setting.should be_nil
+    end
+
+    it 'is inheritable' do
+      @klass.setting = 1
+      @sub.setting == 1
+    end
+
+    it 'is overridable' do
+      @sub.setting = 1
+      @klass.setting.should be_nil
+
+      @klass.setting = 2
+      @sub.setting.should == 1
+
+      Class.new(@sub).setting.should == 1
+    end
+
+    it 'creates a query? method' do
+      @klass.setting?.should == false
+      @klass.setting = 1
+      @klass.setting?.should == true
+    end
+
+    it 'instance reader delegates to class' do
+      @klass.new.setting.should be_nil
+
+      @klass.setting = 1
+      @klass.new.setting.should == 1
+    end
+
+    it 'instance override' do
+      object = @klass.new
+      object.setting = 1
+      @klass.setting.should be_nil
+      @klass.setting = 2
+      object.setting.should == 1
+    end
+
+    it 'instance query' do
+      object = @klass.new
+      object.setting?.should == false
+      object.setting = 1
+      object.setting?.should == true
+    end
+
+    it 'disabling instance writer' do
+      object = Class.new { class_attribute :setting, :instance_writer => false }.new
+      lambda{ object.setting = 'boom' }.should raise_error(NoMethodError)
+    end
+
+    it 'works well with singleton classes' do
+      object = @klass.new
+      object.singleton_class.setting = 'foo'
+      object.setting.should == 'foo'
+    end
+
+    it 'setter returns set value' do
+      val = @klass.send(:setting=, 1)
+      val.should == 1
+    end
+  end
+end

data/spec/metaprogramming/delegation_spec.rb

@@ -0,0 +1,166 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+require 'gorillib/metaprogramming/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
+
+# ===========================================================================
+#
+# Tests start
+
+describe 'metaprogramming' do
+  describe 'delegation' do
+    before do
+      @david = Someone.new("David", Somewhere.new("Paulina", "Chicago"))
+    end
+
+    it 'delegates to methods' do
+      @david.street.should == "Paulina"
+      @david.city.should == "Chicago"
+    end
+
+    it 'delegates down hierarchy' do
+      @david.upcase.should == "CHICAGO"
+    end
+
+    it 'delegates to instance variables' do
+      david = Name.new("David", "Hansson")
+      david.upcase.should == "DAVID HANSSON"
+    end
+
+    it 'raises with a missing delegation target' do
+      lambda{ Name.send :delegate, :nowhere }.should raise_error(ArgumentError)
+      lambda{ Name.send :delegate, :noplace, :tos => :hollywood }.should raise_error(ArgumentError)
+    end
+
+    it 'uses a prefix' do
+      invoice = Invoice.new(@david)
+      invoice.client_name.should   == "David"
+      invoice.client_street.should == "Paulina"
+      invoice.client_city.should   == "Chicago"
+    end
+
+    it 'accepts a custom prefix' do
+      invoice = Invoice.new(@david)
+      invoice.customer_name.should   == "David"
+      invoice.customer_street.should == "Paulina"
+      invoice.customer_city.should   == "Chicago"
+    end
+
+    it 'delegation prefix with nil or false' do
+      Developer.new(@david).name.should == "David"
+      Tester.new(@david).name.should    == "David"
+    end
+
+    it 'delegation prefix with instance variable' do
+      lambda{
+        Class.new do
+          def initialize(client)
+            @client = client
+          end
+          delegate :name, :address, :to => :@client, :prefix => true
+        end
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'with allow_nil' do
+      rails = Project.new("Rails", Someone.new("David"))
+      rails.name.should == "David"
+    end
+
+    it 'with allow_nil, accepts a nil value' do
+      rails = Project.new("Rails")
+      rails.name.should be_nil
+    end
+
+    it 'with allow_nil, accepts a nil value and prefix' do
+      Project.class_eval do
+        delegate :name, :to => :person, :allow_nil => true, :prefix => true
+      end
+      rails = Project.new("Rails")
+      rails.person_name.should be_nil
+    end
+
+    it 'without allow_nil, raises an error on nil vlaue' do
+      david = Someone.new("David")
+      lambda{ david.street }.should raise_error(RuntimeError)
+    end
+
+    it 'delegates to method that exists on nil' do
+      nil_person = Someone.new(nil)
+      nil_person.to_f.should == 0.0
+    end
+
+    it 'delegates to method that exists on nil when allowing nil' do
+      nil_project = Project.new(nil)
+      nil_project.to_f.should == 0.0
+    end
+
+    it 'does not raise error when removing singleton instance methods' do
+      parent = Class.new do
+        def self.parent_method; end
+      end
+
+      Class.new(parent) do
+        class << self
+          delegate :parent_method, :to => :superclass
+        end
+      end
+    end
+  end
+end