utilrb 0.2

data/Changes.txt

@@ -0,0 +1,20 @@
+=== Version 0.2.1
+ * new features:
+    - is_singleton?
+    - inherited_enumerable (class_inherited_enumerable on steroids)
+    - attribute() can be used in singleton classes (previously we had to 
+      call class_attribute() in the class itself)
+    - UnboundMethod#call(obj, *args, &block) calls the method on obj with 
+      the provided arguments
+
+ * changes:
+    - changed semantics of Module::include for inclusion of modules in modules:
+      the source_module::ClassExtension gets included in
+      target_module::ClassExtension.  Previously, it was extending the target's
+      singleton class. This way, Module really acts as a mixin for both class
+      methods and instance methods
+
+=== Version 0.1
+ * Initial release
+
+

data/License.txt

@@ -0,0 +1,26 @@
+Copyright (c) The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the name of the University nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/Manifest.txt

@@ -0,0 +1,64 @@
+bm/allocation.rb
+bm/speed.rb
+Changes.txt
+ext/extconf.rb
+ext/faster.cc
+ext/swap.cc
+ext/value_set.cc
+lib/utilrb/array.rb
+lib/utilrb/array/to_s.rb
+lib/utilrb/common.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/gc.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/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/forward.rb
+lib/utilrb/logger/hierarchy.rb
+lib/utilrb/logger.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/address.rb
+lib/utilrb/object/attribute.rb
+lib/utilrb/object.rb
+lib/utilrb/object/singleton_class.rb
+lib/utilrb/objectstats.rb
+lib/utilrb.rb
+lib/utilrb/time.rb
+lib/utilrb/time/to_hms.rb
+lib/utilrb/unbound_method/call.rb
+lib/utilrb/unbound_method.rb
+lib/utilrb/value_set.rb
+License.txt
+Manifest.txt
+Rakefile
+README.txt
+test/test_array.rb
+test/test_config.rb
+test/test_enumerable.rb
+test/test_gc.rb
+test/test_hash.rb
+test/test_kernel.rb
+test/test_misc.rb
+test/test_module.rb
+test/test_object.rb
+test/test_objectstats.rb
+test/test_unbound_method.rb

data/README.txt

@@ -0,0 +1,44 @@
+Utilrb
+    http://utilrb.rubyforge.org
+    http://www.laas.fr/~sjoyeux/darcs/utilrb
+    http://www.laas.fr/~sjoyeux/research.php
+
+Copyright (c) 2006 
+    Sylvain Joyeux <sylvain.joyeux@m4x.org>
+    LAAS/CNRS <openrobots@laas.fr>
+
+This work is licensed under the BSD license. See License.txt for details
+
+== 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.
+
+== 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.
+
+* some features have a Ruby version, but a C version is provided for
+  performance:
+  - Enumerable#each_uniq
+
+* some features are C-only
+  - ValueSet class
+  - Kernel#swap!
+
+The environment variable <tt>UTILRB_FASTER_MODE</tt> controls the extension
+loading. Set it to +no+ to disable the extension, to +yes+ to force it 
+(an error is generated if the extension is not available). If the variable
+is not set, the extension is loaded if available.
+
+== TODO
+* put the +block+ argument in front in Module#define_method_with_block. This
+  would allow to do 
+
+    define_method_with_block(:bla) do |block, *args| 
+    end
+
+  [DONE 20061101125259-1e605-fef189550540b8e096f0bbe6c219d892bf3e13fc.gz]
+
+== CHANGES
+:include: Changes.txt

data/Rakefile

@@ -0,0 +1,46 @@
+require 'hoe'
+require './lib/utilrb/common'
+
+Hoe.new('utilrb', Utilrb::VERSION) do |p|
+    p.author = "Sylvain Joyeux"
+    p.email = "sylvain.joyeux@m4x.org"
+
+    p.summary = 'Yet another Ruby toolkit'
+    p.description = p.paragraphs_of('README.txt', 2..5).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.extra_deps = ['facets']
+end
+
+task :full_test do
+    ENV['UTILRB_FASTER_MODE'] = 'no'
+    system("testrb test/")
+    ENV['UTILRB_FASTER_MODE'] = 'yes'
+    system("testrb test/")
+end
+
+task :rcov_test do
+    Dir.chdir('test') do 
+	if !File.directory?('../rcov')
+	    File.mkdir('../rcov')
+	end
+	File.open("../rcov/index.html", "w") do |index|
+	    index.puts <<-EOF
+		<!DOCTYPE html PUBLIC 
+		    "-//W3C//DTD XHTML 1.0 Transitional//EN" 
+		    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+		<body>
+	    EOF
+
+	    Dir.glob('test_*.rb').each do |path|
+		puts "\n" * 4 + "=" * 5 + " #{path} " + "=" * 5 + "\n"
+		basename = File.basename(path, '.rb')
+		system("rcov --replace-progname -o ../rcov/#{basename} #{path}")
+		index.puts "<div class=\"test\"><a href=\"#{basename}/index.html\">#{basename}</a></div>"
+	    end
+	    index.puts "</body>"
+	end
+    end
+end
+

data/bm/allocation.rb

@@ -0,0 +1,7 @@
+require 'utilrb'
+require 'pp'
+
+STDERR.puts "== Enumerable#each_uniq =="
+test_array = 10000.enum_for(:times).map { rand(10) }
+pp ObjectStats.profile { test_array.each_uniq { } }
+

data/bm/speed.rb

@@ -0,0 +1,19 @@
+require 'benchmark'
+require 'utilrb'
+
+STDERR.puts "== Enumerable#each_uniq =="
+test_arrays = []
+1000.times { 
+    new = []
+    1000.times { new << rand(10) }
+    test_arrays << new
+}
+
+Benchmark.bm(7) do |x|
+    x.report('each_uniq') do 
+	test_arrays.each do |test|
+	    test.each_uniq { }
+	end
+    end
+end
+

data/ext/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+CONFIG['CC'] = "g++"
+$LDFLAGS += "-module"
+create_makefile("faster")
+

data/ext/faster.cc

@@ -0,0 +1,48 @@
+#include <ruby.h>
+#include <set>
+
+using namespace std;
+
+static VALUE enumerable_each_uniq_i(VALUE i, VALUE* memo)
+{ 
+    set<VALUE>& seen = *reinterpret_cast< set<VALUE>* >(memo); 
+    if (seen.find(i) == seen.end())
+    {
+	seen.insert(i);
+	return rb_yield(i);
+    }
+    else
+	return Qnil;
+
+}
+
+/* :nodoc: */
+static VALUE enumerable_each_uniq(VALUE self)
+{
+    set<VALUE> seen;
+    rb_iterate(rb_each, self, 
+	    RUBY_METHOD_FUNC(enumerable_each_uniq_i), (VALUE)&seen);
+    return self;
+}
+
+/* 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))
+	return Qtrue;
+    else
+	return Qfalse;
+}
+
+extern "C" void Init_value_set();
+extern "C" void Init_swap();
+
+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);
+
+    Init_value_set();
+    Init_swap();
+}
+

data/ext/swap.cc

@@ -0,0 +1,61 @@
+#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);
+
+/*
+ * Kernel.swap!(obj1, obj2, *args)
+ *
+ * Swaps the object which are being hold by obj1 and obj2.
+ *
+ * WARNING: I don't know if this can be called in a method of +obj1+ or +obj2+
+ */
+static VALUE kernel_swap_bang(VALUE self, VALUE obj1, VALUE obj2)
+{
+    // Save the definition of the old object
+    RVALUE old_obj;
+    memcpy(&old_obj, reinterpret_cast<void*>(obj1), SLOT_SIZE);
+    // Place the definition of the new object in the slot of the old one
+    memcpy(reinterpret_cast<void*>(obj1), reinterpret_cast<void*>(obj2), SLOT_SIZE);
+    // Place the definition of the old object in the slot of the new one
+    memcpy(reinterpret_cast<void*>(obj2), &old_obj, SLOT_SIZE);
+
+    return Qnil;
+}
+
+extern "C" void Init_swap()
+{
+    rb_define_singleton_method(rb_mKernel, "swap!", RUBY_METHOD_FUNC(kernel_swap_bang), 2);
+}
+

data/ext/value_set.cc

@@ -0,0 +1,290 @@
+#include <ruby.h>
+#include <set>
+#include <algorithm>
+
+#include <boost/tuple/tuple.hpp>
+
+using namespace boost;
+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)
+{
+    ValueSet* object = 0;
+    Data_Get_Struct(self, ValueSet, object);
+    return *object;
+}
+
+static void value_set_mark(ValueSet const* set) { std::for_each(set->begin(), set->end(), rb_gc_mark); }
+static void value_set_free(ValueSet const* set) { delete set; }
+static VALUE value_set_alloc(VALUE klass)
+{
+    ValueSet* cxx_set = new ValueSet;
+    return Data_Wrap_Struct(klass, value_set_mark, value_set_free, cxx_set);
+}
+/* call-seq:
+ *  set.empty?			    => true or false
+ *
+ * Checks if this set is empty
+ */
+static VALUE value_set_empty_p(VALUE self)
+{ 
+    ValueSet& set = get_wrapped_set(self);
+    return set.empty() ? Qtrue : Qfalse;
+}
+
+/* call-seq:
+ *  set.size			    => size
+ *
+ * Returns this set size
+ */
+static VALUE value_set_size(VALUE self)
+{ 
+    ValueSet& set = get_wrapped_set(self);
+    return INT2NUM(set.size());
+}
+
+
+/* call-seq:
+ *  set.each { |obj| ... }	    => set
+ *
+ */
+static VALUE value_set_each(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++;
+	rb_yield(*this_it);
+    }
+    return self;
+}
+/* call-seq:
+ *  set.include?(value)	    => true or false
+ *
+ * Checks if +value+ is in +set+
+ */
+static VALUE value_set_include_p(VALUE vself, VALUE vother)
+{
+    ValueSet const& self  = get_wrapped_set(vself);
+    return self.find(vother) == self.end() ? Qfalse : Qtrue;
+}
+
+/* call-seq:
+ *  set.to_value_set		    => set
+ */
+static VALUE value_set_to_value_set(VALUE self) { return self; }
+
+/* call-seq:
+ *  set.include_all?(other)		=> true or false
+ *
+ * Checks if all elements of +other+ are in +set+
+ */
+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));
+    return std::includes(self.begin(), self.end(), other.begin(), other.end()) ? Qtrue : Qfalse;
+}
+
+/* call-seq:
+ *  set.union(other)		=> union_set
+ *  set | other			=> union_set
+ *
+ * Computes the union of +set+ and +other+. This operation is O(N + M)
+ * is +other+ is a ValueSet
+ */
+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));
+    
+    VALUE vresult = rb_funcall(cValueSet, id_new, 0);
+    ValueSet& result = get_wrapped_set(vresult);
+    std::set_union(self.begin(), self.end(), other.begin(), other.end(), 
+	    std::inserter(result, result.end()));
+    return vresult;
+}
+
+/* call-seq:
+ *  set.merge(other)		=> set
+ *
+ * Merges the elements of +other+ into +self+. If +other+ is a ValueSet, the operation is O(N + M)
+ */
+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));
+    
+    self.insert(other.begin(), other.end());
+    return vself;
+}
+
+/* call-seq:
+ *   set.intersection(other)	=> intersection_set
+ *   set & other		=> intersection_set
+ *
+ * Computes the intersection of +set+ and +other+. This operation
+ * is O(N + M) if +other+ is a ValueSet
+ */
+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));
+    
+    VALUE vresult = rb_funcall(cValueSet, id_new, 0);
+    ValueSet& result = get_wrapped_set(vresult);
+    std::set_intersection(self.begin(), self.end(), other.begin(), other.end(), 
+	    std::inserter(result, result.end()));
+    return vresult;
+}
+/* call-seq:
+ *   set.difference(other)	=> difference_set
+ *   set - other		=> difference_set
+ *
+ * Computes the set of all elements of +set+ not in +other+. This operation
+ * is O(N + M) if +other+ is a ValueSet
+ */
+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));
+    
+    VALUE vresult = rb_funcall(cValueSet, id_new, 0);
+    ValueSet& result = get_wrapped_set(vresult);
+    std::set_difference(self.begin(), self.end(), other.begin(), other.end(), 
+	    std::inserter(result, result.end()));
+    return vresult;
+}
+
+/* call-seq:
+ *  set.insert(value)		=> true or false
+ * 
+ * Inserts +value+ into +set+. Returns true if the value did not exist
+ * in the set yet (it has actually been inserted), and false otherwise.
+ * This operation is O(log N)
+ */
+static VALUE value_set_insert(VALUE vself, VALUE v)
+{
+    ValueSet& self  = get_wrapped_set(vself);
+    bool exists;
+    tie(tuples::ignore, exists) = self.insert(v);
+    return exists ? Qtrue : Qfalse;
+}
+/* call-seq:
+ *  set.delete(value)		=> true or false
+ * 
+ * Removes +value+ from +set+. Returns true if the value did exist
+ * in the set yet (it has actually been removed), and false otherwise.
+ */
+static VALUE value_set_delete(VALUE vself, VALUE v)
+{
+    ValueSet& self  = get_wrapped_set(vself);
+    size_t count = self.erase(v);
+    return count > 0 ? Qtrue : Qfalse;
+}
+
+/* call-seq:
+ *  set == other		=> true or false
+ *
+ * Equality
+ */
+static VALUE value_set_equal(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));
+    return (self == other) ? Qtrue : Qfalse;
+}
+
+/* call-seq:
+ *  set.clear			=> set
+ *
+ * Remove all elements of this set
+ */
+static VALUE value_set_clear(VALUE self)
+{
+    get_wrapped_set(self).clear();
+    return self;
+}
+
+/* call-seq:
+ *  set.initialize_copy(other)  => set
+ *
+ * Initializes +set+ with the values in +other+. Needed by #dup
+ */
+static VALUE value_set_initialize_copy(VALUE vself, VALUE vother)
+{
+    ValueSet const& other = get_wrapped_set(rb_funcall(vother, id_to_value_set, 0));
+    set<VALUE> new_set(other.begin(), other.end());
+    get_wrapped_set(vself).swap(new_set);
+    return vself;
+}
+
+
+
+
+
+
+
+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
+ *
+ * Builds a ValueSet object from this enumerable
+ */
+static VALUE enumerable_to_value_set(VALUE self)
+{
+    VALUE vresult = rb_funcall(cValueSet, id_new, 0);
+    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;
+}
+
+/*
+ * Document-class: ValueSet
+ *
+ * ValueSet is a wrapper around the C++ set<> template. set<> is an ordered container,
+ * for which union(), intersection() and difference() is done in linear time. For performance
+ * reasons, in the case of ValueSet, the values are ordered by their VALUE, which roughly is
+ * their object_id.
+ */
+
+extern "C" void Init_value_set()
+{
+    rb_define_method(rb_mEnumerable, "to_value_set", RUBY_METHOD_FUNC(enumerable_to_value_set), 0);
+
+    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, "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);
+    rb_define_method(cValueSet, "delete", RUBY_METHOD_FUNC(value_set_delete), 1);
+    rb_define_method(cValueSet, "==", RUBY_METHOD_FUNC(value_set_equal), 1);
+    rb_define_method(cValueSet, "to_value_set", RUBY_METHOD_FUNC(value_set_to_value_set), 0);
+    rb_define_method(cValueSet, "empty?", RUBY_METHOD_FUNC(value_set_empty_p), 0);
+    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);
+}
+
+