gorillib 0.0.7 → 0.0.8

data/lib/gorillib/hash/deep_compact.rb

@@ -6,19 +6,9 @@ require 'gorillib/object/blank'
 class Hash
   def deep_compact!
     self.each do |key, val|
-      case val
-      when Hash
-        val = val.deep_compact!
-        self.delete(key) if val.blank?
-      when Array
-        val = val.deep_compact!
-        self.delete(key) if val.blank?
-      when String
-        self.delete(key) if val.blank?
-      when nil
-        self.delete(key)
-      end
+      val.deep_compact! if val.respond_to?(:deep_compact!)
+      self.delete(key) if val.blank?
     end
-    self.blank? ? nil : self
+    self
   end
 end

data/lib/gorillib/logger/log.rb

@@ -5,7 +5,7 @@ require 'logger'
 #
 # define Log yourself to prevent its creation
 #
-::Log = Logger.new(STDERR) unless defined?(::Log)
+::Log = Logger.new($stderr) unless defined?(::Log)
 
 def Log.dump *args
   debug args.map(&:inspect).join("\t")

data/lib/gorillib/numeric/clamp.rb

@@ -1,4 +1,13 @@
 Numeric.class_eval do
+  #
+  # Coerce a number to lie between min and max.
+  #
+  # @example
+  #   5.clamp(6, 7)     # => 6
+  #   5.clamp(6)        # => 6
+  #   5.clamp(nil, 6)   # => 5
+  #   5.clamp(nil, 4)   # => 4
+  #
   def clamp min=nil, max=nil
     raise ArgumentError, "min must be <= max" if (min && max && (min > max))
     return min if min && (self < min)

data/lib/gorillib/object/try.rb

@@ -0,0 +1,10 @@
+class Object
+  #   @person ? @person.name : nil
+  # vs
+  #   @person.try(:name)
+  def try(method)
+    send method if respond_to? method
+  end
+
+end
+

data/lib/gorillib/object/try_dup.rb

@@ -0,0 +1,44 @@
+class Object
+  # Override this in a child if it cannot be dup'ed
+  #
+  # @return [Object]
+  def try_dup
+    self.dup
+  end
+end
+
+class TrueClass
+  def try_dup
+    self
+  end
+end
+
+class FalseClass
+  def try_dup
+    self
+  end
+end
+
+class Module
+  def try_dup
+    self
+  end
+end
+
+class NilClass
+  def try_dup
+    self
+  end
+end
+
+class Numeric
+  def try_dup
+    self
+  end
+end
+
+class Symbol
+  def try_dup
+    self
+  end
+end

data/lib/gorillib/string/human.rb

@@ -34,9 +34,7 @@ class Array
     default_words_connector     = ", "
     default_two_words_connector = " and "
     default_last_word_connector = ", and "
-
-    options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
-    options.reverse_merge! :words_connector => default_words_connector, :two_words_connector => default_two_words_connector, :last_word_connector => default_last_word_connector
+    options = { :words_connector => default_words_connector, :two_words_connector => default_two_words_connector, :last_word_connector => default_last_word_connector }.merge(options)
 
     case length
       when 0

data/lib/gorillib/string/truncate.rb

@@ -16,13 +16,13 @@ class String
   #   # => "And they f... (continued)"
   def truncate(length, options = {})
     text = self.dup
-    chars        = text.respond_to?(:mb_chars)      ? text.mb_chars            : text.chars
+    chars        = text.respond_to?(:mb_chars)      ? text.mb_chars            : text
     omission     = options[:omission] || "..."
     omission_len = omission.respond_to?(:mb_chars)  ? omission.mb_chars.length : omission.length
     length_with_room_for_omission = length - omission_len
 
     if (separator = options[:separator])
-      separator_chars = separator.respond_to?(:mb_chars) ? separator.to_s.mb_chars  : separator.to_s.chars
+      separator_chars = separator.respond_to?(:mb_chars) ? separator.to_s.mb_chars  : separator.to_s
       stop = chars.rindex(separator_chars, length_with_room_for_omission) || length_with_room_for_omission
     else
       stop = length_with_room_for_omission

data/spec/array/compact_blank_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+require 'gorillib/array/compact_blank'
+
+describe Array do
+
+  describe '#compact_blank' do
+    it 'with empty' do
+      [ [nil], [nil, false, {}, ""] ].each do |arr|
+        arr.compact_blank.should == []
+        arr.length.should_not    == 0
+      end
+    end
+
+    it 'with full' do
+      [ [nil, 1, nil, 2], [nil, 1, false, 2, {}, ""] ].each do |arr|
+        arr.compact_blank.should == [1, 2]
+      end
+    end
+  end
+
+  describe '#compact_blank!' do
+    it 'with empty' do
+      [].compact_blank!.should == []
+      [ [nil], [nil, false, {}, ""] ].each do |arr|
+        arr.compact_blank!.should == []
+        arr.length.should         == 0
+      end
+    end
+
+    it 'with full' do
+      [ [nil, 1, nil, 2], [nil, 1, false, 2, {}, ""] ].each do |arr|
+        arr.compact_blank!.should == [1, 2]
+      end
+    end
+
+  end
+end

data/spec/array/extract_options_spec.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+require 'gorillib/array/extract_options'
+
+class HashSubclass < Hash
+end
+
+class ExtractableHashSubclass < Hash
+  def extractable_options?
+    true
+  end
+end
+
+describe Array do
+  describe '#extract_options!' do
+    it 'pulls empty hash from empty array' do
+      [].extract_options!.should == {}
+    end
+    it 'pulls empty hash from array with no hash' do
+      [1].extract_options!.should == {}
+    end
+    it 'pulls hash from array with only that hash' do
+      [{:a=>:b}].extract_options!.should    == {:a=>:b}
+    end
+    it 'pulls hash from end of array' do
+      [1, {:a=>:b}].extract_options!.should == {:a=>:b}
+    end
+
+    it 'does not extract hash subclasses' do
+      hash = HashSubclass.new
+      hash[:foo] = 1
+      array = [hash]
+      options = array.extract_options!
+      options.should == {}
+      array.should   == [hash]
+    end
+
+    it 'does extract extractable subclass' do
+      hash = ExtractableHashSubclass.new
+      hash[:foo] = 1
+      array = [hash]
+      options = array.extract_options!
+      options.should == {:foo => 1}
+      array.should   == []
+    end
+
+  end
+end

data/spec/datetime/flat_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+require 'gorillib/datetime/flat'
+require 'gorillib/datetime/parse'
+
+describe Time do
+  describe '#to_flat' do
+    before do
+      @time_utc  = Time.parse("2011-02-03T04:05:06 UTC")
+      @time_cst  = Time.parse("2011-02-02T22:05:06-06:00")
+      @time_flat = "20110203040506"
+    end
+
+    it 'converts times to UTC' do
+      @time_utc.to_flat.should == @time_flat
+      @time_cst.to_flat.should == @time_flat
+    end
+
+    it 'round-trips' do
+      Time.parse_safely(@time_flat).to_flat.should == @time_flat
+      Time.parse_safely(@time_utc.to_flat).should  == @time_utc
+    end
+
+  end
+end
+
+describe Date do
+  describe '#to_flat' do
+    before do
+      @date      = Date.new(2011, 2, 3)
+      @date_flat = "20110203"
+    end
+
+    it 'converts dates' do
+      @date.to_flat.should == @date_flat
+    end
+
+  end
+end

data/spec/datetime/parse_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+require 'gorillib/datetime/flat'
+require 'gorillib/datetime/parse'
+
+describe DateTime do
+  describe '#parse_safely' do
+    before do
+      @time_utc  = Time.parse("2011-02-03T04:05:06 UTC")
+      @time_cst  = Time.parse("2011-02-02T22:05:06-06:00")
+      @time_flat    = "20110203040506"
+      @time_iso_utc = "2011-02-03T04:05:06+00:00"
+      @time_iso_cst = "2011-02-02T22:05:06-06:00"
+    end
+
+    it 'with a Time, passes it through.' do
+      Time.parse_safely(@time_utc).should == @time_utc
+      Time.parse_safely(@time_cst).should == @time_cst
+    end
+
+    it 'with a Time, converts to UTC.' do
+      Time.parse_safely(@time_utc).utc_offset.should == 0
+      Time.parse_safely(@time_cst).utc_offset.should == 0
+    end
+
+    it 'with a flat time, converts to UTC Time instance' do
+      Time.parse_safely(@time_flat).should == @time_utc
+      Time.parse_safely(@time_flat).utc_offset.should == 0
+    end
+
+    it 'with a flat time and Z, converts to UTC Time instance' do
+      Time.parse_safely(@time_flat+'Z').should == @time_utc
+      Time.parse_safely(@time_flat+'Z').utc_offset.should == 0
+    end
+
+    it 'parses a regular time string, converting to UTC' do
+      Time.parse_safely(@time_iso_utc).should == @time_utc
+      Time.parse_safely(@time_iso_utc).utc_offset.should == 0
+      Time.parse_safely(@time_iso_cst).should == @time_utc
+      Time.parse_safely(@time_iso_cst).utc_offset.should == 0
+    end
+
+    it 'round-trips' do
+      Time.parse_safely(@time_flat).to_flat.should == @time_flat
+      Time.parse_safely(@time_utc.to_flat).should  == @time_utc
+    end
+
+  end
+end

data/spec/enumerable/sum_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+require 'gorillib/enumerable/sum'
+
+Payment = Struct.new(:price)
+class SummablePayment < Payment
+  def +(p) self.class.new(price + p.price) end
+end
+
+describe Enumerable do
+  describe '#sum' do
+    it 'sums lists of numbers to a number' do
+      [5, 15, 10].sum        .should == 30
+      [5, 15, 10].sum{|i| i }.should == 30
+    end
+
+    it 'sums list of strings to a string' do
+
+      %w(a b c).sum        .should == 'abc'
+      %w(a b c).sum{|i| i }.should == 'abc'
+    end
+
+    it 'sums list of objects with a &:method' do
+      payments = [ Payment.new(5), Payment.new(15), Payment.new(10) ]
+      payments.sum(&:price)           .should == 30
+      payments.sum { |p| p.price * 2 }.should == 60
+    end
+
+    it 'sums object with a synthetic "+" method' do
+      payments = [ SummablePayment.new(5), SummablePayment.new(15) ]
+      payments.sum        .should == SummablePayment.new(20)
+      payments.sum{|p| p }.should == SummablePayment.new(20)
+    end
+
+    it 'handles nil sums' do
+      lambda{ [5, 15, nil].sum }.should raise_error(TypeError)
+
+      payments = [ Payment.new(5), Payment.new(15), Payment.new(10), Payment.new(nil) ]
+      lambda{ payments.sum(&:price) }.should raise_error(TypeError)
+      payments.sum{|p| p.price.to_i * 2 }.should == 60
+    end
+
+    it 'handles empty sums' do
+      [].sum        .should == 0
+      [].sum{|i| i }.should == 0
+      [].sum(Payment.new(0)).should == Payment.new(0)
+    end
+
+    it 'behaves the same on ranges' do
+      (1..4).sum{|i| i * 2 }.should == 20
+      (1..4).sum            .should == 10
+      (1..4.5).sum          .should == 10
+      (1...4).sum           .should ==  6
+      ('a'..'c').sum        .should == 'abc'
+    end
+  end
+end

data/spec/hash/compact_spec.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+require 'gorillib/hash/compact'
+
+describe Hash do
+  describe '#compact' do
+    it 'scrubs nil' do
+      hsh = { 1 => nil }
+      hsh.compact.should == {}
+      hsh.length.should == 1
+    end
+
+    it 'does not scrub false, {} or ""' do
+      hsh       = { 1 => nil, 2 => false, 3 => {}, 4 => "" }
+      hsh.compact.should == { 2 => false, 3 => {}, 4 => "" }
+      hsh.length.should == 4
+    end
+
+    it 'with values' do
+      { 1 => nil, nil => 2 }.compact.should == { nil => 2 }
+      { 1 => nil, 2 => :val_2, 3 => {}, 4 => :val_4}.compact.should == { 2 => :val_2, 3 => {}, 4 => :val_4 }
+    end
+  end
+
+  describe '#compact!' do
+    it 'scrubs nil' do
+      hsh = { 1 => nil }
+      hsh.compact!.should == {}
+      hsh.length.should == 0
+    end
+
+    it 'does not scrub false, {} or ""' do
+      hsh        = { 1 => nil, 2 => false, 3 => {}, 4 => "" }
+      hsh.compact!.should == { 2 => false, 3 => {}, 4 => "" }
+      hsh.length.should == 3
+    end
+
+    it 'with values' do
+      { 1 => nil, nil => 2 }.compact!.should == { nil => 2 }
+      { 1 => nil, 2 => :val_2, 3 => {}, 4 => :val_4}.compact!.should == { 2 => :val_2, 3 => {}, 4 => :val_4 }
+    end
+  end
+
+  describe '#compact_blank' do
+    it 'when empty' do
+      [ { 1 => nil}, { 1 => nil, 2 => false, 3 => {}, 4 => ""} ].each do |hsh|
+        hsh.compact_blank.should == {}
+        hsh.length.should_not == 0
+      end
+    end
+
+    it 'with values' do
+      { 1 => nil, nil => 2 }.compact_blank.should == { nil => 2 }
+      { 1 => nil, 2 => :val_2, 3 => {}, 4 => :val_4}.compact_blank.should == { 2 => :val_2, 4 => :val_4 }
+    end
+  end
+
+  describe '#compact_blank!' do
+    it 'when empty' do
+      [ { 1 => nil}, { 1 => nil, 2 => false, 3 => {}, 4 => ""} ].each do |hsh|
+        hsh.compact_blank!.should == {}
+        hsh.length.should == 0
+      end
+    end
+
+    it 'with values' do
+        { 1 => nil, nil => 2 }.compact_blank!.should == { nil => 2 }
+        { 1 => nil, 2 => :val_2, 3 => {}, 4 => :val_4}.compact_blank!.should == { 2 => :val_2, 4 => :val_4 }
+    end
+  end
+end

data/spec/hash/deep_compact_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+require 'gorillib/hash/deep_compact'
+require 'gorillib/array/deep_compact'
+
+describe Hash do
+  describe 'array/deep_compact and hash/deep_compact' do
+    it "should respond to the method deep_compact!" do
+      { }.should respond_to :deep_compact!
+    end
+
+    it "should return nil if all values evaluate as blank" do
+      { :a => nil, :b => "", :c => [], :d => {} }.deep_compact!.should == {}
+    end
+
+    it "should return a hash with all blank values removed recursively" do
+      @test_hash = {:e=>["", nil, [], {}, "foo", { :a=> [nil, {}, { :c=> ["","",[]] } ], :b => nil }]}
+      @test_hash.deep_compact!.should == {:e=>["foo"]}
+    end
+  end
+end
+
+describe Array do
+  describe 'array/deep_compact and hash/deep_compact' do
+    it "should respond to the method deep_compact!" do
+      [ ].should respond_to :deep_compact!
+    end
+
+    it "should return nil if all values evaluate as blank" do
+      [nil, '', { }, []].deep_compact!.should == []
+    end
+
+    it "should return a hash with all blank values removed recursively" do
+      @test_arr = ["", nil, [], {}, "foo", { :a=> [nil, {}, { :c=> ["","",[]] } ], :b => nil }]
+      @test_arr.deep_compact!.should == ["foo"]
+    end
+  end
+end

data/spec/hash/deep_merge_spec.rb

@@ -0,0 +1,117 @@
+require File.dirname(__FILE__)+'/../spec_helper'
+require 'gorillib/hash/deep_merge'
+
+describe Hash do
+  describe '#deep_merge' do
+    before do
+      @hash_1 =
+        { :a => 1, :b => "b", :c => { :val => "val", :arr => ['hi'], :hsh => { :d1 => "d1" } } }
+    end
+
+    it 'merges, replacing values on the left' do
+      @hash_1.deep_merge(
+        { :a => 1,            :c => { :val => 2,                                             } }).should ==
+        { :a => 1, :b => "b", :c => { :val => 2,     :arr => ['hi'], :hsh => { :d1 => "d1" } } }
+      @hash_1.should ==
+        { :a => 1, :b => "b", :c => { :val => "val", :arr => ['hi'], :hsh => { :d1 => "d1" } } }
+    end
+
+    it 'merges, merging hashes where they meet' do
+      @hash_1.deep_merge(
+        { :a => 1,            :c => { :val => 2,                     :hsh => {              :d2 => "d2" } } }).should ==
+        { :a => 1, :b => "b", :c => { :val => 2,     :arr => ['hi'], :hsh => { :d1 => "d1", :d2 => "d2" } } }
+      @hash_1.should ==
+        { :a => 1, :b => "b", :c => { :val => "val", :arr => ['hi'], :hsh => { :d1 => "d1" } } }
+    end
+
+    it 'merges, replacing hash on left with value on right' do
+      @hash_1.deep_merge(
+        { :a => 1,            :c => {                                :hsh => :val } }).should ==
+        { :a => 1, :b => "b", :c => { :val => "val", :arr => ['hi'], :hsh => :val } }
+      @hash_1.should ==
+        { :a => 1, :b => "b", :c => { :val => "val", :arr => ['hi'], :hsh => { :d1 => "d1" } } }
+    end
+
+    it 'merges, replacing val on left with hash on right' do
+      @hash_1.deep_merge(
+        { :a => 1,            :c => { :val => {},                                            } }).should ==
+        { :a => 1, :b => "b", :c => { :val => {},    :arr => ['hi'], :hsh => { :d1 => "d1" } } }
+      @hash_1.should ==
+        { :a => 1, :b => "b", :c => { :val => "val", :arr => ['hi'], :hsh => { :d1 => "d1" } } }
+    end
+
+    it 'merges, replacing array on left with array on right without merging' do
+      @hash_1.deep_merge(
+        { :a => 1,            :c => {                :arr => ['whatevs']                          } }).should ==
+        { :a => 1, :b => "b", :c => { :val => "val", :arr => ['whatevs'], :hsh => { :d1 => "d1" } } }
+      @hash_1.should ==
+        { :a => 1, :b => "b", :c => { :val => "val", :arr => ['hi'], :hsh => { :d1 => "d1" } } }
+    end
+  end
+
+  describe '#deep_merge!' do
+    before do
+      @hash_1 = {
+          :a => 1, :b => "b", :c => { :val => "val", :arr => ['hi'], :hsh => { :d1 => "d1" } } }
+    end
+
+    it 'merges, replacing values on the left' do
+      @hash_1.deep_merge!(
+        { :a => 1,            :c => { :val => 2,                                             } }).should ==
+        { :a => 1, :b => "b", :c => { :val => 2,     :arr => ['hi'], :hsh => { :d1 => "d1" } } }
+      @hash_1.should ==
+        { :a => 1, :b => "b", :c => { :val => 2,     :arr => ['hi'], :hsh => { :d1 => "d1" } } }
+    end
+
+    it 'merges, merging hashes where they meet' do
+      @hash_1.deep_merge!(
+        { :a => 1,            :c => { :val => 2,                     :hsh => {              :d2 => "d2" } } }).should ==
+        { :a => 1, :b => "b", :c => { :val => 2,     :arr => ['hi'], :hsh => { :d1 => "d1", :d2 => "d2" } } }
+      @hash_1.should ==
+        { :a => 1, :b => "b", :c => { :val => 2,     :arr => ['hi'], :hsh => { :d1 => "d1", :d2 => "d2" } } }
+    end
+
+    it 'merges, replacing hash on left with value on right' do
+      @hash_1.deep_merge!(
+        { :a => 1,            :c => {                                :hsh => :val } }).should ==
+        { :a => 1, :b => "b", :c => { :val => "val", :arr => ['hi'], :hsh => :val } }
+      @hash_1.should ==
+        { :a => 1, :b => "b", :c => { :val => "val", :arr => ['hi'], :hsh => :val } }
+    end
+
+    it 'merges, replacing val on left with hash on right' do
+      @hash_1.deep_merge!(
+        { :a => 1,            :c => { :val => {},                                            } }).should ==
+        { :a => 1, :b => "b", :c => { :val => {},    :arr => ['hi'], :hsh => { :d1 => "d1" } } }
+      @hash_1.should ==
+        { :a => 1, :b => "b", :c => { :val => {},    :arr => ['hi'], :hsh => { :d1 => "d1" } } }
+    end
+
+    it 'merges, replacing array on left with array on right without merging' do
+      @hash_1.deep_merge!(
+        { :a => 1,            :c => {                :arr => ['whatevs']                          } }).should ==
+        { :a => 1, :b => "b", :c => { :val => "val", :arr => ['whatevs'], :hsh => { :d1 => "d1" } } }
+      @hash_1.should ==
+        { :a => 1, :b => "b", :c => { :val => "val", :arr => ['whatevs'], :hsh => { :d1 => "d1" } } }
+    end
+  end
+
+
+
+  describe '#deep_dup' do
+    # 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
+end