utilrb 1.1 → 1.2

data/lib/utilrb/kernel/swap.rb

@@ -1,2 +1,2 @@
 require 'utilrb/common'
-Utilrb.require_faster('Kernel#swap!')
+Utilrb.require_ext('Kernel#swap!')

data/lib/utilrb/logger/hierarchy.rb

@@ -1,5 +1,5 @@
-require 'facet/module/dirname'
-require 'facet/kernel/constant'
+require 'facets/module/spacename'
+require 'facets/kernel/constant'
 class Logger
     # Define a hierarchy of loggers mapped to the module hierarchy.
     # It defines the #logger accessor which either returns the logger
@@ -22,11 +22,11 @@ class Logger
         attr_writer :logger
         def logger
             return @logger if defined?(@logger) && @logger
-            if kind_of?(Module)
-                constant(self.dirname).logger
-            else
-                self.class.logger
-            end
+	    @logger = if kind_of?(Module)
+			  constant(self.spacename).logger
+		      else
+			  self.class.logger
+		      end
         end
     end
 end

data/lib/utilrb/module/ancestor_p.rb

@@ -1,6 +1,6 @@
 require 'utilrb/common'
 class Module
-    Utilrb.if_faster do
+    Utilrb.if_ext do
 	# Check if +klass+ is an ancestor of this class/module
 	#
 	# It works for singleton classes as well:
@@ -15,7 +15,7 @@ class Module
 	    self <= klass || (is_singleton? && superclass.has_ancestor?(klass))
 	end
     end
-    Utilrb.unless_faster do
+    Utilrb.unless_ext do
 	def has_ancestor?(klass) # :nodoc:
 	    self <= klass || superclass == klass || superclass < klass
 	end

data/lib/utilrb/module/define_or_reuse.rb

@@ -0,0 +1,29 @@
+class Module
+    if Utilrb::RUBY_IS_19
+        # :call-seq
+        #   define_or_reuse(name, value)   ->              value
+        #   define_or_reuse(name) { ... }  ->              value
+        #
+        # Defines a new constant under a given module, or reuse the
+        # already-existing value if the constant is already defined.
+        #
+        # In the first form, the method gets its value from its argument. 
+        # In the second case, it calls the provided block
+        def define_or_reuse(name, value = nil)
+            if const_defined?(name, false)
+                const_get(name)
+            else
+                const_set(name, (value || yield))
+            end
+        end
+    else
+        def define_or_reuse(name, value = nil)
+            if const_defined?(name)
+                const_get(name)
+            else
+                const_set(name, (value || yield))
+            end
+        end
+    end
+end
+

data/lib/utilrb/module/include.rb

@@ -1,5 +1,7 @@
 class Module
-    unless (method(:__instance_include__) rescue nil)
+    begin
+	method(:__instance_include__)
+    rescue NameError
 	alias :__instance_include__  :include
     end
 
@@ -12,19 +14,20 @@ class Module
     # * if it is included in a Class, the ClassExtension module
     #   extends the class.
     def include(mod)
-	__instance_include__ mod
-	return unless mod.const_defined?(:ClassExtension)
-
-	if is_a?(Module) && !is_a?(Class)
-	    unless const_defined?(:ClassExtension)
-		const_set(:ClassExtension, Module.new)
-	    end
-	    const_get(:ClassExtension).class_eval do
-		__instance_include__ mod.const_get(:ClassExtension)
+	if mod.const_defined?(:ClassExtension)
+	    if !is_a?(Class)
+		unless const_defined?(:ClassExtension)
+		    const_set(:ClassExtension, Module.new)
+		end
+		const_get(:ClassExtension).class_eval do
+		    __instance_include__ mod.const_get(:ClassExtension)
+		end
+	    else
+		extend mod.const_get(:ClassExtension)
 	    end
-	else
-	    extend mod.const_get(:ClassExtension)
 	end
+
+	__instance_include__ mod
     end
 end
 

data/lib/utilrb/module/inherited_enumerable.rb

@@ -14,6 +14,10 @@ class Module
         if options[:map]
             class_eval <<-EOF
             def each_#{name}(key = nil, uniq = true)
+	        if !block_given?
+	            return enum_for(:each_#{name}, key, uniq)
+		end
+
 		if key
 		    for klass in ancestors
 			if klass.instance_variable_defined?(:@#{attribute_name})

data/lib/utilrb/object/address.rb

@@ -5,10 +5,10 @@ class Object
     def address; Object.address_from_id(object_id) end
 
     # Converts the object_id of a non-immediate object
-    # to its 32 bits address
+    # to its memory address
     def self.address_from_id(id)
-	id = 0xFFFFFFFF - ~id if id < 0
-	(id * 2) & 0xFFFFFFFF
+	id = 0xFFFFFFFFFFFFFFFF - ~id if id < 0
+	(id * 2) & 0xFFFFFFFFFFFFFFFF
     end
 end
 

data/lib/utilrb/object/attribute.rb

@@ -1,7 +1,7 @@
 require 'utilrb/common'
 require 'utilrb/object/singleton_class'
 
-Utilrb.unless_faster do
+Utilrb.unless_ext do
     class Object
 	# call-seq:
 	#   attribute :name => default_value
@@ -37,7 +37,7 @@ Utilrb.unless_faster do
     end
 end
 
-Utilrb.if_faster do
+Utilrb.if_ext do
     class Object
 	def attribute(attr_def, &init) # :nodoc:
 	    if Hash === attr_def

data/lib/utilrb/object/singleton_class.rb

@@ -1,68 +1,61 @@
+require 'utilrb/common'
 require 'utilrb/object/address'
 
+class Class
+    unless method_defined?(:__ancestors__)
+	alias __ancestors__ ancestors
+    end
+
+    attr_reader :singleton_instance
+
+    Utilrb.require_ext("Object#ancestors") do
+        def ancestors
+            if is_singleton?
+                __ancestors__.unshift(self) 
+            else
+                __ancestors__
+            end
+        end
+    end
+end
+
 class Object
     # Returns true if this object has its own singleton class
     def has_singleton?; defined? @singleton_class end
 end
 
-if RUBY_VERSION >= "1.9"
-    class Object
-	def singleton_class # :nodoc:
-	    if defined? @singleton_class
-		return @singleton_class
-	    else
-		@singleton_class = class << self
-		    class << self
-			alias __ancestors__ ancestors # :nodoc:
-			def ancestors # :nodoc:
-			    __ancestors__.unshift(self) 
-			end
-		    end
-		    
-		    self 
-		end
+class Object
+    # Returns the singleton class for this object.
+    #
+    # In Ruby 1.8, makes sure that the #superclass method of the singleton class 
+    # returns the object's class (instead of Class), as Ruby 1.9 does
+    #
+    # The first element of #ancestors on the returned singleton class is
+    # the singleton class itself. A #singleton_instance accessor is also
+    # defined, which returns the object instance the class is the singleton
+    # of.
+    def singleton_class
+	unless defined? @singleton_class
+	    klass = class << self; self end
+	    klass.instance_variable_set(:@singleton_instance, self)
+	    @singleton_class = klass
 
-		@singleton_class
-	    end
-	end
-    end
-else
-    class Object
-	# Returns the singleton class for this object.
-	#
-	# In Ruby 1.8, makes sure that the #superclass method of the singleton class 
-	# returns the object's class (instead of Class), as Ruby 1.9 does
-	#
-	# The first element of #ancestors on the returned singleton class is
-	# the singleton class itself. A #singleton_instance accessor is also
-	# defined, which returns the object instance the class is the singleton
-	# of.
-	def singleton_class
-	    if defined? @singleton_class
-		return @singleton_class
-	    else
-		klass = class << self; self end
+	    unless Utilrb::RUBY_IS_19
 		instance = self
 		klass.class_eval do
-		    @singleton_instance = instance
-		    @superclass		= instance.class
+		    @superclass = instance.class
 		    class << self
 			attr_reader :superclass
-			attr_reader :singleton_instance
 			def name
-			    "#{@superclass.name}!0x#{@singleton_instance.address.to_s(16)}"
-			end
-
-			alias __ancestors__ ancestors # :nodoc:
-			def ancestors # :nodoc:
-			    __ancestors__.unshift(self) 
+			    "#{superclass.name}!0x#{@singleton_instance.address.to_s(16)}"
 			end
 		    end
 		end
-
-		@singleton_class = klass
 	    end
+	    klass
 	end
+
+	@singleton_class
     end
 end
 

data/lib/utilrb/socket/tcp_server.rb

@@ -0,0 +1,7 @@
+require 'socket'
+
+class TCPServer
+    def bound_addr; Socket::getnameinfo(getsockname)[0] end
+    def port; Socket::getnameinfo(getsockname)[1].to_i end
+end
+

data/lib/utilrb/socket/tcp_socket.rb

@@ -0,0 +1,7 @@
+
+class TCPSocket
+    def peer_info; Socket::getnameinfo(getpeername) end
+    def peer_addr; Socket::getnameinfo(getpeername)[0] end
+    def peer_port; Socket::getnameinfo(getpeername)[1] end
+end
+

data/lib/utilrb/time/to_hms.rb

@@ -5,37 +5,52 @@ class Time
 	"%i:%02i:%02i.%03i" % [sec / 3600, (sec % 3600) / 60, sec % 60, usec / 1000]
     end
 
-    # Creates a Time object from a h:m:s.ms representation. The following formats are allowed:
-    # s, s.ms, m:s, m:s.ms, h:m:s, h:m:s.ms
-    def self.from_hms(string)
-	unless string =~ /(?:^|:)0*(\d*)(?:$|\.)/
+    def self.hms_decomposition(string)
+	unless string =~ /(?:^|:)0*(\d*)(?:$|\.(\d*)$)/
 	    raise ArgumentError, "#{string} found, expected [[h:]m:]s[.ms]"
 	end
-	hm, ms = $`, $'
+	hm, ms = $`, ($2 || "")
 
 	s = if $1.empty? then 0
 	    else Integer($1)
 	    end
 
-	unless hm =~ /^(?:0*(\d*):)?(?:0*(\d*))?$/
-	    raise ArgumentError, "found #{hm}, expected nothing, m: or h:m:"
+	h, m = hm.split(':')
+	if !m
+	    h, m = nil, h
 	end
 
-	h, m = if (!$1 || $1.empty?) && $2.empty? then [0, 0]
-	       elsif (!$1 || $1.empty?) then [0, Integer($2)]
-	       elsif $2.empty? then [0, Integer($1)]
-	       else
-		   [Integer($1), Integer($2)]
-	       end
+	if m
+	    m =~ /^0*(\d*)$/
+	    m = $1
+	end
+	m = if !m || m.empty? then 0
+	    else Integer(m)
+	    end
+
+	if h
+	    h =~ /^0*(\d*)$/
+	    h = $1
+	end
+	h = if !h || h.empty? then 0
+	    else Integer(h)
+	    end
 
 	ms = if ms =~ /^0*$/ then 0
 	     else
-		 unless ms =~ /^(0*)([1-9]+)0*$/
+		 unless ms =~ /^(0*)(\d+)$/
 		     raise ArgumentError, "found #{string}, expected a number"
 		 end
-		 Integer($2) * (10 ** (2 - $1.length))
+		 Integer($2) * (10 ** (3 - ($2.length + $1.length)))
 	     end
 
-	Time.at(Float(h * 3600 + m * 60 + s) + ms * 1.0e-3)
+	[h, m, s, ms]
+    end
+
+    # Creates a Time object from a h:m:s.ms representation. The following formats are allowed:
+    # s, s.ms, m:s, m:s.ms, h:m:s, h:m:s.ms
+    def self.from_hms(string)
+	h, m, s, ms = *hms_decomposition(string)
+	Time.at(h * 3600 + m * 60 + s, 1000 * ms)
     end
 end

data/lib/utilrb/value_set.rb

@@ -1,7 +1,7 @@
 require 'utilrb/common'
 require 'utilrb/enumerable/to_s_helper'
 
-Utilrb.require_faster("ValueSet") do
+Utilrb.require_ext("ValueSet") do
     class ValueSet
 	def <<(obj); insert(obj) ; self end
 	alias :| :union

data/test/test_dir.rb

@@ -0,0 +1,22 @@
+require 'test_config'
+
+require 'utilrb/dir'
+require 'enumerator'
+
+class TC_Dir < Test::Unit::TestCase
+    def test_empty
+	this_dir = File.dirname(__FILE__)
+	assert(!Dir.new(this_dir).empty?)
+
+	begin
+	    Dir.mkdir(test_dir_path = File.join(this_dir, 'test_empty') )
+	rescue Errno::EEXIST
+	end
+
+	test_dir = Dir.new(test_dir_path)
+	assert(test_dir.empty?)
+    ensure
+	Dir.delete(test_dir_path) if test_dir_path
+    end
+end
+

data/test/test_enumerable.rb

@@ -54,13 +54,13 @@ class TC_Enumerable < Test::Unit::TestCase
 	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]
+	set = Hash[*(1..100).map { |i| [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
+    Utilrb.require_ext('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

data/test/test_kernel.rb

@@ -45,7 +45,7 @@ class TC_Kernel < Test::Unit::TestCase
 	assert_nothing_raised { check_arity(object.method(:arity_1_more), 2) }
     end
 
-    Utilrb.require_faster('is_singleton?') do
+    Utilrb.require_ext('is_singleton?') do
 	def test_is_singleton
 	    klass = Class.new
 	    singl_klass = (class << klass; self end)
@@ -57,7 +57,7 @@ class TC_Kernel < Test::Unit::TestCase
 	end
     end
 
-    Utilrb.require_faster('test_swap') do
+    Utilrb.require_ext('test_swap') do
 	def test_swap
 	    obj = Array.new
 	    Kernel.swap!(obj, Hash.new)

data/test/test_module.rb

@@ -7,20 +7,26 @@ require 'utilrb/module'
 
 class TC_Module < Test::Unit::TestCase
     def test_include
-	class_extension = Module.new do
-	    def tag; end
-	end
+        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
 
-	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))
+    def test_define_or_reuse
+	mod = Module.new
+	new_mod = mod.define_or_reuse(:Foo) { Module.new }
+	assert_equal(new_mod, mod.define_or_reuse(:Foo) { flunk("block called in #define_under") })
     end
 
     def test_define_method_with_block
@@ -43,31 +49,31 @@ class TC_Module < Test::Unit::TestCase
     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 )
+        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)
+        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
@@ -87,7 +93,9 @@ class TC_Module < Test::Unit::TestCase
 	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)
+        Utilrb.if_ext do
+            assert_equal([:in_singleton, :in_derived, :in_base], object.singleton_class.enum_for(:each_signature).to_a)
+        end
     end
 
     def check_inherited_enumerable(base, derived)
@@ -125,23 +133,23 @@ class TC_Module < Test::Unit::TestCase
     end
 
     def test_has_ancestor
-	mod       = Module.new
-	parent    = Class.new do
-	    include mod
-	end
-	child     = Class.new(parent)
-	singleton = child.new.singleton_class
-
-	assert(child.has_ancestor?(parent))
-	assert(child.has_ancestor?(mod))
-	assert(parent.has_ancestor?(mod))
-
-	assert(singleton.has_ancestor?(parent), singleton.superclass)
-	assert(singleton.has_ancestor?(mod))
-	assert(singleton.has_ancestor?(child))
-
-	assert(!parent.has_ancestor?(child))
-	assert(!parent.has_ancestor?(singleton))
+        mod       = Module.new
+        parent    = Class.new do
+            include mod
+        end
+        child     = Class.new(parent)
+        singleton = child.new.singleton_class
+
+        assert(child.has_ancestor?(parent))
+        assert(child.has_ancestor?(mod))
+        assert(parent.has_ancestor?(mod))
+
+        assert(singleton.has_ancestor?(parent), singleton.superclass)
+        assert(singleton.has_ancestor?(mod))
+        assert(singleton.has_ancestor?(child))
+
+        assert(!parent.has_ancestor?(child))
+        assert(!parent.has_ancestor?(singleton))
     end
 end