utilrb 0.2.2 → 0.2.3

data/Changes.txt

@@ -1,3 +1,21 @@
+=== Version 0.2.3
+
+ * new features:
+    - BenchmarkAllocation, a Benchmark-like interface to benchmark object
+      allocation
+    - ValueSet#delete_if
+    - Time#from_hms takes a time as "h:m:s.ms" and builds the corresponding
+      Time object. Note that "s", "s.ms", "m:s", "m:s.ms", ... are accepted
+      formats
+
+ * changes and fixes:
+    - define Queue#get only if we are using Ruby's core Queue. The current
+      implementation is incompatible with fastthread for instance (and 
+      fastthhread's maintainer does not want #get on its Queue). Included
+      a patch to define Queue#get on fastthread
+    - fix ValueSet#== raising if the argument is not a ValueSet
+    - fix brain-dead SequenceEnumerator#+, which was changing its receiver
+
 === Version 0.2.2
 The "don't forget to bump version number" release. 0.2 was supposed to be 0.2.1
 

data/License.txt

@@ -1,4 +1,5 @@
-Copyright (c) The Regents of the University of California.
+Copyright (c) 2006-2007 LAAS/CNRS <openrobots@laas.fr>
+	      2006-2007 Sylvain Joyeux <sylvain.joyeux@laas.fr>
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/Manifest.txt

@@ -1,58 +1,61 @@
+Changes.txt
+License.txt
+Manifest.txt
+README.txt
+Rakefile
 bm/allocation.rb
 bm/speed.rb
-Changes.txt
 ext/extconf.rb
 ext/faster.cc
 ext/swap.cc
 ext/value_set.cc
+lib/utilrb.rb
 lib/utilrb/array.rb
 lib/utilrb/array/to_s.rb
 lib/utilrb/common.rb
+lib/utilrb/enumerable.rb
 lib/utilrb/enumerable/null.rb
 lib/utilrb/enumerable/random_element.rb
-lib/utilrb/enumerable.rb
 lib/utilrb/enumerable/sequence.rb
 lib/utilrb/enumerable/uniq.rb
-lib/utilrb/exception/full_message.rb
 lib/utilrb/exception.rb
-lib/utilrb/gc/force.rb
+lib/utilrb/exception/full_message.rb
 lib/utilrb/gc.rb
+lib/utilrb/gc/force.rb
 lib/utilrb/hash.rb
 lib/utilrb/hash/slice.rb
 lib/utilrb/hash/to_s.rb
 lib/utilrb/hash/to_sym_keys.rb
+lib/utilrb/kernel.rb
 lib/utilrb/kernel/arity.rb
 lib/utilrb/kernel/options.rb
 lib/utilrb/kernel/poll.rb
-lib/utilrb/kernel.rb
 lib/utilrb/kernel/require.rb
 lib/utilrb/kernel/swap.rb
+lib/utilrb/logger.rb
 lib/utilrb/logger/forward.rb
 lib/utilrb/logger/hierarchy.rb
-lib/utilrb/logger.rb
+lib/utilrb/module.rb
 lib/utilrb/module/ancestor_p.rb
 lib/utilrb/module/attr_enumerable.rb
 lib/utilrb/module/define_method.rb
 lib/utilrb/module/include.rb
 lib/utilrb/module/inherited_enumerable.rb
-lib/utilrb/module.rb
+lib/utilrb/object.rb
 lib/utilrb/object/address.rb
 lib/utilrb/object/attribute.rb
-lib/utilrb/object.rb
 lib/utilrb/object/singleton_class.rb
 lib/utilrb/objectstats.rb
-lib/utilrb/queue/get.rb
 lib/utilrb/queue.rb
-lib/utilrb.rb
+lib/utilrb/queue/get.rb
+lib/utilrb/set.rb
+lib/utilrb/set/to_s.rb
 lib/utilrb/time.rb
 lib/utilrb/time/to_hms.rb
-lib/utilrb/unbound_method/call.rb
 lib/utilrb/unbound_method.rb
+lib/utilrb/unbound_method/call.rb
 lib/utilrb/value_set.rb
-License.txt
-Manifest.txt
-Rakefile
-README.txt
+patches/fastthread-queue-get.patch
 test/test_array.rb
 test/test_config.rb
 test/test_enumerable.rb
@@ -63,4 +66,5 @@ test/test_misc.rb
 test/test_module.rb
 test/test_object.rb
 test/test_objectstats.rb
+test/test_time.rb
 test/test_unbound_method.rb

data/Rakefile

@@ -8,7 +8,7 @@ Hoe.new('utilrb', Utilrb::VERSION) do |p|
     p.summary = 'Yet another Ruby toolkit'
     p.description = p.paragraphs_of('README.txt', 3..6).join("\n\n")
     p.url         = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
-    p.changes     = p.paragraphs_of('Changes.txt', 0..1).join("\n\n")
+    p.changes     = p.paragraphs_of('Changes.txt', 0..2).join("\n\n")
 
     p.extra_deps << 'facets'
 end

data/ext/faster.cc

@@ -25,7 +25,11 @@ static VALUE enumerable_each_uniq(VALUE self)
     return self;
 }
 
-/* Returns true if +self+ is a singleton class */
+/* call-seq:
+ *  Kernel.is_singleton?(object)
+ *
+ * Returns true if +self+ is a singleton class 
+ */
 static VALUE kernel_is_singleton_p(VALUE self)
 {
     if (BUILTIN_TYPE(self) == T_CLASS && FL_TEST(self, FL_SINGLETON))

data/ext/value_set.cc

@@ -65,6 +65,27 @@ static VALUE value_set_each(VALUE self)
     }
     return self;
 }
+
+/* call-seq:
+ *  set.delete_if { |obj| ... }		=> set
+ *
+ * Deletes all objects for which the block returns true
+ */
+static VALUE value_set_delete_if(VALUE self)
+{
+    ValueSet& set = get_wrapped_set(self);
+    for (ValueSet::iterator it = set.begin(); it != set.end();)
+    {
+	// Increment before calling yield() so that 
+	// the current element can be deleted safely
+	ValueSet::iterator this_it = it++;
+	bool do_delete = RTEST(rb_yield(*this_it));
+	if (do_delete)
+	    set.erase(this_it);
+    }
+    return self;
+}
+
 /* call-seq:
  *  set.include?(value)	    => true or false
  *
@@ -198,6 +219,9 @@ static VALUE value_set_delete(VALUE vself, VALUE v)
 static VALUE value_set_equal(VALUE vself, VALUE vother)
 {
     ValueSet const& self  = get_wrapped_set(vself);
+    if (!rb_respond_to(vother, id_to_value_set))
+	return Qfalse;
+
     ValueSet const& other = get_wrapped_set(rb_funcall(vother, id_to_value_set, 0));
     return (self == other) ? Qtrue : Qfalse;
 }
@@ -285,6 +309,7 @@ extern "C" void Init_value_set()
     rb_define_method(cValueSet, "size", RUBY_METHOD_FUNC(value_set_size), 0);
     rb_define_method(cValueSet, "clear", RUBY_METHOD_FUNC(value_set_clear), 0);
     rb_define_method(cValueSet, "initialize_copy", RUBY_METHOD_FUNC(value_set_initialize_copy), 1);
+    rb_define_method(cValueSet, "delete_if", RUBY_METHOD_FUNC(value_set_delete_if), 0);
 }
 
 

data/lib/utilrb/array/to_s.rb

@@ -1,4 +1,6 @@
 class Array
+    # Displays arrays as [ a, b, [c, d], ... ] instead of the standard #join
+    # Unlike #inspect, it calls #to_s on the elements too
     def to_s
 	stack = (Thread.current[:array_to_s] ||= [])
 	if stack.include?(self)

data/lib/utilrb/common.rb

@@ -1,5 +1,5 @@
 module Utilrb
-    VERSION = "0.2.2" unless defined? Utilrb::VERSION
+    VERSION = "0.2.3" unless defined? Utilrb::VERSION
 
     unless defined? UTILRB_FASTER_MODE
 	if ENV['UTILRB_FASTER_MODE'] == 'no'

data/lib/utilrb/enumerable/null.rb

@@ -2,6 +2,8 @@
 # Kernel#null_enum
 class NullEnumerator
     def each; self end
+    def +(other); other end
+
     include Enumerable
 end
 

data/lib/utilrb/enumerable/random_element.rb

@@ -1,15 +1,23 @@
+class Array
+    # Returns a random element of the array
+    def random_element; self[rand(size)] end
+end
+
 module Enumerable
+    # Returns a random element in the enumerable. In the worst case scenario,
+    # it converts the enumerable into an array
     def random_element
-	if Array === self
-	    self[rand(size)]
-	elsif respond_to?(:to_ary)
+	if respond_to?(:to_ary)
 	    to_ary.random_element
 	elsif respond_to?(:size)
+	    return if size == 0
 	    element = rand(size)
 	    each_with_index { |e, i| return e if i == element }
-	    nil
+	    raise "something wrong here ..."
 	elsif respond_to?(:to_a)
 	    to_a.random_element
+	else
+	    raise ArgumentError, "cannot ue #random_element on this enumerable"
 	end
     end
 end

data/lib/utilrb/enumerable/sequence.rb

@@ -3,7 +3,6 @@ class SequenceEnumerator
     def initialize; @sequence = Array.new end
     # Adds +object+ at the back of the sequence
     def <<(object); @sequence << object; self end
-    alias :+ :<<
 
     def each
 	@sequence.each { |enum| enum.each { |o| yield(o) } } if block_given?

data/lib/utilrb/exception/full_message.rb

@@ -1,5 +1,21 @@
 
 class Exception
+    # Returns the full exception message, with backtrace, like the one we get from
+    # the Ruby interpreter when the program is aborted (well, almost like that)
+    #
+    # For instance,
+    #	def test
+    #	    raise RuntimeError, "this is a test"
+    #	rescue 
+    #	    puts $!.full_message
+    #	end
+    #	test
+    #
+    # displays
+    #
+    #   test.rb:3:in `test': this is a test (RuntimeError)
+    #         from test.rb:7
+    #
     def full_message
 	first, *remaining = backtrace
 	"#{first}: #{message} (#{self.class})\n\tfrom " + remaining.join("\n\tfrom ")

data/lib/utilrb/hash/to_s.rb

@@ -1,4 +1,6 @@
 class Hash
+    # Displays hashes as { a => A, b => B, ... } instead of the standard #join
+    # Unlike #inspect, it calls #to_s on the elements too
     def to_s
 	"{" << map { |k, v| "#{k} => #{v}" }.join(", ") << "}"
     end

data/lib/utilrb/hash/to_sym_keys.rb

@@ -1,4 +1,8 @@
 class Hash
+    # Returns a hash for which all keys have been converted to symbols (only
+    # valid for string/symbol keys of course)
+    #
+    #   { 'a' => 1, :b => '2' }.to_sym_keys => { :a => 1, :b => '2' }
     def to_sym_keys
 	inject({}) { |h, (k, v)| h[k.to_sym] = v; h }
     end

data/lib/utilrb/kernel/options.rb

@@ -5,6 +5,12 @@ module Kernel
     # arguments, with default value support. All option keys are
     # converted to symbols for consistency.
     #
+    # The following rules apply:
+    #	* if a hash is given, non-nil values are treated as default values.
+    #	* an array is equivalent to a hash where all values are 'nil'
+    #
+    # See #validate_options and #filter_and_validate_options
+    #
     # call-seq:
     #   filter_options(option, hash)       -> known, unknown
     #   filter_options(option, array)	   -> known, unknown
@@ -38,7 +44,7 @@ module Kernel
     # as an empty option hash, all keys are converted into symbols.
     #
     def validate_options(options, known_options)
-	opt, unknown = filter_options(options, known_options)
+	opt, unknown = Kernel.filter_options(options, known_options)
 	unless unknown.empty?
 	    not_valid = unknown.keys.map { |m| "'#{m}'" }.join(" ")
 	    raise ArgumentError, "unknown options #{not_valid}", caller(1)

data/lib/utilrb/object/attribute.rb

@@ -3,7 +3,7 @@ require 'utilrb/object/singleton_class'
 
 Utilrb.unless_faster do
     class Object
-	# :call-seq
+	# call-seq:
 	#   attribute :name => default_value
 	#   attribute(:name) { default_value }
 	#

data/lib/utilrb/object/singleton_class.rb

@@ -1,7 +1,18 @@
 require 'utilrb/object/address'
+
+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 has_singleton?; defined? @singleton_class end
+	# Returns the singleton class for this object
+	#
+	# 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
@@ -21,9 +32,15 @@ if RUBY_VERSION >= "1.9"
     end
 else
     class Object
-	def has_singleton?
-	    defined? @singleton_class
-	end
+	# 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

data/lib/utilrb/objectstats.rb

@@ -1,15 +1,23 @@
 require 'utilrb/gc/force'
+require 'utilrb/object/attribute'
 
 module ObjectStats
-    # Allocates no object
+    # The count of objects currently allocated
+    #
+    # It allocates no objects, which means that if
+    #	a = ObjectStats.count
+    #	b = ObjectStats.count
+    #	then a == b
     def self.count
         count = 0
-        ObjectSpace.each_object { |obj| count += 1}
+        ObjectSpace.each_object { |obj| count += 1 }
 
 	count
     end
 
-    # Allocates 1 Hash, which is included in the count
+    # Returns a klass => count hash counting the currently allocated objects
+    # 
+    # It allocates 1 Hash, which is included in the count
     def self.count_by_class
         by_class = Hash.new(0)
         ObjectSpace.each_object { |obj|
@@ -19,10 +27,19 @@ module ObjectStats
         by_class
     end
 
-    # Profiles the memory allocation in the block
-    # If alive is true, then only non-gcable objects
-    # are returned.
+    # Profiles how much objects has been allocated by the block. Returns a
+    # klass => count hash like count_by_class
+    #
+    # If alive is true, then only live objects are returned.
     def self.profile(alive = false)
+	if alive
+	    GC.force
+	    profile do
+		yield
+		GC.force
+	    end
+	end
+
         already_disabled = GC.disable
         before = count_by_class
         yield
@@ -34,19 +51,173 @@ module ObjectStats
             merge(after) { |klass, old, new| new - old }.
             delete_if { |klass, count| count == 0 }
     end
+end
 
-    def self.stats(filter = nil)
-        total_count = 0
-        output = ""
-        count_by_class.each do |klass, obj_count|
-            total_count += obj_count
-            if !filter || klass.name =~ filter
-                output << klass.name << " " << obj_count.to_s << "\n"
-            end
-        end
-        
-        (output << "Total object count: #{total_count}")
+# BenchmarkAllocation is a Benchmark-like interface to benchmark object allocation. 
+#
+# == Formatting
+# BenchmarkAllocation formats its output in two ways (see examples below)
+# * first, each part of a class path is displayed in its own line, to reduce
+#   the output width
+# * then, output is formatted so that it does not exceed
+#   BenchmarkAllocation::SCREEN_WIDTH width
+#
+#
+# == Examples
+#
+# For instance, 
+#
+#   require 'utilrb/objectstats'
+#   
+#   module Namespace
+#	class MyClass
+#	end
+#   end
+#
+#   BenchmarkAllocation.bm do |x|
+#       x.report("array") { Array.new }
+#       x.report("hash") { Hash.new }
+#       x.report("myclass") { MyClass.new }
+#   end
+#
+# will produce the output
+#
+#            Array  Hash  Namespace::
+#                             MyClass
+#     array      1     -            -
+#      hash      -     1            -
+#   myclass      -     -            1
+#  
+# Like Benchmark, a rehearsal benchmark method, BenchmarkAllocation.bmbm
+# is provided:
+#
+#   require 'utilrb/objectstats'
+#   require 'delegate'
+#   
+#   module Namespace
+#       class MyClass
+#       end
+#   end
+#   
+#   delegate_klass = nil
+#   BenchmarkAllocation.bmbm do |x|
+#       x.report("array") { Array.new }
+#       x.report("hash") { Hash.new }
+#       x.report("myclass") { Namespace::MyClass.new }
+#       x.report("delegate") do
+#   	delegate_klass ||= Class.new(DelegateClass(Namespace::MyClass)) do
+#   	    def self.name; "Delegate(MyClass)" end
+#   	end
+#   	delegate_klass.new(Namespace::MyClass.new)
+#       end
+#   end
+#
+# produces
+#
+#   Rehearsal --------------------------------------------------------------------------------
+#   
+#             Array  Class  Delegate(MyClass)  Hash  Namespace::  String
+#                                                        MyClass
+#      array      1      -                  -     -            -       -
+#       hash      -      -                  -     1            -       -
+#    myclass      -      -                  -     -            1       -
+#   delegate      5      2                  1     2            1     247
+#   ------------------------------------------------------------------------------------------
+#   
+#             Array  Delegate(MyClass)  Hash  Namespace::
+#                                                 MyClass
+#      array      1                  -     -            -
+#       hash      -                  -     1            -
+#    myclass      -                  -     -            1
+#   delegate      -                  1     -            1
+#   
+class BenchmarkAllocation
+    MARGIN       = 2
+    SCREEN_WIDTH = 90
+
+    def self.bm(label_width = nil)
+	yield(gather = new)
+	gather.format
     end
-end
+    def self.bmbm(label_width = nil)
+	yield(gather = new)
+
+	title = "Rehearsal"
+	puts title + " " + "-" * (SCREEN_WIDTH - title.length - 1)
+	gather.format
+	puts "-" * SCREEN_WIDTH
+
+	yield(gather = new)
+	gather.format
+    end
+
+    def format(screen_width = SCREEN_WIDTH, margin = MARGIN)
+	label_width ||= 0
+	column_names = profiles.inject([]) do |column_names, (label, profile)|
+	    label_width = label_width < label.length ? label.length : label_width
+	    column_names |= profile.keys
+	end.sort
 
+	# split at the :: to separate modules and klasses (reduce header sizes)
+	blocks = []
+	header, columns, current_width = nil
+	column_names.each_with_index do |name, col_index|
+	    splitted = name.gsub(/::/, "::\n").split("\n")
+	    width    = splitted.map { |part| part.length }.max + MARGIN
+
+	    if !current_width || (current_width + label_width + width > screen_width)
+		# start a new block
+		blocks << [[], []]
+		header, columns = blocks.last
+		current_width = 0
+	    end
+
+	    splitted.each_with_index do |part, line_index|
+		if !header[line_index]
+		    header[line_index] = columns.map { |_, w| " " * w }
+		end
+		header[line_index] << "% #{width}s" % [part]
+	    end
+	    # Pad the remaining lines
+	    header[splitted.size..-1].each_with_index do |line, index|
+		line << " " * width
+	    end
+
+	    columns << [name, width]
+	    current_width += width
+	end
+	    
+	blocks.each do |header, columns|
+	    puts
+	    header.each { |line| puts " " * label_width + line.join("") }
+
+	    profiles.each do |label, profile|
+		print "% #{label_width}s" % [label]
+		columns.each do |name, width|
+		    
+		    if count = profile[name] 
+			print "% #{width}i" % [profile[name] || 0]
+		    else
+			print " " * (width - 1) + "-"
+		    end
+		end
+		puts
+	    end
+	end
+    end
+
+    attribute(:profiles) { Array.new }
+    def report(label)
+	result = ObjectStats.profile do
+	    yield
+	end
+	result.inject({}) do |result, (klass, count)|
+	    klass = klass.name
+	    klass = "unknown" if !klass || klass.empty?
+	    result[klass] = count
+	    result
+	end
+	profiles << [label, result]
+    end
+end
 

data/lib/utilrb/queue/get.rb

@@ -1,17 +1,22 @@
 class Queue
-    # Returns all elements currently in the queue.
-    # If +non_block+ is true, returns an empty array
-    # if the queue is empty
-    def get(non_block = false)
-	while (Thread.critical = true; @que.empty?)
-	    return [] if non_block
-	    @waiting.push Thread.current
-	    Thread.stop
+    # Returns all elements currently in the queue.  If +non_block+ is true,
+    # returns an empty array if the queue is empty
+    #
+    # WARNING: this method is NOT compatible with fastthread's Queue implementation
+    # If you rely on Queue#get and want to use fastthread, you will have to patch
+    # fastthread with patches/fastthread-queue-get.patch
+    unless instance_methods.include?("get")
+	def get(non_block = false)
+	    while (Thread.critical = true; @que.empty?)
+		return [] if non_block
+		@waiting.push Thread.current
+		Thread.stop
+	    end
+	    result = @que.dup
+	    @que.clear
+	    result
+	ensure
+	    Thread.critical = false
 	end
-	result = @que.dup
-	@que.clear
-	result
-    ensure
-	Thread.critical = false
     end
 end

data/lib/utilrb/set.rb

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

data/lib/utilrb/set/to_s.rb

@@ -0,0 +1,7 @@
+require 'set'
+class Set
+    def to_s
+	"{ #{map { |o| o.to_s }.join(", ")} }"
+    end
+end
+

data/lib/utilrb/time/to_hms.rb

@@ -1,6 +1,38 @@
 class Time
+    # Converts this time into a h:m:s.ms representation
     def to_hms
 	sec, usec = tv_sec, tv_usec
 	"%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 =~ /(?:^|:)(\d+)(?:$|\.)/
+	    raise "invalid format #{string}"
+	end
+	hm, ms = $`, $'
+
+	s = Integer($1)
+	unless hm =~ /^(?:(\d*):)?(?:(\d*))?$/
+	    raise "invalid format #{string}. found #{hm}, expected nothing, m: or h:m:"
+	end
+	h, m = if $2.empty? then 
+		   if $1 then [0, Integer($1)]
+		   else [0, 0]
+		   end
+	       else [Integer($1), Integer($2)]
+	       end
+
+	ms = if ms.empty? then 0
+	     else
+		 unless ms =~ /^\d*$/
+		     raise "invalid format "#{string}"
+		 end
+		 ms += "0" * (3 - ms.size)
+		 Integer(ms)
+	     end
+
+	Time.at(Float(h * 3600 + m * 60 + s) + ms * 1.0e-3)
+    end
 end

data/patches/fastthread-queue-get.patch

@@ -0,0 +1,72 @@
+--- fastthread-0.6.2/ext/fastthread/fastthread.c	2007-01-25 12:09:54.956708000 +0100
++++ fastthread-0.6.2.new/ext/fastthread/fastthread.c	2007-01-25 11:49:49.151455000 +0100
+@@ -737,6 +737,61 @@ rb_queue_marshal_load(self, data)
+ 
+ static VALUE rb_queue_marshal_dump _((VALUE));
+ 
++
++/* call-seq:
++ *  Queue#get(non_block = false) => array
++ *
++ * Returns an array containing all elements currently in the queue. After a call
++ * to #get, the queue is empty. If non_block is false, the call will block until
++ * there is something in it. Otherwise, if the queue is empty, it returns an empty
++ * array.
++ */
++static VALUE
++rb_queue_get(argc, argv, self)
++  int argc;
++  VALUE *argv;
++  VALUE self;
++{
++  Queue *queue;
++  int should_block;
++  VALUE result;
++  Data_Get_Struct(self, Queue, queue);
++
++  if ( argc == 0 ) {
++    should_block = 1;
++  } else if ( argc == 1 ) {
++    should_block = !RTEST(argv[0]);
++  } else {
++    rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
++  }
++
++  lock_mutex(&queue->mutex);
++  if ( !queue->values.entries ) {
++    /* NOTE: locking is not needed to check if the queue is empty
++       since AFAIK C extensions are never preempted. I do as in #pop
++       where it is done.
++    */
++    if ( !should_block ) {
++      unlock_mutex(&queue->mutex);
++      return rb_ary_new();
++    }
++    while (!queue->values.entries) {
++      wait_condvar(&queue->value_available, &queue->mutex);
++    }
++  }
++
++  result = rb_ary_new();
++  while ( queue->values.entries ) {
++    rb_ary_push(result, shift_list(&queue->values));
++  }
++  if ( queue->capacity ) {
++    signal_condvar(&queue->space_available);
++  }
++  unlock_mutex(&queue->mutex);
++
++  return result;
++}
++
+ static VALUE
+ rb_queue_marshal_dump(self)
+   VALUE self;
+@@ -991,6 +1046,7 @@ static VALUE setup_classes(unused)
+   rb_define_method(rb_cQueue, "num_waiting", rb_queue_num_waiting, 0);
+   rb_define_method(rb_cQueue, "pop", rb_queue_pop, -1);
+   rb_define_method(rb_cQueue, "push", rb_queue_push, 1);
++  rb_define_method(rb_cQueue, "get", rb_queue_get, -1);
+   rb_alias(rb_cQueue, rb_intern("<<"), rb_intern("push"));
+   rb_alias(rb_cQueue, rb_intern("deq"), rb_intern("pop"));
+   rb_alias(rb_cQueue, rb_intern("shift"), rb_intern("pop"));

data/test/test_enumerable.rb

@@ -74,6 +74,7 @@ class TC_Enumerable < Test::Unit::TestCase
 	    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)
+	    assert(! (a == :bla)) # check #== behaves correctly with a non-enumerable
 
 	    a.delete(1)
 	    assert(! a.include?(1))
@@ -83,6 +84,8 @@ class TC_Enumerable < Test::Unit::TestCase
 	    assert([].to_value_set.empty?)
 
 	    assert([1, 2, 4, 3].to_value_set.clear.empty?)
+
+	    assert_equal([1,3,5].to_value_set, [1, 2, 3, 4, 5, 6].to_value_set.delete_if { |v| v % 2 == 0 })
 	end
     end
 end

data/test/test_objectstats.rb

@@ -3,17 +3,17 @@ require 'test_config'
 require 'utilrb/objectstats'
 
 class TC_ObjectStats < Test::Unit::TestCase
+    def teardown
+	GC.enable
+    end
+
+    def allocate_dead_hash; Hash.new; nil end
+
     def test_object_stats
 	assert( ObjectStats.profile { ObjectStats.count }.empty?, "Object allocation profile changed" )
 	assert_equal({ Hash => 1 }, ObjectStats.profile { ObjectStats.count_by_class }, "Object allocation profile changed")
 	assert_equal({ Array => 1 }, ObjectStats.profile { test = [] })
 	assert_equal({ Array => 2, Hash => 1 }, ObjectStats.profile { a, b = [], {} })
-
-	GC.start
-        GC.disable
-        Hash.new
-        assert([Hash, 1], ObjectStats.profile { Hash.new }.collect { |klass, count| [klass, count] })
-        assert([Hash, -1], ObjectStats.profile { GC.start }.collect { |klass, count| [klass, count] })
     end
 end
 

data/test/test_time.rb

@@ -0,0 +1,31 @@
+require 'test_config'
+require 'utilrb/time'
+
+class TC_Time < Test::Unit::TestCase
+    def test_to_hms
+	assert_equal("0:00:00.000", Time.at(0).to_hms)
+	assert_equal("0:00:00.100", Time.at(0.1).to_hms)
+	assert_equal("0:00:34.100", Time.at(34.1).to_hms)
+	assert_equal("0:21:34.100", Time.at(21 * 60 + 34.1).to_hms)
+	assert_equal("236:21:34.100", Time.at(236 * 3600 + 21 * 60 + 34.1).to_hms)
+    end
+    def test_from_hms
+	assert_equal(Time.at(0), Time.from_hms("0:00:00.000"))
+	assert_equal(Time.at(0.1), Time.from_hms("0:00:00.100"))
+	assert_equal(Time.at(34.1), Time.from_hms("0:00:34.100"))
+	assert_equal(Time.at(21 * 60 + 34.1), Time.from_hms("0:21:34.100"))
+	assert_equal(Time.at(236 * 3600 + 21 * 60 + 34.1), Time.from_hms("236:21:34.100"))
+
+	assert_equal(Time.at(0), Time.from_hms("0"))
+	assert_equal(Time.at(0), Time.from_hms(":0"))
+	assert_equal(Time.at(62), Time.from_hms("1:2"))
+	assert_equal(Time.at(3723), Time.from_hms("1:2:3"))
+
+	assert_equal(Time.at(0), Time.from_hms("0"))
+	assert_equal(Time.at(0), Time.from_hms("0."))
+	assert_in_delta(0, Time.at(1.2) - Time.from_hms("1.2"), 0.001)
+	assert_in_delta(0, Time.at(121.3) - Time.from_hms("2:1.3"), 0.001)
+	assert_in_delta(0, Time.at(3723.4) - Time.from_hms("1:2:3.4"), 0.001)
+    end
+end
+

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
+rubygems_version: 0.9.1
 specification_version: 1
 name: utilrb
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
-date: 2006-12-01 00:00:00 +01:00
+  version: 0.2.3
+date: 2007-01-30 00:00:00 +01:00
 summary: Yet another Ruby toolkit
 require_paths: 
 - lib
@@ -30,61 +30,64 @@ post_install_message:
 authors: 
 - Sylvain Joyeux
 files: 
+- Changes.txt
+- License.txt
+- Manifest.txt
+- README.txt
+- Rakefile
 - bm/allocation.rb
 - bm/speed.rb
-- Changes.txt
 - ext/extconf.rb
 - ext/faster.cc
 - ext/swap.cc
 - ext/value_set.cc
+- lib/utilrb.rb
 - lib/utilrb/array.rb
 - lib/utilrb/array/to_s.rb
 - lib/utilrb/common.rb
+- lib/utilrb/enumerable.rb
 - lib/utilrb/enumerable/null.rb
 - lib/utilrb/enumerable/random_element.rb
-- lib/utilrb/enumerable.rb
 - lib/utilrb/enumerable/sequence.rb
 - lib/utilrb/enumerable/uniq.rb
-- lib/utilrb/exception/full_message.rb
 - lib/utilrb/exception.rb
-- lib/utilrb/gc/force.rb
+- lib/utilrb/exception/full_message.rb
 - lib/utilrb/gc.rb
+- lib/utilrb/gc/force.rb
 - lib/utilrb/hash.rb
 - lib/utilrb/hash/slice.rb
 - lib/utilrb/hash/to_s.rb
 - lib/utilrb/hash/to_sym_keys.rb
+- lib/utilrb/kernel.rb
 - lib/utilrb/kernel/arity.rb
 - lib/utilrb/kernel/options.rb
 - lib/utilrb/kernel/poll.rb
-- lib/utilrb/kernel.rb
 - lib/utilrb/kernel/require.rb
 - lib/utilrb/kernel/swap.rb
+- lib/utilrb/logger.rb
 - lib/utilrb/logger/forward.rb
 - lib/utilrb/logger/hierarchy.rb
-- lib/utilrb/logger.rb
+- lib/utilrb/module.rb
 - lib/utilrb/module/ancestor_p.rb
 - lib/utilrb/module/attr_enumerable.rb
 - lib/utilrb/module/define_method.rb
 - lib/utilrb/module/include.rb
 - lib/utilrb/module/inherited_enumerable.rb
-- lib/utilrb/module.rb
+- lib/utilrb/object.rb
 - lib/utilrb/object/address.rb
 - lib/utilrb/object/attribute.rb
-- lib/utilrb/object.rb
 - lib/utilrb/object/singleton_class.rb
 - lib/utilrb/objectstats.rb
-- lib/utilrb/queue/get.rb
 - lib/utilrb/queue.rb
-- lib/utilrb.rb
+- lib/utilrb/queue/get.rb
+- lib/utilrb/set.rb
+- lib/utilrb/set/to_s.rb
 - lib/utilrb/time.rb
 - lib/utilrb/time/to_hms.rb
-- lib/utilrb/unbound_method/call.rb
 - lib/utilrb/unbound_method.rb
+- lib/utilrb/unbound_method/call.rb
 - lib/utilrb/value_set.rb
-- License.txt
-- Manifest.txt
-- Rakefile
-- README.txt
+- patches/fastthread-queue-get.patch
 - test/test_array.rb
 - test/test_config.rb
 - test/test_enumerable.rb
@@ -95,8 +98,10 @@ files:
 - test/test_module.rb
 - test/test_object.rb
 - test/test_objectstats.rb
+- test/test_time.rb
 - test/test_unbound_method.rb
 test_files: 
+- test/test_time.rb
 - test/test_misc.rb
 - test/test_module.rb
 - test/test_unbound_method.rb
@@ -120,20 +125,20 @@ requirements: []
 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: hoe
+  name: facets
   version_requirement: 
   version_requirements: !ruby/object:Gem::Version::Requirement 
     requirements: 
-    - - ">="
+    - - ">"
       - !ruby/object:Gem::Version 
-        version: 1.1.4
+        version: 0.0.0
     version: 
 - !ruby/object:Gem::Dependency 
-  name: facets
+  name: hoe
   version_requirement: 
   version_requirements: !ruby/object:Gem::Version::Requirement 
     requirements: 
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.0.0
+        version: 1.1.7
     version: