utilrb 0.2.3 → 1.0

data/Changes.txt

@@ -1,3 +1,27 @@
+=== Version 1.0
+Bumped version number because of incompatible changes. Make it 1.0 since
+having 0. version numbers for this kind of library is completely meaningless
+
+ * incompatible changes:
+    - Enumerable#+ acts on too many objects. Define it only on Enumerable::Enumerator
+    - remove automatic convertion into ValueSet for methods which were doing it
+    - removed Queue#get: fastthread is now the preferred threading library in
+      Ruby 1.8.6, so Queue#get cannot be implemented anymore
+
+ * new features:
+    - PkgConfig class
+    - define Proc#same_body?, Proc#file and Proc#line
+    - Module#attr_predicate
+    - 'since', 'until' and block parameters for Exception#full_message
+    - ValueSet#intersects? (more efficient than checking that the intersection
+      is empty)
+
+ * changes and fixes:
+    - properly handle singleton classes in has_ancestor?
+    - properly handle recursion in ValueSet#to_s and Array#to_s
+    - add the 'setup' task on the Rakefile to build the C extension
+    - make Module#has_ancestor? work event if the C extension is not built
+
 === Version 0.2.3
 
  * new features:

data/Manifest.txt

@@ -7,6 +7,7 @@ bm/allocation.rb
 bm/speed.rb
 ext/extconf.rb
 ext/faster.cc
+ext/ruby_internals.h
 ext/swap.cc
 ext/value_set.cc
 lib/utilrb.rb
@@ -38,6 +39,7 @@ lib/utilrb/logger/hierarchy.rb
 lib/utilrb/module.rb
 lib/utilrb/module/ancestor_p.rb
 lib/utilrb/module/attr_enumerable.rb
+lib/utilrb/module/attr_predicate.rb
 lib/utilrb/module/define_method.rb
 lib/utilrb/module/include.rb
 lib/utilrb/module/inherited_enumerable.rb
@@ -46,8 +48,7 @@ lib/utilrb/object/address.rb
 lib/utilrb/object/attribute.rb
 lib/utilrb/object/singleton_class.rb
 lib/utilrb/objectstats.rb
-lib/utilrb/queue.rb
-lib/utilrb/queue/get.rb
+lib/utilrb/pkgconfig.rb
 lib/utilrb/set.rb
 lib/utilrb/set/to_s.rb
 lib/utilrb/time.rb
@@ -55,10 +56,11 @@ lib/utilrb/time/to_hms.rb
 lib/utilrb/unbound_method.rb
 lib/utilrb/unbound_method/call.rb
 lib/utilrb/value_set.rb
-patches/fastthread-queue-get.patch
+test/data/test_pkgconfig.pc
 test/test_array.rb
 test/test_config.rb
 test/test_enumerable.rb
+test/test_exception.rb
 test/test_gc.rb
 test/test_hash.rb
 test/test_kernel.rb
@@ -66,5 +68,7 @@ test/test_misc.rb
 test/test_module.rb
 test/test_object.rb
 test/test_objectstats.rb
+test/test_pkgconfig.rb
+test/test_proc.rb
 test/test_time.rb
 test/test_unbound_method.rb

data/Rakefile

@@ -1,3 +1,15 @@
+require 'rake'
+require 'rake/rdoctask'
+# FIX: Hoe always calls rdoc with -d, and diagram generation fails here
+class Rake::RDocTask
+    alias __option_list__ option_list
+    def option_list
+	options = __option_list__
+	options.delete("-d")
+	options
+    end
+end
+
 require 'hoe'
 require './lib/utilrb/common'
 
@@ -8,9 +20,20 @@ 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..2).join("\n\n")
+    p.changes     = p.paragraphs_of('Changes.txt', 0..3).join("\n\n")
 
     p.extra_deps << 'facets'
+    p.rdoc_pattern = /(ext\/.*cc$|lib)|txt/
+end
+
+desc "builds Utilrb's C extension"
+task :setup do
+    Dir.chdir("ext") do
+	if !system("ruby extconf.rb") || !system("make")
+	    raise "cannot build the C extension"
+	end
+    end
+    FileUtils.ln_sf "../../ext/faster.so", "lib/utilrb/faster.so"
 end
 
 task :full_test do

data/ext/faster.cc

@@ -1,5 +1,6 @@
 #include <ruby.h>
 #include <set>
+#include "ruby_internals.h"
 
 using namespace std;
 
@@ -38,6 +39,59 @@ static VALUE kernel_is_singleton_p(VALUE self)
 	return Qfalse;
 }
 
+
+/* call-seq:
+ *  proc.same_body?(other) => true or false
+ *
+ * Returns true if +self+ and +other+ have the same body
+ */
+static VALUE proc_same_body_p(VALUE self, VALUE other)
+{
+    if (self == other) return Qtrue;
+    if (TYPE(other) != T_DATA) return Qfalse;
+    if (RDATA(other)->dmark != RDATA(self)->dmark) return Qfalse;
+    if (CLASS_OF(self) != CLASS_OF(other)) return Qfalse;
+
+    struct BLOCK* data, *data2;
+    Data_Get_Struct(self, struct BLOCK, data);
+    Data_Get_Struct(other, struct BLOCK, data2);
+    return (data->body == data2->body) ? Qtrue : Qfalse;
+}
+
+/* call-seq:
+ *  proc.file
+ *
+ * Returns the file in which the proc body is defined, or nil
+ */
+static VALUE proc_file(VALUE self)
+{ 
+    struct BLOCK *data;
+    NODE *node;
+
+    Data_Get_Struct(self, struct BLOCK, data);
+    if ((node = data->frame.node) || (node = data->body)) 
+	return rb_str_new2(node->nd_file);
+    else 
+	return Qnil;
+}
+
+/* call-seq:
+ *  proc.file
+ *
+ * Returns the line at which the proc body is defined, or nil
+ */
+static VALUE proc_line(VALUE self)
+{
+    struct BLOCK *data;
+    NODE *node;
+
+    Data_Get_Struct(self, struct BLOCK, data);
+    if ((node = data->frame.node) || (node = data->body)) 
+	return INT2FIX(nd_line(node));
+    else
+	return Qnil;
+}
+
 extern "C" void Init_value_set();
 extern "C" void Init_swap();
 
@@ -45,6 +99,9 @@ extern "C" void Init_faster()
 {
     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);
+    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);
 
     Init_value_set();
     Init_swap();

data/ext/ruby_internals.h

@@ -0,0 +1,72 @@
+#ifndef __RUBY_INTERNALS_HH__
+#define __RUBY_INTERNALS_HH__
+
+/* WARNING: this file contains copies of internal Ruby structures. They are not supposed to be copied (I think ;-)), but I had to nonetheless.
+ * The following methods depend on these:
+ *
+ *   Kernel.swap!
+ *   Proc#same_body?
+ *   Proc#file
+ *   Proc#line
+ */
+
+#include <ruby.h>
+#include <intern.h>
+#include <node.h>
+#include <re.h>
+#include <env.h>
+
+typedef struct RVALUE {
+    union {
+        struct {
+            unsigned long flags;        /* always 0 for freed obj */
+            struct RVALUE *next;
+        } free;
+        struct RBasic  basic;
+        struct RObject object;
+        struct RClass  klass;
+        struct RFloat  flonum;
+        struct RString string;
+        struct RArray  array;
+        struct RRegexp regexp;
+        struct RHash   hash;
+        struct RData   data;
+        struct RStruct rstruct;
+        struct RBignum bignum;
+        struct RFile   file;
+        struct RNode   node;
+        struct RMatch  match;
+        struct RVarmap varmap;
+        struct SCOPE   scope;
+    } as;
+#ifdef GC_DEBUG
+    char *file;
+    int   line;
+#endif
+} RVALUE;
+static const size_t SLOT_SIZE = sizeof(RVALUE);
+
+/* This is a copy of Ruby 1.8.5 BLOCK structure. It sucks to copy it here,
+ * but it is not public in Ruby and it is needed to define same_body? */
+struct BLOCK {
+    NODE *var;
+    NODE *body;
+    VALUE self;
+    struct FRAME frame;
+    struct SCOPE *scope;
+    VALUE klass;
+    NODE *cref;
+    int iter;
+    int vmode;
+    int flags;
+    int uniq;
+    struct RVarmap *dyna_vars;
+    VALUE orig_thread;
+    VALUE wrapper;
+    VALUE block_obj;
+    struct BLOCK *outer;
+    struct BLOCK *prev;
+};
+
+#endif
+

data/ext/swap.cc

@@ -1,38 +1,4 @@
-#include <ruby.h>
-#include <intern.h>
-#include <node.h>
-#include <re.h>
-#include <env.h>
-
-typedef struct RVALUE {
-    union {
-        struct {
-            unsigned long flags;        /* always 0 for freed obj */
-            struct RVALUE *next;
-        } free;
-        struct RBasic  basic;
-        struct RObject object;
-        struct RClass  klass;
-        struct RFloat  flonum;
-        struct RString string;
-        struct RArray  array;
-        struct RRegexp regexp;
-        struct RHash   hash;
-        struct RData   data;
-        struct RStruct rstruct;
-        struct RBignum bignum;
-        struct RFile   file;
-        struct RNode   node;
-        struct RMatch  match;
-        struct RVarmap varmap;
-        struct SCOPE   scope;
-    } as;
-#ifdef GC_DEBUG
-    char *file;
-    int   line;
-#endif
-} RVALUE;
-static const size_t SLOT_SIZE = sizeof(RVALUE);
+#include "ruby_internals.h"
 
 /*
  * Kernel.swap!(obj1, obj2, *args)

data/ext/value_set.cc

@@ -9,7 +9,6 @@ using namespace std;
 
 static VALUE cValueSet;
 static ID id_new;
-static ID id_to_value_set;
 
 typedef std::set<VALUE> ValueSet;
 static ValueSet& get_wrapped_set(VALUE self)
@@ -110,7 +109,9 @@ static VALUE value_set_to_value_set(VALUE self) { return self; }
 static VALUE value_set_include_all_p(VALUE vself, VALUE vother)
 {
     ValueSet const& self  = get_wrapped_set(vself);
-    ValueSet const& other = get_wrapped_set(rb_funcall(vother, id_to_value_set, 0));
+    if (!RTEST(rb_obj_is_kind_of(vother, cValueSet)))
+	rb_raise(rb_eArgError, "expected a ValueSet");
+    ValueSet const& other = get_wrapped_set(vother);
     return std::includes(self.begin(), self.end(), other.begin(), other.end()) ? Qtrue : Qfalse;
 }
 
@@ -124,7 +125,9 @@ static VALUE value_set_include_all_p(VALUE vself, VALUE vother)
 static VALUE value_set_union(VALUE vself, VALUE vother)
 {
     ValueSet const& self  = get_wrapped_set(vself);
-    ValueSet const& other = get_wrapped_set(rb_funcall(vother, id_to_value_set, 0));
+    if (!RTEST(rb_obj_is_kind_of(vother, cValueSet)))
+	rb_raise(rb_eArgError, "expected a ValueSet");
+    ValueSet const& other = get_wrapped_set(vother);
     
     VALUE vresult = rb_funcall(cValueSet, id_new, 0);
     ValueSet& result = get_wrapped_set(vresult);
@@ -141,7 +144,9 @@ static VALUE value_set_union(VALUE vself, VALUE vother)
 static VALUE value_set_merge(VALUE vself, VALUE vother)
 {
     ValueSet& self  = get_wrapped_set(vself);
-    ValueSet const& other = get_wrapped_set(rb_funcall(vother, id_to_value_set, 0));
+    if (!RTEST(rb_obj_is_kind_of(vother, cValueSet)))
+	rb_raise(rb_eArgError, "expected a ValueSet");
+    ValueSet const& other = get_wrapped_set(vother);
     
     self.insert(other.begin(), other.end());
     return vself;
@@ -157,7 +162,9 @@ static VALUE value_set_merge(VALUE vself, VALUE vother)
 static VALUE value_set_intersection(VALUE vself, VALUE vother)
 {
     ValueSet const& self  = get_wrapped_set(vself);
-    ValueSet const& other = get_wrapped_set(rb_funcall(vother, id_to_value_set, 0));
+    if (!RTEST(rb_obj_is_kind_of(vother, cValueSet)))
+	rb_raise(rb_eArgError, "expected a ValueSet");
+    ValueSet const& other = get_wrapped_set(vother);
     
     VALUE vresult = rb_funcall(cValueSet, id_new, 0);
     ValueSet& result = get_wrapped_set(vresult);
@@ -165,6 +172,37 @@ static VALUE value_set_intersection(VALUE vself, VALUE vother)
 	    std::inserter(result, result.end()));
     return vresult;
 }
+
+/* call-seq:
+ *  set.intersects?(other)	=> true or false
+ *
+ * Returns true if there is elements in +set+ that are also in +other
+ */
+static VALUE value_set_intersects(VALUE vself, VALUE vother)
+{
+    ValueSet const& self  = get_wrapped_set(vself);
+    if (!RTEST(rb_obj_is_kind_of(vother, cValueSet)))
+	rb_raise(rb_eArgError, "expected a ValueSet");
+    ValueSet const& other = get_wrapped_set(vother);
+
+    ValueSet::const_iterator 
+	self_it   = self.begin(),
+	self_end  = self.end(),
+	other_it  = other.begin(),
+	other_end = other.end();
+
+    while(self_it != self_end && other_it != other_end)
+    {
+	if (*self_it < *other_it)
+	    ++self_it;
+	else if (*other_it < *self_it)
+	    ++other_it;
+	else
+	    return Qtrue;
+    }
+    return Qfalse;
+}
+
 /* call-seq:
  *   set.difference(other)	=> difference_set
  *   set - other		=> difference_set
@@ -175,7 +213,9 @@ static VALUE value_set_intersection(VALUE vself, VALUE vother)
 static VALUE value_set_difference(VALUE vself, VALUE vother)
 {
     ValueSet const& self  = get_wrapped_set(vself);
-    ValueSet const& other = get_wrapped_set(rb_funcall(vother, id_to_value_set, 0));
+    if (!RTEST(rb_obj_is_kind_of(vother, cValueSet)))
+	rb_raise(rb_eArgError, "expected a ValueSet");
+    ValueSet const& other = get_wrapped_set(vother);
     
     VALUE vresult = rb_funcall(cValueSet, id_new, 0);
     ValueSet& result = get_wrapped_set(vresult);
@@ -219,10 +259,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))
+    if (!RTEST(rb_obj_is_kind_of(vother, cValueSet)))
 	return Qfalse;
-
-    ValueSet const& other = get_wrapped_set(rb_funcall(vother, id_to_value_set, 0));
+    ValueSet const& other = get_wrapped_set(vother);
     return (self == other) ? Qtrue : Qfalse;
 }
 
@@ -244,7 +283,7 @@ static VALUE value_set_clear(VALUE self)
  */
 static VALUE value_set_initialize_copy(VALUE vself, VALUE vother)
 {
-    ValueSet const& other = get_wrapped_set(rb_funcall(vother, id_to_value_set, 0));
+    ValueSet const& other = get_wrapped_set(vother);
     set<VALUE> new_set(other.begin(), other.end());
     get_wrapped_set(vself).swap(new_set);
     return vself;
@@ -292,13 +331,13 @@ extern "C" void Init_value_set()
 
     cValueSet = rb_define_class("ValueSet", rb_cObject);
     id_new = rb_intern("new");
-    id_to_value_set = rb_intern("to_value_set");
     rb_define_alloc_func(cValueSet, value_set_alloc);
     rb_define_method(cValueSet, "each", RUBY_METHOD_FUNC(value_set_each), 0);
     rb_define_method(cValueSet, "include?", RUBY_METHOD_FUNC(value_set_include_p), 1);
     rb_define_method(cValueSet, "include_all?", RUBY_METHOD_FUNC(value_set_include_all_p), 1);
     rb_define_method(cValueSet, "union", RUBY_METHOD_FUNC(value_set_union), 1);
     rb_define_method(cValueSet, "intersection", RUBY_METHOD_FUNC(value_set_intersection), 1);
+    rb_define_method(cValueSet, "intersects?", RUBY_METHOD_FUNC(value_set_intersects), 1);
     rb_define_method(cValueSet, "difference", RUBY_METHOD_FUNC(value_set_difference), 1);
     rb_define_method(cValueSet, "insert", RUBY_METHOD_FUNC(value_set_insert), 1);
     rb_define_method(cValueSet, "merge", RUBY_METHOD_FUNC(value_set_merge), 1);

data/lib/utilrb/array/to_s.rb

@@ -3,11 +3,11 @@ class Array
     # Unlike #inspect, it calls #to_s on the elements too
     def to_s
 	stack = (Thread.current[:array_to_s] ||= [])
-	if stack.include?(self)
+	if stack.include?(object_id)
 	    "..."
 	else
 	    begin
-		stack.push self
+		stack.push object_id
 		"[" << map { |obj| obj.to_s }.join(", ") << "]"
 	    ensure
 		stack.pop

data/lib/utilrb/common.rb

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

data/lib/utilrb/enumerable/sequence.rb

@@ -1,8 +1,16 @@
-# An enumerator which iterates on a sequence of enumerator
+require 'enumerator'
+
+# An enumerator which iterates on multiple iterators in sequence
+#
+#   ([1, 2].enum_for + [2, 3].enum_for).each => 1, 2, 2, 3
+#
+# See also Enumerator#+
 class SequenceEnumerator
     def initialize; @sequence = Array.new end
+
+    def +(other); SequenceEnumerator.new << self << other end
     # Adds +object+ at the back of the sequence
-    def <<(object); @sequence << object; self end
+    def <<(other); @sequence << other; self end
 
     def each
 	@sequence.each { |enum| enum.each { |o| yield(o) } } if block_given?
@@ -12,7 +20,7 @@ class SequenceEnumerator
     include Enumerable
 end
 
-module Enumerable # :nodoc
+class Enumerable::Enumerator # :nodoc
     # Builds a sequence of enumeration object.
     #	([1, 2].enum_for + [2, 3]).each		=> 1, 2, 2, 3
     def +(other_enumerator) # :nodoc

data/lib/utilrb/exception/full_message.rb

@@ -1,3 +1,4 @@
+require 'utilrb/kernel/options'
 
 class Exception
     # Returns the full exception message, with backtrace, like the one we get from
@@ -16,9 +17,40 @@ class Exception
     #   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 ")
+    # Two regular expressions can be given through the +options+ hash to filter the backtrace:
+    # since:: 
+    #   Only the methods *below* the first matching line will be displayed. The matching
+    #   line is included.
+    # until::
+    #   Only the methods *above* the first matching line will be displayed. The matching
+    #   line is *not* included
+    #
+    # If a block is given, each line of the backtrace are yield and only the lines for which
+    # the block returns true are displayed
+    #
+    def full_message(options = {}, &block)
+	options = validate_options options, [:since, :until]
+	since_matches, until_matches = options[:since], options[:until]
+
+	trace = backtrace
+	if since_matches || until_matches
+	    found_beginning, found_end = !since_matches, false
+	    trace = trace.find_all do |line|
+		found_beginning ||= (line =~ since_matches)
+		found_end       ||= (line =~ until_matches) if until_matches
+		found_beginning && !found_end
+	    end
+	end
+
+	first, *remaining = if block_given? then trace.find_all(&block)
+			    else trace
+			    end
+
+	msg = "#{first}: #{message} (#{self.class})"
+	unless remaining.empty?
+	    msg << "\n\tfrom " + remaining.join("\n\tfrom ")
+	end
+	msg
     end
 end
 

data/lib/utilrb/module/ancestor_p.rb

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

data/lib/utilrb/module/attr_predicate.rb

@@ -0,0 +1,17 @@
+class Module
+    # Defines a +name+ predicate (name should end with '?'), and if writable is true
+    # a writer method which is +name+ without '?'
+    #
+    # The predicate reads the instance variable which is +name+ without the '?'
+    def attr_predicate(name, writable = false)
+	attr_name = name.to_s.gsub(/\?$/, '')
+	attr_reader attr_name
+	alias_method "#{attr_name}?", attr_name
+	remove_method attr_name
+
+	if writable
+	    class_eval "def #{attr_name}=(value); @#{attr_name} = !!value end"
+	end
+    end
+end
+

data/lib/utilrb/pkgconfig.rb

@@ -0,0 +1,48 @@
+module Utilrb
+    # Access to information from pkg-config(1)
+    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
+	attr_reader :name
+	# The module version
+	attr_reader :version
+
+	# Create a PkgConfig object for the package +name+
+	# Raises PkgConfig::NotFound if the module does not exist
+	def initialize(name)
+	    if !system("pkg-config --exists #{name}")
+		raise NotFound.new(name)
+	    end
+	    
+	    @name    = name
+	    @version = `pkg-config --modversion #{name}`.chomp.strip
+	    @actions = Hash.new
+	    @variables = Hash.new
+	end
+
+	def self.define_action(action)
+	    define_method(action.gsub(/-/, '_')) do 
+		@actions[action] ||= `pkg-config --#{action} #{name}`.chomp.strip
+	    end
+	    nil
+	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)
+	    if args.empty?
+		@variables[varname] ||= `pkg-config --variable=#{varname} #{name}`.chomp.strip
+	    else
+		super(varname, *args, &proc)
+	    end
+	end
+    end
+end
+

data/lib/utilrb/time/to_hms.rb

@@ -9,13 +9,13 @@ class Time
     # 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}"
+	    raise ArgumentError, "#{string} found, expected [[h:]m:]s[.ms]"
 	end
 	hm, ms = $`, $'
 
 	s = Integer($1)
 	unless hm =~ /^(?:(\d*):)?(?:(\d*))?$/
-	    raise "invalid format #{string}. found #{hm}, expected nothing, m: or h:m:"
+	    raise ArgumentError, "found #{hm}, expected nothing, m: or h:m:"
 	end
 	h, m = if $2.empty? then 
 		   if $1 then [0, Integer($1)]
@@ -27,7 +27,7 @@ class Time
 	ms = if ms.empty? then 0
 	     else
 		 unless ms =~ /^\d*$/
-		     raise "invalid format "#{string}"
+		     raise ArgumentError, "found #{string}, expected a number"
 		 end
 		 ms += "0" * (3 - ms.size)
 		 Integer(ms)

data/lib/utilrb/value_set.rb

@@ -9,9 +9,25 @@ Utilrb.require_faster("ValueSet") do
 	include Enumerable
 
 	def to_s
-	    base = super[0..-2]
-	    "#{base} { #{to_a.map { |o| o.to_s }.join(", ")} }"
+	    stack = (Thread.current[:__value_set_stack__] ||= ValueSet.new)
+	    if stack.include?(self)
+		"..."
+	    else
+		stack << self
+
+		base = super[0..-2]
+		"#{base} { #{to_a.map { |o| o.to_s }.join(", ")} }"
+	    end
+	ensure
+	    stack.delete(self)
 	end
 	alias :inspect :to_s
+
+	def _dump(lvl = -1)
+	    Marshal.dump(to_a)
+	end
+	def self._load(str)
+	    Marshal.load(str).to_value_set
+	end
     end
 end

data/test/data/test_pkgconfig.pc

@@ -0,0 +1,9 @@
+prefix=a_prefix
+
+Name: test_pkgconfig
+Description:
+Version: 4.2
+
+Cflags: -I${prefix}/include -O3
+Libs: -ltest -lother -L${prefix}/lib
+

data/test/test_enumerable.rb

@@ -43,6 +43,7 @@ class TC_Enumerable < Test::Unit::TestCase
 	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)
+	assert_equal([:a, :b, :c, :d, :e, :f], [c1, c2].inject(SequenceEnumerator.new) { |a, b| a << b }.to_a)
     end
 
     def test_random_element
@@ -66,9 +67,13 @@ class TC_Enumerable < Test::Unit::TestCase
 	    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?([4, 1, 8].to_value_set))
 	    assert(!a.include_all?(b))
 
+	    assert(a.intersects?(b))
+	    assert(b.intersects?(a))
+	    assert(!a.intersects?([2, 9, 12].to_value_set))
+
 	    assert(a.object_id == a.to_value_set.object_id)
 
 	    assert_equal([1, 2, 3, 4, 6, 8, 11], (a.union(b)).to_a)
@@ -87,6 +92,12 @@ class TC_Enumerable < Test::Unit::TestCase
 
 	    assert_equal([1,3,5].to_value_set, [1, 2, 3, 4, 5, 6].to_value_set.delete_if { |v| v % 2 == 0 })
 	end
+
+	def test_value_set_recursive_to_s
+	    v = [1, 2].to_value_set
+	    v << v
+	    assert_nothing_raised { v.to_s }
+	end
     end
 end
 

data/test/test_exception.rb

@@ -0,0 +1,38 @@
+require 'test_config'
+require 'utilrb/exception'
+require 'flexmock'
+
+class TC_Exception < Test::Unit::TestCase
+    def test_full_message
+	FlexMock.use do |mock|
+	    error = Exception.new
+	    def error.message; "this is an error" end
+	    def error.backtrace
+		(0..10).map { |i| i.to_s }
+	    end
+
+	    full     = error.full_message.split("\n")
+	    assert_equal(11, full.size)
+
+	    filtered = error.full_message { |line| Integer(line) % 2 == 0 }.split("\n")
+	    assert_equal(6, filtered.size)
+	    assert_equal(full.values_at(0, 2, 4, 6, 8, 10), filtered)
+
+	    since_matches = error.full_message(:since => /4/).split("\n")
+	    assert_equal(7, since_matches.size)
+	    assert_equal(full.values_at(*(5..10)), since_matches[1..-1])
+
+	    until_matches = error.full_message(:until => /3/).split("\n")
+	    assert_equal(3, until_matches.size)
+	    assert_equal(full.values_at(1, 2), until_matches[1..-1])
+
+	    since_and_until = error.full_message(:since => /3/, :until => /6/).split("\n")
+	    assert_equal(3, since_and_until.size)
+	    assert_equal(full.values_at(4, 5), since_and_until[1..-1])
+
+	    all = error.full_message(:since => /3/, :until => /6/) { |line| Integer(line) % 2 == 0 }.split("\n")
+	    assert_equal(1, all.size)
+	end
+    end
+end
+

data/test/test_module.rb

@@ -123,5 +123,25 @@ class TC_Module < Test::Unit::TestCase
         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
+
+    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))
+    end
 end
 

data/test/test_object.rb

@@ -61,5 +61,24 @@ class TC_Object < Test::Unit::TestCase
 	assert_equal(klass, object.singleton_class.superclass)
 	assert_equal([object.singleton_class, klass, Object], object.singleton_class.ancestors[0, 3])
     end
+
+    def test_attr_predicate
+	klass = Class.new do
+	    attr_predicate :working
+	    attr_predicate :not_working, true
+	end
+	assert(klass.method_defined?(:working?))
+	assert(!klass.method_defined?(:working))
+	assert(!klass.method_defined?(:working=))
+	assert(klass.method_defined?(:not_working?))
+	assert(!klass.method_defined?(:not_working))
+	assert(klass.method_defined?(:not_working=))
+
+	object = klass.new
+	object.instance_eval { @working = true }
+	assert(object.working?)
+	object.not_working = 5
+	assert_equal(true, object.not_working?)
+    end
 end
 

data/test/test_pkgconfig.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+require 'set'
+require 'utilrb/pkgconfig'
+
+class TC_PkgConfig < Test::Unit::TestCase
+    def setup
+	@old_pkg_config_path = ENV['PKG_CONFIG_PATH']
+	ENV['PKG_CONFIG_PATH'] = File.join(File.expand_path(File.dirname(__FILE__)), 'data')
+    end
+    def teardown
+	ENV['PKG_CONFIG_PATH'] = @old_pkg_config_path
+    end
+
+    PkgConfig = Utilrb::PkgConfig
+    def test_find_package
+	STDERR.puts ENV['PKG_CONFIG_PATH']
+	assert_raises(PkgConfig::NotFound) { PkgConfig.new('does_not_exist') }
+	assert_nothing_raised { PkgConfig.new('test_pkgconfig') }
+    end
+
+    def test_load
+	pkg = PkgConfig.new('test_pkgconfig')
+	assert_equal('test_pkgconfig', pkg.name)
+	assert_equal('4.2', pkg.version)
+
+	assert_equal('a_prefix', pkg.prefix)
+	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(%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)
+    end
+end

data/test/test_proc.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require 'utilrb'
+
+Utilrb.require_faster('TC_Proc') do
+    class TC_Proc < Test::Unit::TestCase
+	def block_to_proc_helper(&block); block end
+	def block_to_proc
+	    [block_to_proc_helper { blo }, block_to_proc_helper { bla }]
+	end
+	def test_same_body
+	    a1, a2 = block_to_proc
+	    b1, b2 = block_to_proc
+	    assert(a1.same_body?(b1))
+	    assert(a2.same_body?(b2))
+	    assert(!a1.same_body?(b2))
+	    assert(!a2.same_body?(b1))
+	end
+
+	def test_line
+	    assert_equal(8, block_to_proc.first.line)
+	end
+
+	def test_file
+	    assert_equal(File.expand_path(__FILE__), File.expand_path(block_to_proc.first.file))
+	end
+    end
+end
+

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.1
+rubygems_version: 0.9.2
 specification_version: 1
 name: utilrb
 version: !ruby/object:Gem::Version 
-  version: 0.2.3
-date: 2007-01-30 00:00:00 +01:00
+  version: "1.0"
+date: 2007-03-31 00:00:00 +02:00
 summary: Yet another Ruby toolkit
 require_paths: 
 - lib
@@ -39,6 +39,7 @@ files:
 - bm/speed.rb
 - ext/extconf.rb
 - ext/faster.cc
+- ext/ruby_internals.h
 - ext/swap.cc
 - ext/value_set.cc
 - lib/utilrb.rb
@@ -70,6 +71,7 @@ files:
 - lib/utilrb/module.rb
 - lib/utilrb/module/ancestor_p.rb
 - lib/utilrb/module/attr_enumerable.rb
+- lib/utilrb/module/attr_predicate.rb
 - lib/utilrb/module/define_method.rb
 - lib/utilrb/module/include.rb
 - lib/utilrb/module/inherited_enumerable.rb
@@ -78,8 +80,7 @@ files:
 - lib/utilrb/object/attribute.rb
 - lib/utilrb/object/singleton_class.rb
 - lib/utilrb/objectstats.rb
-- lib/utilrb/queue.rb
-- lib/utilrb/queue/get.rb
+- lib/utilrb/pkgconfig.rb
 - lib/utilrb/set.rb
 - lib/utilrb/set/to_s.rb
 - lib/utilrb/time.rb
@@ -87,10 +88,11 @@ files:
 - lib/utilrb/unbound_method.rb
 - lib/utilrb/unbound_method/call.rb
 - lib/utilrb/value_set.rb
-- patches/fastthread-queue-get.patch
+- test/data/test_pkgconfig.pc
 - test/test_array.rb
 - test/test_config.rb
 - test/test_enumerable.rb
+- test/test_exception.rb
 - test/test_gc.rb
 - test/test_hash.rb
 - test/test_kernel.rb
@@ -98,9 +100,13 @@ files:
 - test/test_module.rb
 - test/test_object.rb
 - test/test_objectstats.rb
+- test/test_pkgconfig.rb
+- test/test_proc.rb
 - test/test_time.rb
 - test/test_unbound_method.rb
 test_files: 
+- test/test_proc.rb
+- test/test_exception.rb
 - test/test_time.rb
 - test/test_misc.rb
 - test/test_module.rb
@@ -113,6 +119,7 @@ test_files:
 - test/test_enumerable.rb
 - test/test_hash.rb
 - test/test_objectstats.rb
+- test/test_pkgconfig.rb
 rdoc_options: []
 
 extra_rdoc_files: []
@@ -140,5 +147,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.1.7
+        version: 1.2.0
     version: 

data/lib/utilrb/queue/get.rb

@@ -1,22 +0,0 @@
-class Queue
-    # 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
-    end
-end

data/lib/utilrb/queue.rb

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

data/patches/fastthread-queue-get.patch

@@ -1,72 +0,0 @@
---- 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"));