utilrb 1.3.3 → 1.4.0

data/History.txt

@@ -1,3 +1,20 @@
+=== Version 1.4.0
+
+* release the latest git version. utilrb has not seen any release for a very
+  long time, and did not move so much anyway. The reason for this release is
+  mainly to fix rubygem installation between older rubygem version and newest
+  ruby version
+
+=== Version 1.3.4
+
+* fixes a minor problem with PkgConfig handling on broken installations.
+  pkg-config is picky about all dependencies being installed on the system.
+  The issue is that pkg-config --list-all will stop in the middle of the
+  enumeration if one of the packages misses some dependencies.
+  PkgConfig.has_package? was using --list-all through PkgConfig.each_package,
+  and therefore was wrongly returning false sometimes.
+  Moved it to pkg-config --exists, which works.
+
 === Version 1.3.3
 
 * fixed a problem with WeakRef crashing on 1.8.7p172. This version of weakref

data/Manifest.txt

@@ -17,6 +17,8 @@ lib/utilrb/array.rb
 lib/utilrb/array/to_s.rb
 lib/utilrb/column_formatter.rb
 lib/utilrb/common.rb
+lib/utilrb/configsearch.rb
+lib/utilrb/configsearch/configuration_finder.rb
 lib/utilrb/dir.rb
 lib/utilrb/dir/empty.rb
 lib/utilrb/enumerable.rb
@@ -30,23 +32,29 @@ lib/utilrb/exception/full_message.rb
 lib/utilrb/gc.rb
 lib/utilrb/gc/force.rb
 lib/utilrb/hash.rb
+lib/utilrb/hash/recursive_merge.rb
 lib/utilrb/hash/slice.rb
 lib/utilrb/hash/to_s.rb
 lib/utilrb/hash/to_sym_keys.rb
 lib/utilrb/kernel.rb
 lib/utilrb/kernel/arity.rb
+lib/utilrb/kernel/load_dsl_file.rb
 lib/utilrb/kernel/options.rb
 lib/utilrb/kernel/poll.rb
 lib/utilrb/kernel/require.rb
 lib/utilrb/kernel/swap.rb
+lib/utilrb/kernel/with_module.rb
 lib/utilrb/logger.rb
 lib/utilrb/logger/forward.rb
 lib/utilrb/logger/hierarchy.rb
+lib/utilrb/logger/io.rb
+lib/utilrb/marshal/load_with_missing_constants.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/cached_enum.rb
+lib/utilrb/module/const_defined_here_p.rb
 lib/utilrb/module/define_method.rb
 lib/utilrb/module/define_or_reuse.rb
 lib/utilrb/module/include.rb
@@ -54,6 +62,7 @@ lib/utilrb/module/inherited_enumerable.rb
 lib/utilrb/object.rb
 lib/utilrb/object/address.rb
 lib/utilrb/object/attribute.rb
+lib/utilrb/object/scoped_eval.rb
 lib/utilrb/object/singleton_class.rb
 lib/utilrb/objectstats.rb
 lib/utilrb/pkgconfig.rb
@@ -61,6 +70,7 @@ lib/utilrb/set.rb
 lib/utilrb/set/to_s.rb
 lib/utilrb/socket/tcp_server.rb
 lib/utilrb/socket/tcp_socket.rb
+lib/utilrb/symbol/to_str.rb
 lib/utilrb/time.rb
 lib/utilrb/time/to_hms.rb
 lib/utilrb/unbound_method.rb
@@ -69,6 +79,7 @@ lib/utilrb/value_set.rb
 lib/utilrb/weakref.rb
 patches/gc_live_objects.patch
 test/data/test_pkgconfig.pc
+test/data/test_pkgconfig_empty.pc
 test/test_array.rb
 test/test_config.rb
 test/test_dir.rb

data/README.txt

@@ -1,7 +1,9 @@
-Utilrb
-    http://utilrb.rubyforge.org
-    http://www.rubyforge.org/projects/utilrb
-    http://github.com/doudou/util-rb (git repository)
+= Utilrb
+http://utilrb.rubyforge.org
+http://www.rubyforge.org/projects/utilrb
+http://github.com/doudou/util-rb (git repository)
+
+== License
 
 Copyright (c) 2006-2008
     Sylvain Joyeux <sylvain.joyeux@m4x.org>
@@ -10,10 +12,12 @@ Copyright (c) 2006-2008
 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.
+the standard class extensions I use in other projects.
 
 == Installation
+
 The only dependency Utilrb has is flexmock if you want to run tests. It is
 available as a gem, so you can run
 

data/Rakefile

@@ -1,49 +1,53 @@
 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 './lib/utilrb/common'
 
 begin
     require 'hoe'
-    config = Hoe.new('utilrb', Utilrb::VERSION) do |p|
-        p.developer("Sylvain Joyeux", "sylvain.joyeux@m4x.org")
 
-        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].map { |l| l.strip }
-        p.changes     = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+    hoe_spec = Hoe.spec 'utilrb' do
+        developer "Sylvain Joyeux", "sylvain.joyeux@m4x.org"
+        extra_deps <<
+            ['facets', '>= 2.4.0'] <<
+            ['rake', '>= 0']
+
+        extra_dev_deps <<
+            ['flexmock', '>= 0.8.6']
 
-        p.extra_deps << ['facets', '>= 2.4.0'] << 'rake'
+        self.summary = 'Yet another Ruby toolkit'
+        self.description = paragraphs_of('README.txt', 3..5).join("\n\n")
     end
-    config.spec.extensions << 'ext/extconf.rb'
-rescue LoadError
-    STDERR.puts "cannot load the Hoe gem. Distribution is disabled"
+    hoe_spec.spec.extensions << 'ext/extconf.rb'
+    Rake.clear_tasks(/^default$/)
+    Rake.clear_tasks(/publish_docs/)
+
 rescue Exception => e
-    STDERR.puts "cannot load the Hoe gem, or Hoe fails. Distribution is disabled"
-    STDERR.puts "error message is: #{e.message}"
+    if e.message !~ /\.rubyforge/
+        STDERR.puts "WARN: cannot load the Hoe gem, or Hoe fails. Publishing tasks are disabled"
+        STDERR.puts "WARN: error message is: #{e.message}"
+    end
 end
 
-RUBY = RbConfig::CONFIG['RUBY_INSTALL_NAME']
+task :default => :setup
+
 desc "builds Utilrb's C extension"
 task :setup do
     Dir.chdir("ext") do
-	if !system("#{RUBY} extconf.rb") || !system("make")
+	if !system("#{FileUtils::RUBY} extconf.rb") || !system("make")
 	    raise "cannot build the C extension"
 	end
     end
     FileUtils.ln_sf "../ext/utilrb_ext.so", "lib/utilrb_ext.so"
 end
 
+task 'publish_docs' => 'redocs' do
+    if !system('./update_github')
+        raise "cannot update the gh-pages branch for GitHub"
+    end
+    if !system('git', 'push', 'github', '+gh-pages')
+        raise "cannot push the documentation"
+    end
+end
+
 task :clean do
     puts "Cleaning extension in ext/"
     FileUtils.rm_f "lib/utilrb_ext.so"
@@ -63,27 +67,3 @@ task :full_test do
     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/ext/extconf.rb

@@ -5,6 +5,19 @@ if RUBY_VERSION >= "1.9"
     $CFLAGS += " -DRUBY_IS_19"
 end
 
-$LDFLAGS += "-module"
+$LDFLAGS += " -module"
 create_makefile("utilrb_ext")
 
+## 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/value_set.cc

@@ -165,6 +165,26 @@ static VALUE value_set_merge(VALUE vself, VALUE vother)
     return vself;
 }
 
+/* call-seq:
+ *   set.intersection!(other)	=> set
+ *
+ * Computes the intersection of +set+ and +other+, and modifies +self+ to be
+ * that interesection. This operation is O(N + M) if +other+ is a ValueSet
+ */
+static VALUE value_set_intersection_bang(VALUE vself, VALUE vother)
+{
+    ValueSet& 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 result;
+    std::set_intersection(self.begin(), self.end(), other.begin(), other.end(), 
+	    std::inserter(result, result.end()));
+    self.swap(result);
+    return vself;
+}
+
 /* call-seq:
  *   set.intersection(other)	=> intersection_set
  *   set & other		=> intersection_set
@@ -216,12 +236,32 @@ static VALUE value_set_intersects(VALUE vself, VALUE vother)
     return Qfalse;
 }
 
+/* call-seq:
+ *   set.difference!(other)	=> set
+ *
+ * Modifies +set+ so that it is the set of all elements of +set+ not in +other+.
+ * This operation is O(N + M).
+ */
+static VALUE value_set_difference_bang(VALUE vself, VALUE vother)
+{
+    ValueSet& 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 result;
+    std::set_difference(self.begin(), self.end(), other.begin(), other.end(), 
+	    std::inserter(result, result.end()));
+    self.swap(result);
+    return vself;
+}
+
 /* 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
+ * is O(N + M).
  */
 static VALUE value_set_difference(VALUE vself, VALUE vother)
 {
@@ -371,8 +411,10 @@ extern "C" void Init_value_set()
     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, "intersection!", RUBY_METHOD_FUNC(value_set_intersection_bang), 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, "difference!", RUBY_METHOD_FUNC(value_set_difference_bang), 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);

data/lib/utilrb/array/to_s.rb

@@ -2,6 +2,7 @@ require 'utilrb/enumerable/to_s_helper'
 class Array
     # Displays arrays as [ a, b, [c, d], ... ] instead of the standard #join
     # Unlike #inspect, it calls #to_s on the elements too
+    undef_method :to_s
     def to_s
 	EnumerableToString.to_s_helper(self, '[', ']') do |obj|
 	    obj.to_s

data/lib/utilrb/common.rb

@@ -1,7 +1,8 @@
 module Utilrb
     unless defined? Utilrb::VERSION
-	VERSION = "1.3.3"
-	RUBY_IS_19 = (RUBY_VERSION >= "1.9")
+	VERSION = "1.4.0"
+        RUBY_IS_19  = (RUBY_VERSION >= "1.9.2")
+        RUBY_IS_191 = (RUBY_VERSION >= "1.9") && (RUBY_VERSION < "1.9.2")
     end
 
     unless defined? UTILRB_EXT_MODE

data/lib/utilrb/configsearch/configuration_finder.rb

@@ -0,0 +1,78 @@
+module Utilrb
+    # Find configuration files within the pathes given 
+    # by ROCK_CONFIG_PATH environment variable
+    #
+    class ConfigurationFinder
+
+        # Find a file by searching through paths defined by an environment variable
+        # and a given package directory. Package name is appended to all pathes found
+        # in the environment
+        # 
+        # Returns the path to the file on success, otherwise nil
+        def self.findWithEnv(filename, pkg_name, environment_search_path)
+            if environment_search_path
+                env_var = ENV[environment_search_path]
+                # Extract search path from environment variable
+                configuration_path = Array.new
+                env_var.split(':').each do | path |
+                    # Extract path and append package name folder
+                    configuration_path << File.join(path.gsub(/:$/,''), pkg_name)
+                end
+            end
+
+            if configuration_path == nil
+                raise "ConfigurationFinder: Environment variable #{environment_search_path} is not set!\n" 
+            else 
+                configuration = search(filename, configuration_path)
+            end
+
+            configuration
+        end
+
+        # Search for a file within [ $ROCK_CONFIG_PATH ]/<packagename>/ 
+        # Will not perform a recursive search   
+        #
+        # Returns the path to the file on success, otherwise nil
+        def self.find(filename, pkg_name)
+            findWithEnv(filename, pkg_name, 'ROCK_CONFIG_PATH')
+        end
+
+        # Search for a file only in the given search directories
+        #
+        # Returns the path to the file on success, otherwise nil
+        def self.search(filename, search_dirs)
+            search_dirs.each do |path|
+                file = File.join(path,filename)
+                if File.exist?(file)
+                    return file
+                end
+            end
+            return 
+        end
+
+        # Search for a file using the system id (<basename>_<id>) 
+        # 
+        # returns the configuration found in [ $ROCK_CONFIG_PATH ]/<basename>/<id>/, performs
+        # a fallback search in <basename> and returns nil if no config could
+        # be found 
+        def self.findSystemConfig(filename, system_id)
+            id_components = system_id.split('_')
+
+            if(id_components.size != 2)
+                raise "ConfigurationFinder: Invalid system identifier #{system_id} provided. " +
+                      "Use <basename>_<id>"
+            end
+
+            base_pkg_name = id_components[0]
+            id_pkg_name = File.join(base_pkg_name, id_components[1])
+            system_config = find(filename, id_pkg_name)
+
+            if !system_config
+                system_config = find(filename, base_pkg_name)
+            end
+
+            system_config
+        end
+    end
+
+end

data/lib/utilrb/configsearch.rb

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

data/lib/utilrb/hash/recursive_merge.rb

@@ -0,0 +1,26 @@
+class Hash
+    def recursive_merge(hash, &block)
+        merge(hash) do |k, v1, v2|
+            if v1.kind_of?(Hash) && v2.kind_of?(Hash)
+                v1.recursive_merge(v2, &block)
+            elsif block_given?
+                yield(k, v1, v2)
+            else
+                v2
+            end
+        end
+    end
+
+    def recursive_merge!(hash, &block)
+        merge!(hash) do |k, v1, v2|
+            if v1.kind_of?(Hash) && v2.kind_of?(Hash)
+                v1.recursive_merge!(v2, &block)
+            elsif block_given?
+                yield(k, v1, v2)
+            else
+                v2
+            end
+        end
+    end
+end
+

data/lib/utilrb/hash/to_s.rb

@@ -2,6 +2,7 @@ require 'utilrb/enumerable/to_s_helper'
 class Hash
     # Displays hashes as { a => A, b => B, ... } instead of the standard #join
     # Unlike #inspect, it calls #to_s on the elements too
+    undef_method :to_s
     def to_s
 	EnumerableToString.to_s_helper(self, '{', '}') do |k, v| 
 	    "#{k} => #{v}" 

data/lib/utilrb/kernel/load_dsl_file.rb

@@ -0,0 +1,187 @@
+require 'utilrb/common'
+require 'utilrb/object/singleton_class'
+require 'utilrb/kernel/with_module'
+
+module Kernel
+    def self.backtrace_remove_first_occurence_of(e, rx)
+        # Remove the first occurence of eval_dsl_file_content in the backtrace
+        backtrace = e.backtrace.dup
+        found = false
+        backtrace.delete_if do |line|
+            break if found
+            line =~ rx
+            found = true
+        end
+        raise e, e.message, e.backtrace
+    end
+
+    def load_dsl_filter_backtrace(file, full_backtrace = false, *exceptions)
+        # Compute the position of the dsl-loading method that called us, so that
+        # we don't touch anything below that while we are filtering the
+        # backtrace
+        if !full_backtrace
+            callers = caller
+            our_frame_pos = caller.size
+            callers.each do |line|
+                if line != /load_dsl_file\.rb/
+                    our_frame_pos -= 1
+                else
+                    break
+                end
+            end
+        end
+
+        yield
+
+    rescue Exception => e
+        raise e if full_backtrace
+        if exceptions.any? { |e_class| e.kind_of?(e_class) }
+            raise e
+        end
+
+        backtrace = e.backtrace.dup
+        message   = e.message.dup
+
+        # Filter out the message ... it can contain backtrace information as
+        # well (!)
+        message = message.split("\n").map do |line|
+            if line =~ /^.*:\d+(:.*)$/
+                backtrace.unshift line
+                nil
+            else
+                line
+            end
+        end.compact.join("\n")
+
+
+        if message.empty?
+            message = backtrace.shift
+            if message =~ /^(\s*[^\s]+:\d+:)\s*(.*)/
+                location = $1
+                message  = $2
+                backtrace.unshift location
+            else
+                backtrace.unshift message
+            end
+        end
+
+        filtered_backtrace = backtrace[0, backtrace.size - our_frame_pos].
+            map do |line|
+                line.gsub! /:in `.*dsl.*'/, ''
+                if line =~ /load_dsl_file.*(method_missing|send)/
+                    next
+                end
+
+                if line =~ /(load_dsl_file\.rb|with_module\.rb):\d+/
+                    next
+                else
+                    line
+                end
+            end.compact
+
+
+        backtrace = (filtered_backtrace[0, 1] + filtered_backtrace + backtrace[(backtrace.size - our_frame_pos)..-1])
+        raise e, message, backtrace
+    end
+
+    def eval_dsl_block(block, proxied_object, context, full_backtrace, *exceptions)
+        load_dsl_filter_backtrace(nil, full_backtrace, *exceptions) do
+            proxied_object.with_module(*context, &block)
+            true
+        end
+    end
+
+    def eval_dsl_file_content(file, file_content, proxied_object, context, full_backtrace, *exceptions, &block)
+        code = with_module(*context) do
+            code =  <<-EOD
+            Proc.new { #{file_content} }
+            EOD
+            eval code, binding, file, 1
+        end
+
+        dsl_exec_common(file, proxied_object, context, full_backtrace, *exceptions, &code)
+    end
+
+    # Load the given file by eval-ing it in the provided binding. The
+    # originality of this method is to translate errors that are detected in the
+    # eval'ed code into errors that refer to the provided file
+    #
+    # The caller of this method should call it at the end of its definition
+    # file, or the translation method may not be robust at all
+    def eval_dsl_file(file, proxied_object, context, full_backtrace, *exceptions, &block)
+        if !File.readable?(file)
+            raise ArgumentError, "#{file} does not exist"
+        end
+
+        loaded_file = file.gsub(/^#{Regexp.quote(Dir.pwd)}\//, '')
+        file_content = File.read(file)
+        eval_dsl_file_content(loaded_file, file_content, proxied_object, context, full_backtrace, *exceptions, &block)
+    end
+
+    # Same than eval_dsl_file, but will not load the same file twice
+    def load_dsl_file(file, *args, &block)
+        file = File.expand_path(file)
+        if $LOADED_FEATURES.include?(file)
+            return false
+        end
+
+        eval_dsl_file(file, *args, &block)
+        $LOADED_FEATURES << file
+        true
+    end
+
+    def dsl_exec(proxied_object, context, full_backtrace, *exceptions, &code)
+        dsl_exec_common(nil, proxied_object, context, full_backtrace, *exceptions, &code)
+    end
+
+    def dsl_exec_common(file, proxied_object, context, full_backtrace, *exceptions, &code)
+        load_dsl_filter_backtrace(file, full_backtrace, *exceptions) do
+            sandbox = with_module(*context) do
+                Class.new do
+                    attr_accessor :main_object
+                    def initialize(obj); @main_object = obj end
+                    def method_missing(*m, &block)
+                        main_object.send(*m, &block)
+                    end
+                end
+            end
+
+            old_constants, new_constants = nil
+            if !Utilrb::RUBY_IS_191
+                old_constants = Kernel.constants
+            end
+
+            sandbox = sandbox.new(proxied_object)
+            sandbox.with_module(*context) do
+                old_constants =
+                    if respond_to?(:constants)
+                        constants
+                    else  self.class.constants
+                    end
+
+                instance_eval(&code)
+
+                new_constants =
+                    if respond_to?(:constants)
+                        constants
+                    else  self.class.constants
+                    end
+            end
+
+            # Check if the user defined new constants by using class K and/or
+            # mod Mod
+            if !Utilrb::RUBY_IS_191
+                new_constants = Kernel.constants
+            end
+
+            new_constants -= old_constants
+            new_constants.delete_if { |n| n.to_s == 'WithModuleConstResolutionExtension' }
+            if !new_constants.empty?
+                msg = "#{new_constants.first} does not exist. You cannot define new constants in this context"
+                raise NameError.new(msg, new_constants.first)
+            end
+            true
+        end
+    end
+end
+

data/lib/utilrb/kernel/options.rb

@@ -17,11 +17,20 @@ module Kernel
     #   filter_options(nil, known_options) -> default_options, {}
     #
     def filter_options(options, option_spec)
+        unknown_options = Hash.new
+        options = options.dup
+        options.delete_if do |key, value|
+            if !key.respond_to?(:to_sym)
+                unknown_options[key] = value
+                true
+            end
+        end
+
         options     = (options.to_hash || Hash.new).to_sym_keys
 	# cannot use #to_sym_keys as option_spec can be an array
 	option_spec = option_spec.inject({}) { |h, (k, v)| h[k.to_sym] = v; h }
 
-	unknown_options = options.slice(*(options.keys - option_spec.keys))
+	unknown_options.merge!(options.slice(*(options.keys - option_spec.keys)))
 	known_options   = options.slice(*option_spec.keys)
 
         # Set default values defined in the spec