utilrb 1.3.2 → 1.3.3

data/History.txt

@@ -1,12 +1,22 @@
-=== Version 1.3.1
+=== Version 1.3.3
+
+* fixed a problem with WeakRef crashing on 1.8.7p172. This version of weakref
+  should now work on every versions of 1.8.6 and 1.8.7
+* made ColumnFormatter more configurable
+* made the Rakefile callable with ruby's binaries that are not called 'ruby'
+
+=== Version 1.3.2
 
 * make utilrb depend only on standard C++, no boost
-* make the Rakefile not depend on the availability of Hoe
+
+=== Version 1.3.1
+
+* quickfix release: update the Manifest file for Hoe
 
 === Version 1.3
 
 * added Utilrb::WeakRef, a much leaner version of the standard WeakRef:
-  implemented in C++, not a subclass of Delegate (delegate is very costly)
+  implemented in C++, not a subclass of Delegate (delegate is very costly).
 
 === Version 1.2
 

data/Rakefile

@@ -20,11 +20,10 @@ begin
 
         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.url         = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1].map { |l| l.strip }
         p.changes     = p.paragraphs_of('History.txt', 0..1).join("\n\n")
 
         p.extra_deps << ['facets', '>= 2.4.0'] << 'rake'
-        p.rdoc_pattern = /(ext\/.*cc$|lib)|txt/
     end
     config.spec.extensions << 'ext/extconf.rb'
 rescue LoadError
@@ -34,10 +33,11 @@ rescue Exception => e
     STDERR.puts "error message is: #{e.message}"
 end
 
+RUBY = RbConfig::CONFIG['RUBY_INSTALL_NAME']
 desc "builds Utilrb's C extension"
 task :setup do
     Dir.chdir("ext") do
-	if !system("ruby extconf.rb") || !system("make")
+	if !system("#{RUBY} extconf.rb") || !system("make")
 	    raise "cannot build the C extension"
 	end
     end

data/ext/extconf.rb

@@ -2,7 +2,7 @@ require 'mkmf'
 
 CONFIG['CC'] = "g++"
 if RUBY_VERSION >= "1.9"
-    $CFLAGS += "-DRUBY_IS_19"
+    $CFLAGS += " -DRUBY_IS_19"
 end
 
 $LDFLAGS += "-module"

data/ext/ruby_internals-1.9.h

@@ -12,9 +12,34 @@
 
 #include <ruby.h>
 #include <ruby/intern.h>
-#include <ruby/node.h>
 #include <ruby/re.h>
 
+typedef struct RNode {
+    unsigned long flags;
+    char *nd_file;
+    union {
+	struct RNode *node;
+	ID id;
+	VALUE value;
+	VALUE (*cfunc)(ANYARGS);
+	ID *tbl;
+    } u1;
+    union {
+	struct RNode *node;
+	ID id;
+	long argc;
+	VALUE value;
+    } u2;
+    union {
+	struct RNode *node;
+	ID id;
+	long state;
+	struct global_entry *entry;
+	long cnt;
+	VALUE value;
+    } u3;
+} NODE;
+
 typedef struct RVALUE {
     union {
 	struct {
@@ -35,11 +60,9 @@ typedef struct RVALUE {
 	struct RFile   file;
 	struct RNode   node;
 	struct RMatch  match;
+	struct RRational rational;
+	struct RComplex complex;
     } as;
-#ifdef GC_DEBUG
-    char *file;
-    int   line;
-#endif
 } RVALUE;
 
 static const size_t SLOT_SIZE = sizeof(RVALUE);

data/ext/utilrb_ext.cc

@@ -1,17 +1,19 @@
 #include <ruby.h>
 #include <set>
 
+#ifndef RUBINIUS
 #ifdef RUBY_IS_19
 #include "ruby_internals-1.9.h"
 #else
-#include <rubyio.h>
 #include "ruby_internals-1.8.h"
 #endif
+#endif
 
 static VALUE mUtilrb;
 
 using namespace std;
 
+#ifndef RUBINIUS
 static VALUE enumerable_each_uniq_i(VALUE i, VALUE* memo)
 { 
     set<VALUE>& seen = *reinterpret_cast< set<VALUE>* >(memo); 
@@ -34,21 +36,6 @@ static VALUE enumerable_each_uniq(VALUE self)
     return self;
 }
 
-#ifndef RUBY_IS_19
-/* call-seq:
- *  io.clearerr => nil 
- *
- * Clear all error flags on the IO
- */
-static VALUE io_clearerr(VALUE self)
-{
-    OpenFile* file;
-    file = RFILE(self)->fptr;
-    clearerr(file->f);
-    return Qnil;
-}
-#endif
-
 /* call-seq:
  *  Kernel.is_singleton?(object)
  *
@@ -120,6 +107,7 @@ static VALUE proc_line(VALUE self)
 
 static VALUE kernel_is_immediate(VALUE klass, VALUE object)
 { return IMMEDIATE_P(object) ? Qtrue : Qfalse; }
+#endif
 
 extern "C" void Init_value_set();
 extern "C" void Init_swap();
@@ -129,19 +117,21 @@ extern "C" void Init_utilrb_ext()
 {
     mUtilrb = rb_define_module("Utilrb");
 
+#ifndef RUBINIUS
     rb_define_method(rb_mEnumerable, "each_uniq", RUBY_METHOD_FUNC(enumerable_each_uniq), 0);
     rb_define_method(rb_mKernel, "is_singleton?", RUBY_METHOD_FUNC(kernel_is_singleton_p), 0);
 #ifndef RUBY_IS_19
     rb_define_method(rb_cProc, "same_body?", RUBY_METHOD_FUNC(proc_same_body_p), 1);
     rb_define_method(rb_cProc, "file", RUBY_METHOD_FUNC(proc_file), 0);
     rb_define_method(rb_cProc, "line", RUBY_METHOD_FUNC(proc_line), 0);
-    rb_define_method(rb_cIO, "clearerr", RUBY_METHOD_FUNC(io_clearerr), 0);
 #endif
 
     rb_define_singleton_method(rb_mKernel, "immediate?", RUBY_METHOD_FUNC(kernel_is_immediate), 1);
 
-    Init_value_set();
     Init_swap();
     Init_weakref(mUtilrb);
+#endif
+
+    Init_value_set();
 }
 

data/ext/value_set.cc

@@ -106,7 +106,7 @@ static VALUE value_set_to_value_set(VALUE self) { return self; }
 static VALUE value_set_dup(VALUE vself, VALUE vother)
 {
     ValueSet const& self  = get_wrapped_set(vself);
-    VALUE vresult = rb_funcall(cValueSet, id_new, 0);
+    VALUE vresult = rb_funcall2(cValueSet, id_new, 0, NULL);
     ValueSet& result = get_wrapped_set(vresult);
     for (ValueSet::const_iterator it = self.begin(); it != self.end(); ++it)
 	result.insert(result.end(), *it);
@@ -142,7 +142,7 @@ static VALUE value_set_union(VALUE vself, VALUE vother)
 	rb_raise(rb_eArgError, "expected a ValueSet");
     ValueSet const& other = get_wrapped_set(vother);
     
-    VALUE vresult = rb_funcall(cValueSet, id_new, 0);
+    VALUE vresult = rb_funcall2(cValueSet, id_new, 0, NULL);
     ValueSet& result = get_wrapped_set(vresult);
     std::set_union(self.begin(), self.end(), other.begin(), other.end(), 
 	    std::inserter(result, result.end()));
@@ -179,7 +179,7 @@ static VALUE value_set_intersection(VALUE vself, VALUE vother)
 	rb_raise(rb_eArgError, "expected a ValueSet");
     ValueSet const& other = get_wrapped_set(vother);
     
-    VALUE vresult = rb_funcall(cValueSet, id_new, 0);
+    VALUE vresult = rb_funcall2(cValueSet, id_new, 0, NULL);
     ValueSet& result = get_wrapped_set(vresult);
     std::set_intersection(self.begin(), self.end(), other.begin(), other.end(), 
 	    std::inserter(result, result.end()));
@@ -230,7 +230,7 @@ static VALUE value_set_difference(VALUE vself, VALUE vother)
 	rb_raise(rb_eArgError, "expected a ValueSet");
     ValueSet const& other = get_wrapped_set(vother);
     
-    VALUE vresult = rb_funcall(cValueSet, id_new, 0);
+    VALUE vresult = rb_funcall2(cValueSet, id_new, 0, NULL);
     ValueSet& result = get_wrapped_set(vresult);
     std::set_difference(self.begin(), self.end(), other.begin(), other.end(), 
 	    std::inserter(result, result.end()));
@@ -307,13 +307,6 @@ static VALUE value_set_initialize_copy(VALUE vself, VALUE vother)
 
 
 
-static VALUE enumerable_to_value_set_i(VALUE i, VALUE* memo)
-{
-    ValueSet& result = *reinterpret_cast<ValueSet*>(memo);
-    result.insert(i);
-    return Qnil;
-}
-
 /* call-seq:
  *  to_value_set    => value_set
  *
@@ -321,17 +314,24 @@ static VALUE enumerable_to_value_set_i(VALUE i, VALUE* memo)
  */
 static VALUE array_to_value_set(VALUE self)
 {
-    VALUE vresult = rb_funcall(cValueSet, id_new, 0);
+    VALUE vresult = rb_funcall2(cValueSet, id_new, 0, NULL);
     ValueSet& result = get_wrapped_set(vresult);
 
-    VALUE* ptr = RARRAY(self)->ptr;
-    long size  = RARRAY(self)->len;
+    long size  = RARRAY_LEN(self);
     for (int i = 0; i < size; ++i)
-	result.insert(ptr[i]);
+	result.insert(rb_ary_entry(self, i));
 
     return vresult;
 }
 
+#ifndef RUBINIUS
+static VALUE enumerable_to_value_set_i(VALUE i, VALUE* memo)
+{
+    ValueSet& result = *reinterpret_cast<ValueSet*>(memo);
+    result.insert(i);
+    return Qnil;
+}
+
 /* call-seq:
  *  enum.to_value_set		=> value_set
  *
@@ -339,12 +339,13 @@ static VALUE array_to_value_set(VALUE self)
  */
 static VALUE enumerable_to_value_set(VALUE self)
 {
-    VALUE vresult = rb_funcall(cValueSet, id_new, 0);
+    VALUE vresult = rb_funcall2(cValueSet, id_new, 0, NULL);
     ValueSet& result = get_wrapped_set(vresult);
 
     rb_iterate(rb_each, self, RUBY_METHOD_FUNC(enumerable_to_value_set_i), reinterpret_cast<VALUE>(&result));
     return vresult;
 }
+#endif
 
 /*
  * Document-class: ValueSet
@@ -357,7 +358,9 @@ static VALUE enumerable_to_value_set(VALUE self)
 
 extern "C" void Init_value_set()
 {
+#ifndef RUBINIUS
     rb_define_method(rb_mEnumerable, "to_value_set", RUBY_METHOD_FUNC(enumerable_to_value_set), 0);
+#endif
     rb_define_method(rb_cArray, "to_value_set", RUBY_METHOD_FUNC(array_to_value_set), 0);
 
     cValueSet = rb_define_class("ValueSet", rb_cObject);

data/ext/weakref.cc

@@ -1,7 +1,11 @@
 #include <set>
 #include <map>
 #include <ruby.h>
+#ifdef RUBY_IS_19
+#include <ruby/intern.h>
+#else
 #include <intern.h>
+#endif
 
 using std::set;
 using std::map;
@@ -12,6 +16,7 @@ static VALUE cRefError;
 /* Weakref internal structure. +obj+ is Qnil before initialization and Qundef
  * after finalization */
 struct WeakRef {
+    VALUE ruby_ref;
     VALUE obj;
 };
 
@@ -22,12 +27,25 @@ typedef map< VALUE, VALUE > ObjFromRefID;
 RefFromObjID from_obj_id;
 ObjFromRefID from_ref_id;
 
-static void weakref_free(WeakRef const* set) { delete set; }
+static void weakref_free(WeakRef const* ref)
+{
+    VALUE ref_id = rb_obj_id(ref->ruby_ref);
+    ObjFromRefID::iterator obj_it = from_ref_id.find(ref_id);
+    if (obj_it != from_ref_id.end())
+    {
+        VALUE obj_id = rb_obj_id(obj_it->second);
+        RefFromObjID::iterator ref_set = from_obj_id.find(obj_id);
+        ref_set->second.erase(ref->ruby_ref);
+        from_ref_id.erase(obj_it);
+    }
+    delete ref;
+}
 static VALUE weakref_alloc(VALUE klass)
 {
     WeakRef* ref = new WeakRef;
     ref->obj = Qnil;
-    return Data_Wrap_Struct(klass, NULL, weakref_free, ref);
+    ref->ruby_ref = Data_Wrap_Struct(klass, NULL, weakref_free, ref);
+    return ref->ruby_ref;
 }
 
 static WeakRef& get_weakref(VALUE self)
@@ -46,40 +64,24 @@ static VALUE do_object_finalize(VALUE mod, VALUE obj_id)
         ObjSet::iterator const end = ref_set->second.end();
         for (; it != end; ++it)
         {
-            /* During GC, objects are garbage collected and *then* the finalizers are called. It means that, even though *it is referenced in from_obj_id, it may be invalid.
-             *
-             * When an object is marked for deferred finalization, its flags
-             * are reset to a special value (flags = FL_MARK). FL_FINALIZE
-             * should therefore not be set on it anymore.
-             */
-            if (FL_TEST(*it, FL_FINALIZE))
-            {
-                WeakRef& ref = get_weakref(*it);
-                ref.obj = Qundef;
-            }
+            // Do NOT use Data_Wrap_Struct here, it would break on recent Ruby
+            // interpreters. The reason is that the object type is reset during
+            // GC -- and the call to free functions is deferred.
+            //
+            // So, at this point, we're sure we have a RDATA in *it (otherwise
+            // weakref_free would have been called), but we can't use
+            // Data_Wrap_Struct because that would crash.
+            WeakRef& ref = *reinterpret_cast<WeakRef*>(RDATA(*it)->data);;
+            ref.obj = Qundef;
             from_ref_id.erase(rb_obj_id(*it));
         }
-
         from_obj_id.erase(obj_id);
     }
     return Qnil;
 }
 
-static VALUE do_weakref_finalize(VALUE mod, VALUE ref_id)
-{
-    ObjFromRefID::iterator obj_it = from_ref_id.find(ref_id);
-    if (obj_it != from_ref_id.end())
-    {
-        VALUE obj_id = rb_obj_id(obj_it->second);
-        RefFromObjID::iterator ref_set = from_obj_id.find(obj_id);
-        ref_set->second.erase(ref_id & ~FIXNUM_FLAG);
-        from_ref_id.erase(obj_it);
-    }
-    return Qnil;
-}
-
 // Note: the Ruby code has already registered +do_object_finalize+ as the
-// finalizer for +obj+, and +do_weakref_finalize+ for +self+.
+// finalizer for +obj+.
 //
 // It is forbidden to make a weakref-of-weakref or a weakref of an immediate
 // object
@@ -134,7 +136,6 @@ extern "C" void Init_weakref(VALUE mUtilrb)
     rb_define_alloc_func(cWeakRef, weakref_alloc);
 
     rb_define_singleton_method(cWeakRef, "do_object_finalize", RUBY_METHOD_FUNC(do_object_finalize), 1);
-    rb_define_singleton_method(cWeakRef, "do_weakref_finalize", RUBY_METHOD_FUNC(do_weakref_finalize), 1);
     rb_define_singleton_method(cWeakRef, "refcount", RUBY_METHOD_FUNC(refcount), 1);
     rb_define_method(cWeakRef, "do_initialize", RUBY_METHOD_FUNC(weakref_do_initialize), 1);
     rb_define_method(cWeakRef, "get", RUBY_METHOD_FUNC(weakref_get), 0);

data/lib/utilrb/column_formatter.rb

@@ -1,16 +1,53 @@
 # Displays a set of data into a column-formatted table
 class ColumnFormatter
-    MARGIN       = 3
-    SCREEN_WIDTH = 90
+    MARGIN       = 1
+    SCREEN_WIDTH = 80
 
-    # data is an array of hashes. Each line of the array is a line to display,
-    # a hash being a column_name => value data set. The special 'label' column
-    # name is used to give a name to each line.
+    # Formats the given array of hash column-wise.
     #
-    # If a block is given, the method yields the column names and the block must
-    # return the array of columns to be displayed, sorted into the order of
-    # the columns.
-    def self.from_hashes(data, io = STDOUT, margin = MARGIN, screen_width = SCREEN_WIDTH)
+    # +data+ is an array of hash. In this array, each element is a sample. The
+    # column names are defined from the hash keys. If one hash does not have a
+    # value for a column, "-" is displayed instead.
+    #
+    # In the output, the columns are ordered alphabetically by default.
+    # Alternatively, they can be ordered by giving an :order option which is an
+    # array of string:
+    #
+    #   from_hashes(data, STDOUT, :order => %w{Col0 Col1 Col2})
+    #
+    # Finally, the method can yield the set of available columns to a block (if
+    # given), and this block should return an ordered array of string.
+    #
+    # In both cases, columns not listed in the ordering array are not displayed.
+    #
+    # The formatting can be controlled by the following options:
+    # header_delimiter:: 
+    #   if true, displays a line of dashes between the header
+    #   and the rest of the table
+    # column_delimiter::
+    #   a string that is inserted between columns
+    # left_padding::
+    #   a string that is inserted in front of each line
+    # order::
+    #   an array of column names, defining which columns should be displayed,
+    #   and in which order they should be displayed. See above for more
+    #   explanations.
+    # screen_width::
+    #   if the table is wider than this count of characters, it is split into
+    #   multiple tables.
+    # margin::
+    #   defines how many spaces are inserted between two columns.
+    def self.from_hashes(data, io = STDOUT, options = Hash.new)
+        options = validate_options options, :margin => MARGIN,
+            :screen_width => SCREEN_WIDTH,
+            :header_delimiter => false,
+            :column_delimiter => "",
+            :left_padding => "",
+            :order => nil
+
+        margin       = options[:margin]
+        screen_width = options[:screen_width]
+
 	width = Hash.new
 
 	# First, determine the columns width and height, and
@@ -35,7 +72,8 @@ class ColumnFormatter
 	# Then ask the user to sort the keys for us
 	names = width.keys.dup
 	names.delete('label')
-	names = if block_given? then yield(names)
+	names = if options[:order] then options[:order]
+                elsif block_given? then yield(names)
 		else names.sort
 		end
 
@@ -45,7 +83,7 @@ class ColumnFormatter
 	    if width.has_key?('label')
 		line_n = ['label']
 		line_w = width['label']
-		format = ["% #{line_w}s"]
+		format = ["%-#{line_w}s"]
 	    else
 		line_n = []
 		line_w = 0
@@ -57,11 +95,18 @@ class ColumnFormatter
 		col_w = width[col_n] || 0
 		line_n << col_n
 		line_w += col_w
-		format << "% #{col_w}s"
+		format << "%-#{col_w}s"
 	    end
 
-	    format = format.join(" " * margin)
-	    io.puts format % line_n
+	    format = format.join(" " * margin + options[:column_delimiter] + " " * margin)
+            header_line = format % line_n
+	    io.puts options[:left_padding] + header_line
+            if options[:header_delimiter]
+                io.puts options[:left_padding] + "-" * header_line.length
+            end
+
+            format = options[:left_padding] + format
+
 	    data.each do |line_data|
 		line_data = line_data.values_at(*line_n)
 		line_data.map! { |v| v || '-' }

data/lib/utilrb/common.rb

@@ -1,6 +1,6 @@
 module Utilrb
     unless defined? Utilrb::VERSION
-	VERSION = "1.3.2"
+	VERSION = "1.3.3"
 	RUBY_IS_19 = (RUBY_VERSION >= "1.9")
     end
 

data/lib/utilrb/enumerable/sequence.rb

@@ -20,11 +20,17 @@ class SequenceEnumerator
     include Enumerable
 end
 
-class Enumerable::Enumerator # :nodoc
+enumerator = if defined?(Enumerable::Enumerator)
+                 Enumerable::Enumerator
+             else
+                 Enumerator
+             end
+
+enumerator.class_eval do # :nodoc
     # Builds a sequence of enumeration object.
     #	([1, 2].enum_for + [2, 3].enum_for).to_a # => [1, 2, 2, 3]
     def +(other_enumerator) # :nodoc
-	SequenceEnumerator.new << self << other_enumerator
+        SequenceEnumerator.new << self << other_enumerator
     end
 end
 

data/lib/utilrb/enumerable/uniq.rb

@@ -2,9 +2,15 @@ require 'utilrb/common'
 require 'enumerator'
 require 'set'
 
+enumerator = if defined?(Enumerable::Enumerator)
+                 Enumerable::Enumerator
+             else
+                 Enumerator
+             end
+
 # Enumerator object which removes duplicate entries. 
 # See also Object#enum_uniq and Enumerable#each_uniq
-class UniqEnumerator < Enumerable::Enumerator
+class UniqEnumerator < enumerator
     # Creates the enumerator on +obj+ using the method +enum_with+ to
     # enumerate. The method will be called with the arguments in +args+.
     #

data/lib/utilrb/pkgconfig.rb

@@ -1,10 +1,44 @@
+require 'shellwords'
+
 module Utilrb
     # Access to information from pkg-config(1)
+    #
+    # This class allows to enumerate the pkg-config packages available, and
+    # create a PkgConfig object that allows to get access to the pkgconfig
+    # information.
+    #
+    # Create a new pkgconfig object with
+    #
+    #   pkg = PkgConfig.new(name)
+    #
+    # It raises PkgConfig::NotFound if the package is not available.
+    #
+    # Then, the classical include directory and library directory flags can be
+    # listed with
+    #
+    #   pkg.include_dirs
+    #   pkg.library_dirs
+    #
+    # Standard fields are available with
+    #
+    #   pkg.cflags
+    #   pkg.cflags_only_I
+    #   pkg.cflags_only_other
+    #   pkg.libs
+    #   pkg.libs_only_L
+    #   pkg.libs_only_l
+    #   pkg.libs_only_other
+    #   pkg.static
+    #
+    # Arbitrary variables defined in the .pc file can be accessed with
+    # 
+    #   pkg.prefix
+    #   pkg.libdir
+    #
     class PkgConfig
 	class NotFound < RuntimeError
 	    attr_reader :name
 	    def initialize(name); @name = name end
-	    def to_s; "#{name} is not available to pkg-config" end
 	end
 	
 	# The module name
@@ -16,7 +50,7 @@ module Utilrb
 	# Raises PkgConfig::NotFound if the module does not exist
 	def initialize(name)
 	    if !system("pkg-config --exists #{name}")
-		raise NotFound.new(name)
+		raise NotFound.new(name), "#{name} is not available to pkg-config"
 	    end
 	    
 	    @name    = name
@@ -25,24 +59,58 @@ module Utilrb
 	    @variables = Hash.new
 	end
 
-	def self.define_action(action)
+	def self.define_action(action) # :nodoc:
 	    define_method(action.gsub(/-/, '_')) do 
 		@actions[action] ||= `pkg-config --#{action} #{name}`.chomp.strip
 	    end
 	    nil
 	end
 
+        # Returns the list of include directories listed in the Cflags: section
+        # of the pkgconfig file
+        def include_dirs
+            Shellwords.shellsplit(cflags_only_I).map { |v| v[2..-1] }
+        end
+
+        # Returns the list of library directories listed in the Libs: section
+        # of the pkgconfig file
+        def library_dirs
+            Shellwords.shellsplit(libs_only_L).map { |v| v[2..-1] }
+        end
+
 	ACTIONS = %w{cflags cflags-only-I cflags-only-other 
 		    libs libs-only-L libs-only-l libs-only-other static}
 	ACTIONS.each { |action| define_action(action) }
 
-	def method_missing(varname, *args, &proc)
+	def method_missing(varname, *args, &proc) # :nodoc:
 	    if args.empty?
 		@variables[varname] ||= `pkg-config --variable=#{varname} #{name}`.chomp.strip
 	    else
 		super(varname, *args, &proc)
 	    end
 	end
+
+        # Returns true if there is a package with this name
+        def self.has_package?(name)
+            enum_for(:each_package, name).find { true }
+        end
+
+        # Yields the package names of available packages. If +regex+ is given,
+        # lists only the names that match the regular expression.
+        def self.each_package(regex = nil)
+            `pkg-config --list-all`.chomp.split.
+                each do |line|
+                    line =~ /^([^\s]+)/
+                    name = $1
+                    if regex
+                        if regex === name
+                            yield(name)
+                        end
+                    else
+                        yield(name)
+                    end
+                end
+        end
     end
 end
 

data/lib/utilrb/weakref.rb

@@ -7,9 +7,9 @@ Utilrb.require_ext("Utilrb::WeakRef") do
                 if obj.kind_of?(WeakRef)
                     raise ArgumentError, "cannot create a weakref of a weakref"
                 end
-
-                ObjectSpace.define_finalizer(obj, self.class.method(:do_object_finalize))
-                ObjectSpace.define_finalizer(self, self.class.method(:do_weakref_finalize))
+                unless WeakRef.refcount(obj)
+                    ObjectSpace.define_finalizer(obj, self.class.method(:do_object_finalize))
+                end
                 do_initialize(obj)
             end
         end

data/test/test_pkgconfig.rb

@@ -26,9 +26,23 @@ class TC_PkgConfig < Test::Unit::TestCase
 	assert_equal(%w{-Ia_prefix/include -O3}.to_set, pkg.cflags.split.to_set)
 	assert_equal('-Ia_prefix/include', pkg.cflags_only_I)
 	assert_equal('-O3', pkg.cflags_only_other)
+        assert_equal(['a_prefix/include'], pkg.include_dirs)
 
 	assert_equal(%w{-ltest -lother -La_prefix/lib}.to_set, pkg.libs.split.to_set)
 	assert_equal('-La_prefix/lib', pkg.libs_only_L)
 	assert_equal(%w{-ltest -lother}.to_set, pkg.libs_only_l.split.to_set)
+        assert_equal(['a_prefix/lib'], pkg.library_dirs)
+
+	pkg = PkgConfig.new('test_pkgconfig_empty')
+	assert_equal('a_prefix', pkg.prefix)
+	assert_equal("", pkg.cflags)
+	assert_equal('', pkg.cflags_only_I)
+	assert_equal('', pkg.cflags_only_other)
+        assert_equal([], pkg.include_dirs)
+
+	assert_equal('', pkg.libs)
+	assert_equal('', pkg.libs_only_L)
+	assert_equal('', pkg.libs_only_l)
+        assert_equal([], pkg.library_dirs)
     end
 end

data/test/test_weakref.rb

@@ -19,6 +19,18 @@ Utilrb.require_ext('TC_WeakRef') do
             assert_raises(ArgumentError) { Utilrb::WeakRef.new(ref) }
         end
 
+        def create_deep_pair(lvl)
+            if lvl == 0
+                100.times do
+                    obj = Object.new
+                    WeakRef.new(obj)
+                    obj = nil
+                end
+            else
+                create_deep_pair(lvl - 1)
+            end
+        end
+
         def create_deep_ref(lvl)
             if lvl == 0
                 obj = Object.new
@@ -38,17 +50,31 @@ Utilrb.require_ext('TC_WeakRef') do
             end
         end
 
-        def test_finalization
+        def test_finalized_objects
             refs, obj_id = create_deep_ref(100)
+            create_deep_ref(200) # erase the stack ...
             GC.start
             for ref in refs
                 assert_raises(WeakRef::RefError) { ref.get }
             end
             assert_equal(nil, WeakRef.refcount(obj_id))
+        end
 
+        def test_finalized_refs
             obj, ref_id = create_deep_obj(100)
+            create_deep_ref(100) # erase the stack ...
+            GC.start
+            assert_raises(RangeError) do
+                ref = ObjectSpace._id2ref(ref_id)
+                if !ref.kind_of?(WeakRef)
+                    raise RangeError
+                end
+            end
+        end
+
+        def test_finalization_ordering_crash
+            create_deep_pair(100)
             GC.start
-            assert_raises(RangeError) { ObjectSpace._id2ref(ref_id) }
         end
     end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: utilrb
 version: !ruby/object:Gem::Version 
-  version: 1.3.2
+  version: 1.3.3
 platform: ruby
 authors: 
 - Sylvain Joyeux
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-07-17 00:00:00 +02:00
+date: 2009-06-22 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,15 +34,29 @@ dependencies:
     version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
-  type: :runtime
+  type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.6.0
+        version: 1.12.2
     version: 
-description: == What is Utilrb ? Utilrb is yet another Ruby toolkit, in the spirit of facets. It includes all the standard class extensions I use in my own projects like Genom.rb.  == Installation The only dependency Utilrb has is flexmock if you want to run tests. It is available as a gem, so you can run  gem install flexmock  == Utilrb's C extension Utilrb includes a C extension in ext/. It is optional, but some of the functionalities will be disabled if it is not present. Trying to require a file in which there is a C-only feature will yield a warning on STDOUT.
+description: |-
+  == What is Utilrb ?
+  Utilrb is yet another Ruby toolkit, in the spirit of facets. It includes all
+  the standard class extensions I use in my own projects like Genom.rb.
+  
+  == Installation
+  The only dependency Utilrb has is flexmock if you want to run tests. It is
+  available as a gem, so you can run
+  
+    gem install flexmock
+  
+  == Utilrb's C extension
+  Utilrb includes a C extension in ext/. It is optional, but some of the
+  functionalities will be disabled if it is not present. Trying to require
+  a file in which there is a C-only feature will yield a warning on STDOUT.
 email: 
 - sylvain.joyeux@m4x.org
 executables: []
@@ -145,7 +159,9 @@ files:
 - test/test_unbound_method.rb
 - test/test_weakref.rb
 has_rdoc: true
-homepage: "    http://utilrb.rubyforge.org"
+homepage: http://utilrb.rubyforge.org
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
@@ -168,9 +184,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: utilrb
-rubygems_version: 1.2.0
+rubygems_version: 1.3.4
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Yet another Ruby toolkit
 test_files: 
 - test/test_time.rb