utilrb 1.6.6 → 2.0

data/Manifest.txt

@@ -2,18 +2,19 @@
 History.txt
 License.txt
 Manifest.txt
-README.txt
+README.rd
 Rakefile
 bm/allocation.rb
 bm/speed.rb
-ext/extconf.rb
-ext/proc.cc
-ext/ruby_internals-1.8.h
-ext/ruby_internals-1.9.h
-ext/swap.cc
-ext/utilrb_ext.cc
-ext/value_set.cc
-ext/weakref.cc
+ext/utilrb/extconf.rb
+ext/utilrb/proc.c
+ext/utilrb/ruby_internals-1.8.h
+ext/utilrb/ruby_internals-1.9.h
+ext/utilrb/ruby_allocator.hh
+ext/utilrb/swap.cc
+ext/utilrb/utilrb.cc
+ext/utilrb/value_set.cc
+ext/utilrb/weakref.cc
 lib/utilrb.rb
 lib/utilrb/array.rb
 lib/utilrb/array/to_s.rb

data/README.rd

@@ -0,0 +1,23 @@
+= Utilrb
+
+homepage :: http://rock-robotics.org
+mailing list :: http://www.dfki.de/mailman/cgi-bin/listinfo/rock-dev
+bug tracker :: trac.rock-robotics.org
+rubygem page :: http://rubygems.org/gems/utilrb
+git repository :: http://gitorious.org/orocos-toolchain/utilrb.git
+API documentation :: http://rubydoc.info/gems/utilrb/1.6.6/frames
+
+== DESCRIPTION
+
+Utilrb is yet another Ruby toolkit, in the spirit of facets. It includes all
+the standard class extensions I use in other projects.
+
+== LICENSE
+
+Copyright (c) 2006-2013
+    Sylvain Joyeux <sylvain.joyeux@m4x.org>
+    DFKI <robotics@dfki.de>
+    LAAS/CNRS <openrobots@laas.fr>
+
+This work is licensed under the BSD license. See License.txt for details
+

data/Rakefile

@@ -1,56 +1,59 @@
+$LOAD_PATH.unshift File.expand_path('lib', File.dirname(__FILE__))
 require 'rake'
-require './lib/utilrb/common'
-require './lib/utilrb/rake_common'
-require './lib/utilrb/doc/rake'
 
-Utilrb::Rake.hoe do
+begin 
+    require 'hoe'
+
+    Hoe::plugin :yard
+
     hoe_spec = Hoe.spec 'utilrb' do
         developer "Sylvain Joyeux", "sylvain.joyeux@m4x.org"
+        self.readme_file = 'README.rd'
+
         extra_deps <<
             ['facets', '>= 2.4.0'] <<
-            ['rake', '>= 0']
+            ['rake',     '>= 0.9'] <<
+            ["rake-compiler",   "~> 0.8.0"] <<
+            ["hoe-yard",   ">= 0.1.2"]
 
         extra_dev_deps <<
-            ['flexmock', '>= 0.8.6']
-
-        self.summary = 'Yet another Ruby toolkit'
-        self.description = paragraphs_of('README.txt', 3..5).join("\n\n")
-    end
-    hoe_spec.spec.extensions << 'ext/extconf.rb'
-    Rake.clear_tasks(/^default$/)
-    Rake.clear_tasks(/doc/)
-end
+            ['flexmock', '>= 0.8.6'] <<
+            ['debugger-ruby_core_source', '>= 0']
 
-task :default => :setup
+        licenses << 'BSD'
 
-Utilrb.doc
+        spec_extras[:extensions] = FileList["ext/**/extconf.rb"]
+    end
 
-desc "builds Utilrb's C extension"
-task :setup do
-    Dir.chdir("ext") do
-	if !system("#{FileUtils::RUBY} extconf.rb") || !system("make")
-	    raise "cannot build the C extension"
-	end
+    require 'rubygems/package_task'
+    Gem::PackageTask.new(hoe_spec.spec) do |pkg|
+        pkg.need_zip = true
+        pkg.need_tar = true
     end
-    FileUtils.ln_sf "../ext/utilrb_ext.so", "lib/utilrb_ext.so"
-end
 
-task :clean do
-    puts "Cleaning extension in ext/"
-    FileUtils.rm_f "lib/utilrb_ext.so"
-    if File.file?(File.join('ext', 'Makefile'))
-        Dir.chdir("ext") do
-            system("make clean")
-        end
+    require 'rake/extensiontask'
+    utilrb_task = Rake::ExtensionTask.new('utilrb', hoe_spec.spec) do |ext|
+        ext.name = 'utilrb'
+        ext.ext_dir = 'ext/utilrb'
+        ext.lib_dir = 'lib/utilrb'
+        ext.config_options << "-DRUBINIUS"
+        ext.source_pattern ="*.{c,cc,cpp}"
     end
-    FileUtils.rm_f "ext/Makefile"
-    FileUtils.rm_f "lib/utilrb_ext.so"
+
+    Rake.clear_tasks(/^default$/)
+    task :default => :compile
+
+    task :docs => :yard
+    task :redocs => :yard
+
+
+rescue LoadError => e
+    puts "'utilrb' cannot be build -- loading gem failed: #{e}"
 end
 
 task :full_test do
-    ENV['UTILRB_EXT_MODE'] = 'no'
-    system("testrb test/")
+    ENV.delete_if { |name,val| name == "UTILRB_EXT_MODE" }
+    system('testrb -I. test')
     ENV['UTILRB_EXT_MODE'] = 'yes'
-    system("testrb test/")
+    system('testrb -I. test')
 end
-

data/ext/utilrb/extconf.rb

@@ -0,0 +1,36 @@
+require 'mkmf'
+
+CONFIG['LDSHARED'].gsub! '$(CC)', "$(CXX)"
+if try_link("int main() { }", "-module")
+    $LDFLAGS += " -module"
+end
+
+if RUBY_VERSION >= "1.9"
+    $CFLAGS += " -DRUBY_IS_19"
+    begin
+        require 'debugger/ruby_core_source'
+        $CFLAGS += " -DHAS_RUBY_SOURCE"
+        hdrs = lambda { try_compile("#include <vm_core.h>") }
+        Debugger::RubyCoreSource.create_makefile_with_core(hdrs, "utilrb/utilrb")
+    rescue LoadError
+        puts "not building with core source"
+        create_makefile("utilrb/utilrb")
+    end
+else
+    puts "not building with core source"
+    create_makefile("utilrb/utilrb")
+end
+
+## WORKAROUND a problem with mkmf.rb
+# It seems that the newest version do define an 'install' target. However, that
+# install target tries to install in the system directories
+#
+# The issue is that RubyGems *does* call make install. Ergo, gem install utilrb
+# is broken right now
+#lines = File.readlines("Makefile")
+#lines.delete_if { |l| l =~ /^install:/ }
+#lines << "install:"
+#File.open("Makefile", 'w') do |io|
+#      io.write lines.join("\n")
+#end
+

data/ext/{proc.cc → utilrb/proc.c}

@@ -1,7 +1,5 @@
 #ifdef HAS_RUBY_SOURCE
-extern "C" {
-#include "/usr/include/ruby-1.9.1/ruby-1.9.3-p0/vm_core.h"
-}
+#include <vm_core.h>
 
 static VALUE env_references(VALUE rbenv)
 {
@@ -11,7 +9,8 @@ static VALUE env_references(VALUE rbenv)
     GetEnvPtr(rbenv, env);
     if (env->env)
     {
-        for (int i = 0; i < env->env_size; ++i)
+        int i;
+        for (i = 0; i < env->env_size; ++i)
             rb_ary_push(result, rb_obj_id(env->env[i]));
     }
     return result;
@@ -26,11 +25,13 @@ static VALUE proc_references(VALUE rbproc)
         return env_references(proc->envval);
     return rb_ary_new();
 }
+#elif RUBY_IS_19
+#warning "Ruby core sources cannot be found, Proc#references will not be available. Install the debugger-ruby_core_source gem to enable"
 #else
-#warning "RUBY_SOURCE_DIR is not set, Proc#references will not be available"
+#warning "compiling on Ruby 1.8, Proc#references will not be available"
 #endif
 
-extern "C" void Init_proc()
+void Init_proc()
 {
 #ifdef HAS_RUBY_SOURCE
     rb_define_method(rb_cProc, "references", RUBY_METHOD_FUNC(proc_references), 0);

data/ext/utilrb/ruby_allocator.hh

@@ -0,0 +1,76 @@
+#ifndef RUBY_ALLOCATOR_HH
+#define RUBY_ALLOCATOR_HH
+
+#include <ruby.h>
+
+template <class T> class ruby_allocator
+{
+public:
+  typedef T                 value_type;
+  typedef value_type*       pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type&       reference;
+  typedef const value_type& const_reference;
+  typedef std::size_t       size_type;
+  typedef std::ptrdiff_t    difference_type;
+  
+  template <class U> 
+  struct rebind { typedef ruby_allocator<U> other; };
+
+  ruby_allocator() {}
+  ruby_allocator(const ruby_allocator&) {}
+  template <class U> 
+  ruby_allocator(const ruby_allocator<U>&) {}
+  ~ruby_allocator() {}
+
+  pointer address(reference x) const { return &x; }
+  const_pointer address(const_reference x) const { 
+    return x;
+  }
+
+  pointer allocate(size_type n, const_pointer = 0) {
+    void* p = ruby_xmalloc(n * sizeof(T));
+    if (!p)
+      throw std::bad_alloc();
+    return static_cast<pointer>(p);
+  }
+
+  void deallocate(pointer p, size_type) { ruby_xfree(p); }
+
+  size_type max_size() const { 
+    return static_cast<size_type>(-1) / sizeof(T);
+  }
+
+  void construct(pointer p, const value_type& x) { 
+    new(p) value_type(x); 
+  }
+  void destroy(pointer p) { p->~value_type(); }
+
+private:
+  void operator=(const ruby_allocator&);
+};
+
+template<> class ruby_allocator<void>
+{
+  typedef void        value_type;
+  typedef void*       pointer;
+  typedef const void* const_pointer;
+
+  template <class U> 
+  struct rebind { typedef ruby_allocator<U> other; };
+};
+
+
+template <class T>
+inline bool operator==(const ruby_allocator<T>&, 
+                       const ruby_allocator<T>&) {
+  return true;
+}
+
+template <class T>
+inline bool operator!=(const ruby_allocator<T>&, 
+                       const ruby_allocator<T>&) {
+  return false;
+}
+
+#endif

data/ext/utilrb/utilrb.cc

@@ -0,0 +1,79 @@
+#include <ruby.h>
+#include <set>
+
+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); 
+    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;
+}
+
+/* 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))
+	return Qtrue;
+    else
+	return Qfalse;
+}
+
+static VALUE kernel_is_immediate(VALUE klass, VALUE object)
+{ return IMMEDIATE_P(object) ? Qtrue : Qfalse; }
+#endif
+
+static VALUE kernel_crash(VALUE klass)
+{
+    *((int*)0) = 10;
+    // Return something to shut gcc up
+    return Qfalse;
+}
+
+extern "C" void Init_value_set();
+extern "C" void Init_swap();
+extern "C" void Init_weakref(VALUE mUtilrb);
+extern "C" void Init_proc();
+
+extern "C" void Init_utilrb()
+{
+    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);
+
+    rb_define_singleton_method(rb_mKernel, "crash!", RUBY_METHOD_FUNC(kernel_crash), 0);
+    rb_define_singleton_method(rb_mKernel, "immediate?", RUBY_METHOD_FUNC(kernel_is_immediate), 1);
+
+    Init_swap();
+    Init_weakref(mUtilrb);
+#endif
+
+    Init_proc();
+
+    Init_value_set();
+}
+

data/ext/{value_set.cc → utilrb/value_set.cc}

@@ -1,13 +1,14 @@
 #include <ruby.h>
 #include <set>
 #include <algorithm>
+#include "ruby_allocator.hh"
 
 using namespace std;
 
 static VALUE cValueSet;
 static ID id_new;
 
-typedef std::set<VALUE> ValueSet;
+typedef std::set<VALUE, std::less<VALUE>, ruby_allocator<VALUE> > ValueSet;
 static ValueSet& get_wrapped_set(VALUE self)
 {
     ValueSet* object = 0;
@@ -252,7 +253,8 @@ static VALUE value_set_difference_bang(VALUE vself, VALUE vother)
     ValueSet result;
     std::set_difference(self.begin(), self.end(), other.begin(), other.end(), 
 	    std::inserter(result, result.end()));
-    self.swap(result);
+    if (result.size() != self.size())
+        self.swap(result);
     return vself;
 }
 
@@ -335,9 +337,7 @@ static VALUE value_set_clear(VALUE self)
  */
 static VALUE value_set_initialize_copy(VALUE vself, VALUE vother)
 {
-    ValueSet const& other = get_wrapped_set(vother);
-    set<VALUE> new_set(other.begin(), other.end());
-    get_wrapped_set(vself).swap(new_set);
+    get_wrapped_set(vself) = get_wrapped_set(vother);
     return vself;
 }
 

data/lib/utilrb/common.rb

@@ -1,17 +1,22 @@
+
+# Utilrb is yet another Ruby toolkit, in the spirit of facets. It includes all
+# the standard class extensions used by www.rock-robotics.org projects.
 module Utilrb
     unless defined? Utilrb::VERSION
-	VERSION = "1.6.6"
+	VERSION = "2.0"
         RUBY_IS_19  = (RUBY_VERSION >= "1.9.2")
         RUBY_IS_191 = (RUBY_VERSION >= "1.9") && (RUBY_VERSION < "1.9.2")
     end
 
+    LIB_DIR = File.expand_path(File.dirname(__FILE__))
+
     unless defined? UTILRB_EXT_MODE
 	if ENV['UTILRB_EXT_MODE'] == 'no'
 	    UTILRB_EXT_MODE = nil
 	    STDERR.puts "Utilrb: not loading the C extension"
 	else
 	    begin
-		require 'utilrb_ext'
+		require 'utilrb/utilrb'
 		UTILRB_EXT_MODE = true
 		STDERR.puts "Utilrb: loaded C extension" if ENV['UTILRB_EXT_MODE']
 	    rescue LoadError => e