gorillib 0.0.7 → 0.0.8

data/test/metaprogramming/delegation_test.rb

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

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

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

data/test/object/blank_test.rb

@@ -1,22 +0,0 @@
-require File.dirname(__FILE__)+'/../abstract_unit'
-require 'gorillib/object/blank'
-
-class BlankTest < Test::Unit::TestCase
-  BLANK = [ EmptyTrue.new, nil, false, '', '   ', "  \n\t  \r ", [], {} ]
-  NOT   = [ EmptyFalse.new, Object.new, true, 0, 1, 'a', [nil], { nil => 0 } ]
-
-  def test_blank
-    BLANK.each { |v| assert v.blank?,  "#{v.inspect} should be blank" }
-    NOT.each   { |v| assert !v.blank?, "#{v.inspect} should not be blank" }
-  end
-
-  def test_present
-    BLANK.each { |v| assert !v.present?, "#{v.inspect} should not be present" }
-    NOT.each   { |v| assert v.present?,  "#{v.inspect} should be present" }
-  end
-
-  def test_presence
-    BLANK.each { |v| assert_equal nil, v.presence, "#{v.inspect}.presence should return nil" }
-    NOT.each   { |v| assert_equal v,   v.presence, "#{v.inspect}.presence should return self" }
-  end
-end

data/test/string/constantize_test.rb

@@ -1,30 +0,0 @@
-require File.dirname(__FILE__)+'/../abstract_unit'
-require File.dirname(__FILE__)+'/inflector_test_cases'
-require 'gorillib/string/constantize'
-
-module Ace
-  module Base
-    class Case
-    end
-  end
-end
-
-
-class InflectorTest < Test::Unit::TestCase
-  include InflectorTestCases
-
-  def test_constantize
-    assert_nothing_raised{ assert_equal Ace::Base::Case, "Ace::Base::Case".constantize }
-    assert_nothing_raised{ assert_equal Ace::Base::Case, "::Ace::Base::Case".constantize }
-    assert_nothing_raised{ assert_equal InflectorTest,   "InflectorTest".constantize }
-    assert_nothing_raised{ assert_equal InflectorTest,   "::InflectorTest".constantize }
-    assert_raise(NameError){ "UnknownClass"     .constantize }
-    assert_raise(NameError){ "An invalid string".constantize }
-    assert_raise(NameError){ "InvalidClass\n"   .constantize }
-  end
-
-  def test_constantize_does_lexical_lookup
-    assert_raise(NameError) { "Ace::Base::InflectorTest".constantize }
-  end
-
-end

data/test/string/human_test.rb

@@ -1,65 +0,0 @@
-require File.dirname(__FILE__)+'/../abstract_unit'
-require File.dirname(__FILE__)+'/inflector_test_cases'
-require 'gorillib/string/human'
-
-class InflectorTest < Test::Unit::TestCase
-  include InflectorTestCases
-
-  def test_titleize
-    MixtureToTitleCase.each do |before, titleized|
-      assert_equal(titleized, before.titleize)
-    end
-  end
-
-  MixtureToTitleCase.each do |before, titleized|
-    define_method "test_titleize_#{before}" do
-      assert_equal(titleized, before.titleize )
-    end
-  end
-
-  def test_humanize
-    UnderscoreToHuman.each do |underscored, human|
-      assert_equal(human, underscored.humanize )
-    end
-  end
-end
-
-class ArrayExtToSentenceTests < Test::Unit::TestCase
-  def test_plain_array_to_sentence
-    assert_equal "", [].to_sentence
-    assert_equal "one", ['one'].to_sentence
-    assert_equal "one and two", ['one', 'two'].to_sentence
-    assert_equal "one, two, and three", ['one', 'two', 'three'].to_sentence
-  end
-
-  def test_to_sentence_with_words_connector
-    assert_equal "one two, and three", ['one', 'two', 'three'].to_sentence(:words_connector => ' ')
-    assert_equal "one & two, and three", ['one', 'two', 'three'].to_sentence(:words_connector => ' & ')
-    assert_equal "onetwo, and three", ['one', 'two', 'three'].to_sentence(:words_connector => nil)
-  end
-
-  def test_to_sentence_with_last_word_connector
-    assert_equal "one, two, and also three", ['one', 'two', 'three'].to_sentence(:last_word_connector => ', and also ')
-    assert_equal "one, twothree", ['one', 'two', 'three'].to_sentence(:last_word_connector => nil)
-    assert_equal "one, two three", ['one', 'two', 'three'].to_sentence(:last_word_connector => ' ')
-    assert_equal "one, two and three", ['one', 'two', 'three'].to_sentence(:last_word_connector => ' and ')
-  end
-
-  def test_two_elements
-    assert_equal "one and two", ['one', 'two'].to_sentence
-    assert_equal "one two", ['one', 'two'].to_sentence(:two_words_connector => ' ')
-  end
-
-  def test_one_element
-    assert_equal "one", ['one'].to_sentence
-  end
-
-  def test_one_element_not_same_object
-    elements = ["one"]
-    assert_not_equal elements[0].object_id, elements.to_sentence.object_id
-  end
-
-  def test_one_non_string_element
-    assert_equal '1', [1].to_sentence
-  end
-end

data/test/string/inflections_test.rb

@@ -1,57 +0,0 @@
-require File.dirname(__FILE__)+'/../abstract_unit'
-require 'gorillib/string/inflections'
-require File.dirname(__FILE__)+'/inflector_test_cases'
-
-class InflectorTest < Test::Unit::TestCase
-  include InflectorTestCases
-
-  def test_camelize
-    CamelToUnderscore.each do |cameled, underscored|
-      assert_equal(cameled, underscored.camelize)
-    end
-  end
-
-  def test_camelize_with_lower_downcases_the_first_letter
-    assert_equal('capital', 'Capital'.camelize(:lower))
-  end
-
-  def test_snakeize
-    UnderscoreToLowerCamel.each do |underscored, snaked|
-      assert_equal(snaked, underscored.snakeize)
-    end
-  end
-
-  def test_underscore_to_lower_camel
-    UnderscoreToLowerCamel.each do |underscored, lower_cameled|
-      assert_equal(lower_cameled, underscored.camelize(:lower))
-    end
-  end
-
-  def test_underscore
-    CamelToUnderscore.each do |cameled, underscored|
-      assert_equal(underscored, cameled.underscore)
-    end
-    CamelToUnderscoreWithoutReverse.each do |cameled, underscored|
-      assert_equal(underscored, cameled.underscore)
-    end
-    assert_equal "html_tidy", "HTMLTidy".underscore
-    assert_equal "html_tidy_generator", "HTMLTidyGenerator".underscore
-  end
-
-  def test_camelize_with_module
-    CamelWithModuleToUnderscoreWithSlash.each do |cameled, underscored|
-      assert_equal(cameled, underscored.camelize)
-    end
-  end
-
-  def test_underscore_with_slashes
-    CamelWithModuleToUnderscoreWithSlash.each do |cameled, underscored|
-      assert_equal(underscored, cameled.underscore)
-    end
-  end
-
-  def test_demodulize
-    assert_equal "Account", "MyApplication::Billing::Account".demodulize
-  end
-
-end

data/test/string/truncate_test.rb

@@ -1,37 +0,0 @@
-# encoding: utf-8
-require File.dirname(__FILE__)+'/../abstract_unit'
-require File.dirname(__FILE__)+'/inflector_test_cases'
-require 'gorillib/string/truncate'
-
-class StringInflectionsTest < Test::Unit::TestCase
-  include InflectorTestCases
-
-  def test_truncate
-    assert_equal "Hello World!", "Hello World!".truncate(12)
-    assert_equal "Hello Wor...", "Hello World!!".truncate(12)
-  end
-
-  def test_truncate_with_omission_and_seperator
-    assert_equal "Hello[...]", "Hello World!".truncate(10, :omission => "[...]")
-    assert_equal "Hello[...]", "Hello Big World!".truncate(13, :omission => "[...]", :separator => ' ')
-    assert_equal "Hello Big[...]", "Hello Big World!".truncate(14, :omission => "[...]", :separator => ' ')
-    assert_equal "Hello Big[...]", "Hello Big World!".truncate(15, :omission => "[...]", :separator => ' ')
-  end
-
-  if RUBY_VERSION < '1.9.0'
-    def test_truncate_multibyte
-      with_kcode 'none' do
-        assert_equal "\354\225\210\353\205\225\355...", "\354\225\210\353\205\225\355\225\230\354\204\270\354\232\224".truncate(10)
-      end
-      with_kcode 'u' do
-        assert_equal "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 ...",
-          "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 \354\225\204\353\235\274\353\246\254\354\230\244".truncate(10)
-      end
-    end
-  else
-    def test_truncate_multibyte
-      assert_equal "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 ...".force_encoding('UTF-8'),
-        "\354\225\204\353\246\254\353\236\221 \354\225\204\353\246\254 \354\225\204\353\235\274\353\246\254\354\230\244".force_encoding('UTF-8').truncate(10)
-    end
-  end
-end