utilrb 0.2

data/lib/utilrb/time/to_hms.rb

@@ -0,0 +1,6 @@
+class Time
+    def to_hms
+	sec, usec = tv_sec, tv_usec
+	"%i:%02i:%02i.%03i" % [sec / 3600, (sec % 3600) / 60, sec % 60, usec / 1000]
+    end
+end

data/lib/utilrb/unbound_method.rb

@@ -0,0 +1,2 @@
+require 'utilrb/kernel/require'
+require_dir(__FILE__)

data/lib/utilrb/unbound_method/call.rb

@@ -0,0 +1,5 @@
+class UnboundMethod
+    def call(obj, *args, &block)
+	bind(obj).call(*args, &block)
+    end
+end

data/lib/utilrb/value_set.rb

@@ -0,0 +1,17 @@
+require 'utilrb/common'
+
+Utilrb.require_faster("ValueSet") do
+    class ValueSet
+	def <<(obj); insert(obj) ; self end
+	alias :| :union
+	alias :& :intersection
+	alias :- :difference
+	include Enumerable
+
+	def to_s
+	    base = super[0..-2]
+	    "#{base} { #{to_a.map { |o| o.to_s }.join(", ")} }"
+	end
+	alias :inspect :to_s
+    end
+end

data/test/test_array.rb

@@ -0,0 +1,9 @@
+require 'test_config'
+require 'utilrb/array'
+
+class TC_Array < Test::Unit::TestCase
+    def test_to_s
+	assert_equal("1, 2", [1, 2].to_s)
+    end
+end
+

data/test/test_config.rb

@@ -0,0 +1,4 @@
+require 'test/unit'
+$LOAD_PATH.unshift File.expand_path('../lib', File.dirname(__FILE__))
+BASE_TEST_DIR=File.expand_path(File.dirname(__FILE__)) unless defined? BASE_TEST_DIR
+

data/test/test_enumerable.rb

@@ -0,0 +1,89 @@
+require 'test_config'
+
+require 'utilrb/enumerable'
+require 'utilrb/value_set'
+
+class TC_Enumerable < Test::Unit::TestCase
+
+    def test_enum_uniq
+        # Test the enum_uniq enumerator
+        assert_equal([:a, :b, :c], [:a, :b, :a, :c].enum_uniq { |k| k }.to_a)
+        assert_equal([:a, :b, :c], [:a, :b, :a, :c].enum_uniq.to_a)
+	enum = [:a, :b, :a, :c].enum_uniq
+	assert_equal(enum, enum.each)
+	
+        a, b, c, d = [1, 2], [1, 3], [2, 3], [3, 4]
+
+        test = [a, b, c, d]
+        assert_equal([a, c, d], test.enum_uniq { |x, y| x }.to_a)
+        assert_equal([a, b, d], test.enum_uniq { |x, y| y }.to_a)
+
+	klass = Class.new do
+	    def initialize(base); @base = base end
+	    def each(&iterator);  @base.each { |x, y| yield [x, y] } end
+	    include Enumerable
+	end
+	test = klass.new(test)
+        assert_equal([a, c, d], test.enum_uniq { |x, y| x }.to_a)
+        assert_equal([a, b, d], test.enum_uniq { |x, y| y }.to_a)
+
+        klass = Struct.new :x, :y
+	test = test.map { |x, y| klass.new(x, y) }
+        a, b, c, d = *test
+        assert_equal([a, c, d], [a, b, c, d].enum_uniq { |v| v.x }.to_a)
+        assert_equal([a, b, d], [a, b, c, d].enum_uniq { |v| v.y }.to_a)
+    end
+    
+    def test_each_uniq
+        assert_equal([:a, :b, :c], [:a, :b, :a, :c].enum_for(:each_uniq).to_a)
+    end
+
+    def test_enum_sequence
+	c1 = [:a, :b, :c]
+	c2 = [:d, :e, :f]
+	assert_equal([:a, :b, :c, :d, :e, :f], (c1.to_enum + c2.to_enum).to_a)
+	assert_equal([:a, :b, :c, :d, :e, :f], [c1, c2].inject(null_enum) { |a, b| a + b }.to_a)
+    end
+
+    def test_random_element
+	# Test on arrays
+	set = (1..100).to_a
+	100.times { set.delete(set.random_element) }
+	assert(set.empty?)
+	assert_equal(nil, [].random_element)
+
+	# Test on non-empty collection which defines #size
+	set = Hash[*(1..100).map { |i| [(?a + i).to_s, i] }.flatten]
+	100.times { set.delete(set.random_element.first) }
+	assert(set.empty?)
+	assert_equal(nil, {}.random_element)
+    end
+
+    Utilrb.require_faster('test_value_set') do
+	def test_value_set
+	    a = [1, 3, 3, 4, 6, 8].to_value_set
+	    b = [1, 2, 4, 3, 11, 11].to_value_set
+	    assert_equal(5, a.size)
+	    assert_equal([1, 3, 4, 6, 8], a.to_a)
+	    assert(a.include?(1))
+	    assert(a.include_all?([4, 1, 8]))
+	    assert(!a.include_all?(b))
+
+	    assert(a.object_id == a.to_value_set.object_id)
+
+	    assert_equal([1, 2, 3, 4, 6, 8, 11], (a.union(b)).to_a)
+	    assert_equal([1, 3, 4], (a.intersection(b)).to_a)
+	    assert_equal([6, 8], (a.difference(b)).to_a)
+
+	    a.delete(1)
+	    assert(! a.include?(1))
+	    a.merge(b);
+	    assert_equal([1, 2, 3, 4, 6, 8, 11].to_value_set, a)
+
+	    assert([].to_value_set.empty?)
+
+	    assert([1, 2, 4, 3].to_value_set.clear.empty?)
+	end
+    end
+end
+

data/test/test_gc.rb

@@ -0,0 +1,39 @@
+require 'test_config'
+
+require 'utilrb/gc'
+require 'enumerator'
+
+class TC_GC < Test::Unit::TestCase
+    def allocate(&block)
+	ObjectSpace.define_finalizer(Object.new, &block)
+	nil
+    end
+
+    def allocate(&block)
+	# Allocate twice since it seems the last object stays on stack
+	# (and is not GC'ed)
+	2.times { ObjectSpace.define_finalizer(Object.new, &block) }
+	nil
+    end
+
+    def test_force
+	finalized = false
+	allocate { finalized = true }
+	GC.start
+	assert( finalized )
+
+	GC.disable
+	finalized = false
+	allocate { finalized = true }
+	GC.start
+	assert( !finalized )
+	GC.force
+	assert( finalized )
+	assert( GC.disable )
+
+	GC.enable
+	GC.force
+	assert( !GC.enable )
+    end
+end
+

data/test/test_hash.rb

@@ -0,0 +1,22 @@
+require 'test_config'
+require 'enumerator'
+require 'set'
+
+require 'utilrb/hash'
+
+class TC_Hash < Test::Unit::TestCase
+    def test_slice
+	test = { :a => 1, :b => 2, :c => 3 }
+	assert_equal({:a => 1, :c => 3}, test.slice(:a, :c))
+	assert_equal({:a => 1, :c => 3}, test.slice(:a, :c, :d))
+    end
+
+    def test_to_sym_keys
+	assert_equal({ :a => 10, :b => 20, :c => 30 }, { 'a' => 10, 'b' => 20, :c => 30 }.to_sym_keys)
+    end
+
+    def test_to_s
+	assert_equal("1 => 2, 2 => 3", { 1 => 2, 2 => 3 }.to_s)
+    end
+end
+

data/test/test_kernel.rb

@@ -0,0 +1,70 @@
+require 'test_config'
+
+require 'utilrb/kernel/options'
+require 'utilrb/kernel/arity'
+require 'utilrb/kernel/swap'
+
+class TC_Kernel < Test::Unit::TestCase
+    def test_validate_options
+        valid_options   = [ :a, :b, :c ]
+        valid_test      = { :a => 1, :c => 2 }
+        invalid_test    = { :k => nil }
+        assert_nothing_raised(ArgumentError) { validate_options(valid_test, valid_options) }
+        assert_raise(ArgumentError) { validate_options(invalid_test, valid_options) }
+
+        check_array = validate_options( valid_test, valid_options )
+        assert_equal( valid_test, check_array )
+        check_empty_array = validate_options( nil, valid_options )
+        assert_equal( {}, check_empty_array )
+
+	# Check default value settings
+        default_values = { :a => nil, :b => nil, :c => nil, :d => 15, :e => [] }
+        new_options = nil
+        assert_nothing_raised(ArgumentError) { new_options = validate_options(valid_test, default_values) }
+	assert_equal(15, new_options[:d])
+	assert_equal([], new_options[:e])
+        assert( !new_options.has_key?(:b) )
+    end
+
+    def test_arity
+	object = Class.new do
+	    def arity_1(a); end
+	    def arity_any(*a); end
+	    def arity_1_more(a, *b); end
+	end.new
+
+	assert_nothing_raised { check_arity(object.method(:arity_1), 1) }
+	assert_raises(ArgumentError) { check_arity(object.method(:arity_1), 0) }
+	assert_raises(ArgumentError) { check_arity(object.method(:arity_1), 2) }
+
+	assert_nothing_raised { check_arity(object.method(:arity_any), 0) }
+	assert_nothing_raised { check_arity(object.method(:arity_any), 2) }
+
+	assert_nothing_raised { check_arity(object.method(:arity_1_more), 1) }
+	assert_raises(ArgumentError) { check_arity(object.method(:arity_1_more), 0) }
+	assert_nothing_raised { check_arity(object.method(:arity_1_more), 2) }
+    end
+
+    Utilrb.require_faster('is_singleton?') do
+	def test_is_singleton
+	    klass = Class.new
+	    singl_klass = (class << klass; self end)
+	    obj = klass.new
+
+	    assert(!klass.is_singleton?)
+	    assert(!obj.is_singleton?)
+	    assert(singl_klass.is_singleton?)
+	end
+    end
+
+    Utilrb.require_faster('test_swap') do
+	def test_swap
+	    obj = Array.new
+	    Kernel.swap!(obj, Hash.new)
+	    assert_instance_of Hash, obj
+
+	    GC.start
+	end
+    end
+end
+

data/test/test_misc.rb

@@ -0,0 +1,42 @@
+require 'test_config'
+
+class TC_Misc < Test::Unit::TestCase
+    def test_super_idiom
+	base = Class.new do
+	    attr_reader :base
+	    def initialize
+		super if defined? super
+		@base = true
+	    end
+	end
+	assert_nothing_raised { base.new }
+
+	derived = Class.new(base) do
+	    attr_reader :derived
+	    def initialize
+		super if defined? super
+		@derived = true
+	    end
+	end
+	obj = nil
+	assert_nothing_raised { obj = derived.new }
+	assert( obj.base )
+	assert( obj.derived )
+
+	mod = Module.new do
+	    attr_reader :module
+	    def initialize
+		super if defined? super
+		@module = true
+	    end
+	end
+	obj = nil
+	base.class_eval { include mod }
+
+	assert_nothing_raised { obj = derived.new }
+	assert( obj.base )
+	assert( obj.module )
+	assert( obj.derived )
+    end
+end
+

data/test/test_module.rb

@@ -0,0 +1,127 @@
+require 'test_config'
+
+require 'flexmock'
+require 'set'
+require 'enumerator'
+require 'utilrb/module'
+
+class TC_Module < Test::Unit::TestCase
+    def test_include
+	class_extension = Module.new do
+	    def tag; end
+	end
+
+	m = Module.new do
+	    const_set(:ClassExtension, class_extension)
+	end
+	
+	m2 = Module.new { include m }
+	assert(m2::ClassExtension.method_defined?(:tag))
+	k = Class.new do
+	    include m2
+	end
+	assert(k.respond_to?(:tag))
+    end
+
+    def test_define_method_with_block
+	FlexMock.use do |mock|
+	    mock.should_receive(:called).once
+	    block_obj = lambda { mock.called }
+	    test_obj = self
+	    method = lambda do |block, a, b|
+		test_obj.assert_equal(a, 1)
+		test_obj.assert_equal(b, 2)
+		test_obj.assert_equal(block, block_obj)
+		block_obj.call
+	    end
+
+	    klass = Class.new do
+		define_method_with_block(:call, &method)
+	    end
+	    klass.new.call(1, 2, &block_obj)
+	end
+    end
+
+    def test_attr_enumerable
+	klass = Class.new do
+	    attr_enumerable(:mapped, :map) { Hash.new }
+	end
+
+	obj = klass.new
+	obj.map[:a] = [10, 20]
+	obj.map[:b] = 10
+	assert_equal( [[:a, [10, 20]], [:b, 10]].to_set, obj.enum_for(:each_mapped).to_set )
+	assert_equal( [10, 20], obj.enum_for(:each_mapped, :a).to_a )
+    end
+
+    def test_inherited_enumerable_module
+	m = Module.new do
+	    inherited_enumerable(:signature, :signatures) { Array.new }
+	end
+	k = Class.new do
+	    include m
+	    inherited_enumerable(:child_attribute) { Array.new }
+	end
+
+	# Add another attribute *after* k has been defined
+	m.class_eval do
+	    inherited_enumerable(:mapped, :map, :map => true) { Hash.new }
+	end
+	check_inherited_enumerable(m, k)
+    end
+
+    def test_inherited_enumerable_class
+	a = Class.new do
+	    inherited_enumerable(:signature, :signatures) { Array.new }
+	    inherited_enumerable(:mapped, :map, :map => true) { Hash.new }
+	end
+	b = Class.new(a) do
+	    include Module.new # include an empty module between a and b to check that the module
+			       # is skipped transparently
+	    inherited_enumerable(:child_attribute) { Array.new }
+	end
+	check_inherited_enumerable(a, b)
+	
+	# Test for singleton class support
+	object = b.new
+	assert(object.singleton_class.respond_to?(:signatures))
+	object.singleton_class.signatures << :in_singleton
+	assert_equal([:in_singleton], object.singleton_class.signatures)
+        assert_equal([:in_singleton, :in_derived, :in_base], object.singleton_class.enum_for(:each_signature).to_a)
+    end
+
+    def check_inherited_enumerable(base, derived)
+	assert(base.respond_to?(:each_signature))
+	assert(base.respond_to?(:signatures))
+	assert(!base.respond_to?(:has_signature?))
+	assert(!base.respond_to?(:find_signatures))
+
+	assert(base.respond_to?(:each_mapped))
+	assert(base.respond_to?(:map))
+	assert(base.respond_to?(:has_mapped?))
+
+        base.signatures << :in_base
+        base.map[:base] = 10
+        base.map[:overriden] = 20
+        assert_equal([:in_base], base.enum_for(:each_signature).to_a)
+        assert_equal([10].to_set, base.enum_for(:each_mapped, :base, false).to_set)
+
+	assert(!base.respond_to?(:child_attribute))
+	assert(!base.respond_to?(:each_child_attribute))
+	assert(derived.respond_to?(:child_attribute))
+	assert(derived.respond_to?(:each_child_attribute))
+
+        derived.signatures << :in_derived
+
+        derived.map[:overriden] = 15
+        derived.map[:derived] = 25
+
+        assert_equal([:in_derived, :in_base], derived.enum_for(:each_signature).to_a)
+        assert_equal([20, 15].to_set, derived.enum_for(:each_mapped, :overriden, false).to_set)
+        assert_equal([15].to_set, derived.enum_for(:each_mapped, :overriden, true).to_set)
+        assert_equal([25].to_set, derived.enum_for(:each_mapped, :derived).to_set)
+        assert_equal([[:base, 10], [:overriden, 20], [:overriden, 15], [:derived, 25]].to_set, derived.enum_for(:each_mapped, nil, false).to_set)
+        assert_equal([[:base, 10], [:overriden, 15], [:derived, 25]].to_set, derived.enum_for(:each_mapped, nil, true).to_set)
+    end
+end
+