gorillib 0.0.2

data/lib/gorillib/object/blank.rb

@@ -0,0 +1,89 @@
+class Object
+  ##
+  # Returns true if the object is nil or empty (if applicable)
+  #
+  #   [].blank?         #=>  true
+  #   [1].blank?        #=>  false
+  #   [nil].blank?      #=>  false
+  #
+  # @return [TrueClass, FalseClass]
+  #
+  # @api public
+  def blank?
+    nil? || (respond_to?(:empty?) && empty?)
+  end
+end # class Object
+
+class Numeric
+  ##
+  # Numerics are never blank
+  #
+  #   0.blank?          #=>  false
+  #   1.blank?          #=>  false
+  #   6.54321.blank?    #=>  false
+  #
+  # @return [FalseClass]
+  #
+  # @api public
+  def blank?
+    false
+  end
+end # class Numeric
+
+class NilClass
+  ##
+  # Nil is always blank
+  #
+  #   nil.blank?        #=>  true
+  #
+  # @return [TrueClass]
+  #
+  # @api public
+  def blank?
+    true
+  end
+end # class NilClass
+
+class TrueClass
+  ##
+  # True is never blank.
+  #
+  #   true.blank?       #=>  false
+  #
+  # @return [FalseClass]
+  #
+  # @api public
+  def blank?
+    false
+  end
+end # class TrueClass
+
+class FalseClass
+  ##
+  # False is always blank.
+  #
+  #   false.blank?      #=>  true
+  #
+  # @return [TrueClass]
+  #
+  # @api public
+  def blank?
+    true
+  end
+end # class FalseClass
+
+class String
+  ##
+  # Strips out whitespace then tests if the string is empty.
+  #
+  #   "".blank?         #=>  true
+  #   "     ".blank?    #=>  true
+  #   " hey ho ".blank? #=>  false
+  #
+  # @return [TrueClass, FalseClass]
+  #
+  # @api public
+  def blank?
+    strip.empty?
+  end
+end # class String

data/lib/gorillib/some.rb

@@ -0,0 +1,12 @@
+require 'gorillib/base'
+require 'set'
+require 'time'
+require 'date'
+require 'gorillib/array/compact_flat'
+require 'gorillib/hash/compact'
+require 'gorillib/enumerable/sum'
+require 'gorillib/datetime/flat'
+require 'gorillib/datetime/parse'
+require 'gorillib/hash/zip'
+require 'gorillib/hash/slice'
+require 'gorillib/hash/keys'

data/lib/gorillib/string/constantize.rb

@@ -0,0 +1,21 @@
+class String
+
+  # Constantize tries to find a declared constant with the name specified
+  # in the string. It raises a NameError when the name is not in CamelCase
+  # or is not initialized.
+  #
+  # @example
+  #   "Module".constantize #=> Module
+  #   "Class".constantize #=> Class
+  #
+  # This is the extlib version of String#constantize, which has different
+  # behavior wrt using lexical context: see active_support/inflector/methods.rb
+  #
+  def constantize
+    unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ self
+      raise NameError, "#{self.inspect} is not a valid constant name!"
+    end
+
+    Object.module_eval("::#{$1}", __FILE__, __LINE__)
+  end unless method_defined?(:constantize)
+end

data/lib/gorillib/string/human.rb

@@ -0,0 +1,52 @@
+require 'gorillib/string/inflections'
+require 'gorillib/array/extract_options'
+
+class String
+
+  # Capitalizes the first word and turns underscores into spaces and strips a
+  # trailing "_id", if any. Like +titleize+, this is meant for creating pretty output.
+  #
+  # @example
+  #   "employee_salary" #=> "Employee salary"
+  #   "author_id" #=> "Author"
+  def humanize
+    self.gsub(/_id$/, '').tr('_', ' ').capitalize
+  end unless method_defined?(:humanize)
+
+  # Capitalizes all the words and replaces some characters in the string to create
+  # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
+  # used in the Rails internals.
+  #
+  # Examples:
+  #   "man from the boondocks".titleize # => "Man From The Boondocks"
+  #   "x-men: the last stand".titleize  # => "X Men: The Last Stand"
+  def titleize
+    self.underscore.humanize.gsub(/\b('?[a-z])/){ $1.capitalize }
+  end unless method_defined?(:titleize)
+end
+
+class Array
+  # Converts the array to a comma-separated sentence where the last element is joined by the connector word. Options:
+  # * <tt>:words_connector</tt> - The sign or word used to join the elements in arrays with two or more elements (default: ", ")
+  # * <tt>:two_words_connector</tt> - The sign or word used to join the elements in arrays with two elements (default: " and ")
+  # * <tt>:last_word_connector</tt> - The sign or word used to join the last element in arrays with three or more elements (default: ", and ")
+  def to_sentence(options = {})
+    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
+
+    case length
+      when 0
+        ""
+      when 1
+        self[0].to_s.dup
+      when 2
+        "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
+      else
+        "#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
+    end
+  end unless method_defined?(:to_sentence)
+end

data/lib/gorillib/string/inflections.rb

@@ -0,0 +1,78 @@
+# String inflections define new methods on the String class to transform names for different purposes.
+#
+#   "ScaleScore".underscore # => "scale_score"
+#
+# This doesn't define the full set of inflections -- only
+#
+# * camelize
+# * snakeize
+# * underscore
+# * demodulize
+#
+class String
+
+  # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+
+  # is set to <tt>:lower</tt> then +camelize+ produces lowerCamelCase.
+  #
+  # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+  #
+  # @example:
+  #   "active_record".camelize                # => "ActiveRecord"
+  #   "active_record".camelize(:lower)        # => "activeRecord"
+  #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
+  #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
+  #
+  # As a rule of thumb you can think of +camelize+ as the inverse of +underscore+,
+  # though there are cases where that does not hold:
+  #
+  #   "SSLError".underscore.camelize # => "SslError"
+  #
+  def camelize(first_letter = :upper)
+    camelized = self.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    (first_letter == :lower) ? (self[0..0].downcase + camelized[1..-1]) : camelized
+  end unless method_defined?(:camelize)
+
+  # Converts strings to snakeCase, also known as lowerCamelCase.
+  #
+  # +snakeize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+  #
+  # @example:
+  #   "active_record".snakeize                # => "activeRecord"
+  #   "active_record/errors".snakeize         # => "activeRecord::Errors"
+  #
+  def snakeize
+    camelize :lower
+  end unless method_defined?(:snakeize)
+
+  # Makes an underscored, lowercase form from the expression in the string.
+  #
+  # +underscore+ will also change '::' to '/' to convert namespaces to paths.
+  #
+  # Examples:
+  #   "ActiveRecord".underscore         # => "active_record"
+  #   "ActiveRecord::Errors".underscore # => active_record/errors
+  #
+  # As a rule of thumb you can think of +underscore+ as the inverse of +camelize+,
+  # though there are cases where that does not hold:
+  #
+  #   "SSLError".underscore.camelize # => "SslError"
+  def underscore
+    word = self.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end unless method_defined?(:underscore)
+
+  # Removes the module part from the expression in the string
+  #
+  # @example
+  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
+  #   "Inflections".demodulize #=> "Inflections"
+  def demodulize
+    self.gsub(/^.*::/, '')
+  end unless method_defined?(:demodulize)
+
+end

data/lib/gorillib/string/truncate.rb

@@ -0,0 +1,33 @@
+class String
+  # Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
+  #
+  #   "Once upon a time in a world far far away".truncate(27)
+  #   # => "Once upon a time in a wo..."
+  #
+  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
+  # for a total length not exceeding <tt>:length</tt>:
+  #
+  #   "Once upon a time in a world far far away".truncate(27, :separator => ' ')
+  #   # => "Once upon a time in a..."
+  #
+  # Pass a <tt>:separator</tt> to truncate +text+ at a natural break:
+  #
+  #   "And they found that many people were sleeping better.".truncate(25, :omission => "... (continued)")
+  #   # => "And they f... (continued)"
+  def truncate(length, options = {})
+    text = self.dup
+    chars        = text.respond_to?(:mb_chars)      ? text.mb_chars            : text.chars
+    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
+      stop = chars.rindex(separator_chars, length_with_room_for_omission) || length_with_room_for_omission
+    else
+      stop = length_with_room_for_omission
+    end
+
+    (chars.length > length ? chars[0...stop] + omission : text).to_s
+  end unless method_defined?(:truncate)
+end

data/lib/gorillib.rb

@@ -0,0 +1 @@
+require 'gorillib/base'

data/spec/blank_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'extlib/blank'
+
+describe Object do
+  it 'should provide blank?' do
+    Object.new.should respond_to(:blank?)
+  end
+
+  it 'should be blank if it is nil' do
+    object = Object.new
+    class << object
+      def nil?; true end
+    end
+    object.should be_blank
+  end
+
+  it 'should be blank if it is empty' do
+    {}.should be_blank
+    [].should be_blank
+  end
+
+  it 'should not be blank if not nil or empty' do
+    Object.new.should_not be_blank
+    [nil].should_not be_blank
+    { nil => 0 }.should_not be_blank
+  end
+end
+
+describe Numeric do
+  it 'should provide blank?' do
+    1.should respond_to(:blank?)
+  end
+
+  it 'should never be blank' do
+    1.should_not be_blank
+  end
+end
+
+describe NilClass do
+  it 'should provide blank?' do
+    nil.should respond_to(:blank?)
+  end
+
+  it 'should always be blank' do
+    nil.should be_blank
+  end
+end
+
+describe TrueClass do
+  it 'should provide blank?' do
+    true.should respond_to(:blank?)
+  end
+
+  it 'should never be blank' do
+    true.should_not be_blank
+  end
+end
+
+describe FalseClass do
+  it 'should provide blank?' do
+    false.should respond_to(:blank?)
+  end
+
+  it 'should always be blank' do
+    false.should be_blank
+  end
+end
+
+describe String do
+  it 'should provide blank?' do
+    'string'.should respond_to(:blank?)
+  end
+
+  it 'should be blank if empty' do
+    ''.should be_blank
+  end
+
+  it 'should be blank if it only contains whitespace' do
+    ' '.should be_blank
+    " \r \n \t ".should be_blank
+  end
+
+  it 'should not be blank if it contains non-whitespace' do
+    ' a '.should_not be_blank
+  end
+end

data/spec/gorillib_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Gorillib" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,6 @@
+--exclude "spec"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--loadby random
+--format profile
+--backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'gorillib'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/spec/spec_tasks.rake

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'rake'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec

data/test/abstract_unit.rb

@@ -0,0 +1,25 @@
+ORIG_ARGV = ARGV.dup
+
+curr = File.expand_path(File.dirname(__FILE__))
+$:.unshift(curr) unless $:.include?('curr') || $:.include?(curr)
+lib  = File.expand_path("#{File.dirname(__FILE__)}/../lib")
+$:.unshift(lib) unless $:.include?('lib') || $:.include?(lib)
+
+require 'test/unit'
+
+def with_kcode(code)
+  if RUBY_VERSION < '1.9'
+    begin
+      old_kcode, $KCODE = $KCODE, code
+      yield
+    ensure
+      $KCODE = old_kcode
+    end
+  else
+    yield
+  end
+end
+
+if RUBY_VERSION < '1.9'
+  $KCODE = 'UTF8'
+end

data/test/array/compact_blank_test.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__)+'/../abstract_unit'
+require 'gorillib/array/compact_blank'
+
+class ArrayCompactBlankTests < Test::Unit::TestCase
+
+  def test_compact_blank_with_empty
+    [ [nil], [nil, false, {}, ""] ].each do |arr|
+      assert_equal([], arr.compact_blank)
+      assert_not_equal(0,  arr.length)
+    end
+  end
+
+  def test_compact_blank_bang_with_empty
+    assert_equal([], [].compact_blank!)
+    #
+    [ [nil], [nil, false, {}, ""] ].each do |arr|
+      assert_equal([], arr.compact_blank!)
+      assert_equal(0,  arr.length)
+    end
+  end
+
+  def test_compact_blank_with_full
+    [ [nil, 1, nil, 2], [nil, 1, false, 2, {}, ""] ].each do |arr|
+      assert_equal([1, 2], arr.compact_blank)
+    end
+  end
+
+  def test_compact_blank_bang_with_full
+    [ [nil, 1, nil, 2], [nil, 1, false, 2, {}, ""] ].each do |arr|
+      assert_equal([1, 2], arr.compact_blank!)
+    end
+  end
+end

data/test/array/extract_options_test.rb

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

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

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

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