utilrb 2.0.2.b2 → 2.1.0.rc1

data/lib/utilrb/logger/io.rb

@@ -8,13 +8,13 @@ class Logger
             @logger, @level = logger, level
             @buffer = ''
         end
-        def puts(msg)
+        def puts(*msg)
             print msg
             logger.send(level, @buffer)
             @buffer = ''
         end
-        def print(msg)
-            @buffer << msg
+        def print(*msg)
+            @buffer << msg.join("")
         end
     end
 

data/lib/utilrb/logger/root.rb

@@ -41,9 +41,15 @@ class Logger
     #
     def self.Root(progname, base_level, &block)
 	begin	
-	    base_level = ENV['BASE_LOG_LEVEL'].upcase.to_sym if ENV['BASE_LOG_LEVEL']
-	    base_level = ::Logger.const_get( base_level ) if base_level.is_a? Symbol
-	rescue Exception => e
+            if ENV['BASE_LOG_LEVEL']
+                env_level = ENV['BASE_LOG_LEVEL'].upcase.to_sym 
+                # there is currently no disabled level on the ruby side
+                # but fatal is the closest
+                env_level = :FATAL if env_level == :DISABLE
+                
+                base_level = ::Logger.const_get( env_level ) 
+            end
+	rescue Exception
 	    raise ArgumentError, "Log level #{base_level} is not available in the ruby Logger"
 	end
 
@@ -51,10 +57,10 @@ class Logger
         formatter =
             if block then lambda(&block)
             elsif HAS_COLOR
-                lambda do |severity, time, progname, msg|
-                    console.color("#{progname}[#{severity}]: #{msg}\n", *LEVEL_TO_COLOR[severity])
+                lambda do |severity, time, name, msg|
+                    console.color("#{name}[#{severity}]: #{msg}\n", *LEVEL_TO_COLOR[severity])
                 end
-            else lambda { |severity, time, progname, msg| "#{progname}[#{severity}]: #{msg}\n" }
+            else lambda { |severity, time, name, msg| "#{name}[#{severity}]: #{msg}\n" }
             end
 
         Module.new do

data/lib/utilrb/module/ancestor_p.rb

@@ -1,19 +1,7 @@
-require 'utilrb/common'
 class Module
     def has_ancestor?(klass) # :nodoc:
         self <= klass
     end
 end
-class Class
-    def has_ancestor?(klass) # :nodoc:
-        # We first test
-        #   self <= class
-        # as self.superclass goes to the next *CLASS* in the chain, i.e. skips
-        # included modules
-        #
-        # Then, the superclass test is used in case +self+ is a singleton
-        self <= klass || (superclass <= klass)
-    end
-end
 
 

data/lib/utilrb/module/is_singleton.rb

@@ -0,0 +1,6 @@
+require 'utilrb/module/singleton_class_p'
+puts "WARN Module#is_singleton? has been renamed to #singleton_class? to match the built-in method in Ruby 2.1+"
+puts "WARN require 'utilrb/module/singleton_class_p instead of is_singleton?"
+class Module
+    alias :is_singleton? :singleton_class?
+end

data/lib/utilrb/module/singleton_class_p.rb

@@ -0,0 +1,14 @@
+class Module
+    if !method_defined?(:singleton_class?)
+        # It so happens that this method to determine whether a class is a
+        # singleton class is valid for ruby 2.0 and breaks on 2.1 ... However
+        # (!) on 2.1 singleton_class? is defined
+        def singleton_class?
+            if instance_variable_defined?(:@__utilrb_singleton_class)
+                @__utilrb_singleton_class
+            else
+                @__utilrb_singleton_class = (ancestors.first == self)
+            end
+        end
+    end
+end

data/lib/utilrb/object/attribute.rb

@@ -1,68 +1,36 @@
-require 'utilrb/common'
-require 'utilrb/object/singleton_class'
-
-Utilrb.unless_ext do
-    class Object
-	# call-seq:
-	#   attribute :name => default_value
-	#   attribute(:name) { default_value }
-	#
-	# In the first form, defines a read-write attribute
-	# named 'name' with default_value for default value.
-	# In the second form, the block is called if the attribute
-	# is read before it has been ever written, and its return
-	# value is used as default value.
-	def attribute(attr_def, &init)
-	    if Hash === attr_def
-		name, defval = attr_def.to_a.flatten
-	    else
-		name = attr_def
-	    end
-
-	    class_eval do
-		attr_writer name
-		define_method("#{name}_defval") do
-		    defval || (instance_eval(&init) if init)
-		end
-	    end
-
-	    class_eval <<-EOD, __FILE__, __LINE__+1
-	    def #{name}
-		if defined? @#{name} then @#{name}
-		else @#{name} = #{name}_defval
-		end
-	    end
-	    EOD
-	end
-    end
-end
-
-Utilrb.if_ext do
-    class Object
-	def attribute(attr_def, &init) # :nodoc:
-	    if Hash === attr_def
-		name, defval = attr_def.to_a.flatten
-	    else
-		name = attr_def
-	    end
-
-	    class_eval do
-		attr_writer name
-		if !defval && init
-		    define_method("#{name}_defval", &init)
-		else
-		    define_method("#{name}_defval") { defval }
-		end
-	    end
-
-	    class_eval <<-EOD, __FILE__, __LINE__+1
-	    def #{name}
-		if instance_variable_defined?(:@#{name}) then @#{name}
-		else @#{name} = #{name}_defval
-		end
-	    end
-	    EOD
-	end
+class Object
+    # call-seq:
+    #   attribute :name => default_value
+    #   attribute(:name) { default_value }
+    #
+    # In the first form, defines a read-write attribute
+    # named 'name' with default_value for default value.
+    # In the second form, the block is called if the attribute
+    # is read before it has been ever written, and its return
+    # value is used as default value.
+    def attribute(attr_def, &init) # :nodoc:
+        if Hash === attr_def
+            name, defval = attr_def.to_a.flatten
+        else
+            name = attr_def
+        end
+
+        class_eval do
+            attr_writer name
+            if !defval && init
+                define_method("#{name}_defval", &init)
+            else
+                define_method("#{name}_defval") { defval }
+            end
+        end
+
+        class_eval <<-EOD, __FILE__, __LINE__+1
+        def #{name}
+            if instance_variable_defined?(:@#{name}) then @#{name}
+            else @#{name} = #{name}_defval
+            end
+        end
+        EOD
     end
 end
 

data/lib/utilrb/object/singleton_class.rb

@@ -1,20 +1 @@
-require 'utilrb/common'
-require 'utilrb/object/address'
-
-class Object
-    if !Object.new.respond_to?(:singleton_class)
-    # Returns the singleton class for this object.
-    #
-    # In Ruby 1.8, makes sure that the #superclass method of the singleton class 
-    # returns the object's class (instead of Class), as Ruby 1.9 does
-    #
-    # The first element of #ancestors on the returned singleton class is
-    # the singleton class itself. A #singleton_instance accessor is also
-    # defined, which returns the object instance the class is the singleton
-    # of.
-    def singleton_class
-        class << self; self end
-    end
-    end
-end
-
+puts "WARN: no need to require 'object/singleton_class' anymore, it is built-in since Ruby 1.9"

data/lib/utilrb/pkgconfig.rb

@@ -109,7 +109,8 @@ module Utilrb
                     requested_op.include?(pkg.version <=> requested_version)
                 end
                 if !result
-                    raise NotFound.new(name), "no version of #{name} match #{version_spect}. Available versions are: #{candidates.map(&:raw_version).join(", ")}"
+                    name = candidates.first.name
+                    raise NotFound.new(name), "no version of #{name} match #{version_spec}. Available versions are: #{candidates.map(&:raw_version).join(", ")}"
                 end
                 result
             else
@@ -215,7 +216,7 @@ module Utilrb
 
             running_line = nil
             @file = file.map do |line|
-                line.gsub! /\s*#.*$/, ''
+                line = line.gsub(/\s*#.*$/, '')
                 line = line.strip
                 next if line.empty?
 
@@ -260,14 +261,23 @@ module Utilrb
             raw_fields.each do |name, value|
                 if SHELL_VARS.include?(name) 
                     value = Shellwords.shellsplit(value)
-                    value.map! do |v|
-                        expand_variables(v, variables, name)
+                    resolved = Array.new
+                    while !value.empty?
+                        value = value.flat_map do |v|
+                            expanded = expand_variables(v, variables, name)
+                            if expanded == v
+                                resolved << v
+                                nil
+                            else
+                                Shellwords.shellsplit(expanded)
+                            end
+                        end.compact
                     end
+                    fields[name] = resolved
                 else
-                    value = expand_variables(value, variables, name)
+                    fields[name] = expand_variables(value, variables, name)
                 end
 
-                fields[name] = value
             end
 
             # Initialize the main flags
@@ -389,7 +399,7 @@ module Utilrb
         end
 
         def libs_only_other(static = false)
-            @ldflags[static].find_all { |s| s !~ /^-[lL]/ }.join(" ")
+            @ldflags_with_requires[static].find_all { |s| s !~ /^-[lL]/ }.join(" ")
         end
 
 	def method_missing(varname, *args, &proc) # :nodoc:
@@ -412,7 +422,7 @@ module Utilrb
             result = []
             each_pkgconfig_directory do |dir|
                 path = File.join(dir, "#{name}.pc")
-                if File.exists?(path)
+                if File.exist?(path)
                     result << path
                 end
             end
@@ -451,8 +461,8 @@ module Utilrb
         end
 
 
-        FOUND_PATH_RX = /Scanning directory '(.*\/)((?:lib|share)\/.*)'$/
-        NONEXISTENT_PATH_RX = /Cannot open directory '.*\/((?:lib|share)\/.*)' in package search path:.*/
+        FOUND_PATH_RX = /Scanning directory '(.*\/)((?:lib|lib64|share)\/.*)'$/
+        NONEXISTENT_PATH_RX = /Cannot open directory '.*\/((?:lib|lib64|share)\/.*)' in package search path:.*/
 
         # Returns the system-wide search path that is embedded in pkg-config
         def self.default_search_path
@@ -463,6 +473,7 @@ module Utilrb
             end
             return @default_search_path
         end
+        @default_search_path = nil
 
         # Returns the system-wide standard suffixes that should be appended to
         # new prefixes to find pkg-config files

data/lib/utilrb/socket/tcp_server.rb

@@ -1,7 +1,7 @@
 require 'socket'
 
 class TCPServer
-    def bound_addr; Socket::getnameinfo(getsockname)[0] end
-    def port; Socket::getnameinfo(getsockname)[1].to_i end
+    def bound_addr; Socket.unpack_sockaddr_in(getsockname)[1] end
+    def port; Socket.unpack_sockaddr_in(getsockname)[0] end
 end
 

data/lib/utilrb/spawn.rb

@@ -47,7 +47,7 @@ module Utilrb
                     Dir.chdir(workdir)
                 end
                 exec(*cmdline)
-            rescue Exception => e
+            rescue Exception
                 write.write("FAILED")
             end
         end

data/lib/utilrb/test.rb

@@ -0,0 +1,65 @@
+# simplecov must be loaded FIRST. Only the files required after it gets loaded
+# will be profiled !!!
+if ENV['TEST_ENABLE_COVERAGE'] != '0'
+    begin
+        require 'simplecov'
+        require 'coveralls'
+        SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+            SimpleCov::Formatter::HTMLFormatter,
+            Coveralls::SimpleCov::Formatter
+        ]
+        SimpleCov.start do
+            add_filter "/test/"
+        end
+    rescue LoadError
+        require 'utilrb'
+        Utilrb.warn "coverage is disabled because the 'simplecov' gem cannot be loaded"
+    rescue Exception => e
+        require 'utilrb'
+        Utilrb.warn "coverage is disabled: #{e.message}"
+    end
+end
+
+require 'utilrb'
+require 'minitest/autorun'
+require 'minitest/spec'
+
+if ENV['TEST_ENABLE_PRY'] != '0'
+    begin
+        require 'pry'
+    rescue Exception
+        Utilrb.warn "debugging is disabled because the 'pry' gem cannot be loaded"
+    end
+end
+
+BASE_TEST_DIR=File.expand_path('../../test', File.dirname(__FILE__))
+
+module Utilrb
+    # This module is the common setup for all tests
+    #
+    # It should be included in the toplevel describe blocks
+    #
+    # @example
+    #   require 'dummyproject/test'
+    #   describe Utilrb do
+    #     include Utilrb::SelfTest
+    #   end
+    #
+    module SelfTest
+        def setup
+            # Setup code for all the tests
+        end
+
+        def teardown
+            super
+            # Teardown code for all the tests
+        end
+    end
+end
+
+module Minitest
+    class Test
+        include Utilrb::SelfTest
+    end
+end
+

data/lib/utilrb/thread_pool.rb

@@ -492,7 +492,7 @@ module Utilrb
                 end
                 task.queued_at = Time.now
                 @tasks_waiting << task
-                if @waiting == 0 && @spawned < @max
+                if @waiting <= @tasks_waiting.size && @spawned < @max
                     spawn_thread
                 end
                 @cond.signal
@@ -506,10 +506,8 @@ module Utilrb
         # @param [boolean] force Trim even if no thread is waiting.
         def trim (force = false)
             @mutex.synchronize do
-                if (force || @waiting > 0) && @spawned - @trim_requests > @min
-                    @trim_requests += 1
-                    @cond.signal
-                end
+                @trim_requests += 1
+                @cond.signal
             end
             self
         end
@@ -571,8 +569,10 @@ module Utilrb
                             end
                             break task unless task.is_a? Array
 
-                            if @trim_requests > 0
-                                @trim_requests -= 1
+                            if @spawned > @min && (auto_trim || @trim_requests > 0)
+                                if @trim_requests > 0
+                                    @trim_requests -= 1
+                                end
                                 break
                             end
                             @waiting += 1
@@ -597,14 +597,12 @@ module Utilrb
                         current_task.finalize # propagate state after it was deleted from the internal lists
                         @callback_on_task_finished.call(current_task) if @callback_on_task_finished
                     end
-                    trim if auto_trim
                 end
 
-                # we do not have to lock here
-                # because spawn_thread must be called from
-                # a synchronized block
-                @spawned -= 1
-                @workers.delete thread
+                @mutex.synchronize do
+                    @spawned -= 1
+                    @workers.delete thread
+                end
             end
             @spawned += 1
             @workers << thread

data/lib/utilrb/timepoints.rb

@@ -1,5 +1,9 @@
 module Utilrb
     module Timepoints
+        def timepoints
+            @timepoints || Array.new
+        end
+
         def clear_timepoints
             @timepoints ||= Array.new
             @timepoints.clear
@@ -18,6 +22,17 @@ module Utilrb
             end
             result
         end
+
+        def merge_timepoints(other)
+            data =
+                if other.respond_to?(:to_ary)
+                    other.to_ary
+                else
+                    other.timepoints
+                end
+            @timepoints = (timepoints + data).sort_by(&:first)
+            self
+        end
     end
 end
 

data/lib/utilrb/value_set.rb

@@ -9,7 +9,16 @@ Utilrb.require_ext("ValueSet") do
 	alias :- :difference
 	include Enumerable
 
-	def to_s
+        def substract(other_set)
+            difference!(other_set.to_value_set)
+        end
+
+        def add(value)
+            insert(value)
+            self
+        end
+
+        def to_s
 	    elements = EnumerableToString.to_s_helper(self, '{', '}') do |obj|
 		obj.to_s
 	    end

data/lib/utilrb/version.rb

@@ -0,0 +1,4 @@
+module Utilrb
+    VERSION = "2.1.0.rc1"
+end
+

data/lib/utilrb/weakref.rb

@@ -1,17 +1,16 @@
-require 'utilrb/common'
+require 'weakref'
 
-Utilrb.require_ext("Utilrb::WeakRef") do
-    module Utilrb
-        class WeakRef
-            def initialize(obj)
-                if obj.kind_of?(WeakRef)
-                    raise ArgumentError, "cannot create a weakref of a weakref"
-                end
-                unless WeakRef.refcount(obj)
-                    ObjectSpace.define_finalizer(obj, self.class.method(:do_object_finalize))
-                end
-                do_initialize(obj)
+module Utilrb
+    class WeakRef < ::WeakRef
+        def initialize(obj)
+            if obj.kind_of?(::WeakRef)
+                raise ArgumentError, "cannot create a weakref of a weakref"
             end
+            super
+        end
+
+        def get
+            __getobj__
         end
     end
 end

data/lib/utilrb/yard.rb

@@ -2,117 +2,6 @@ require 'pp'
 module Utilrb
     module YARD
         include ::YARD
-        class InheritedAttributeHandler < YARD::Handlers::Ruby::AttributeHandler
-            handles method_call(:inherited_attribute)
-            namespace_only
-
-            def self.process(handler, name, attr_name, is_map, key_name = nil, return_type = nil)
-            end
-
-            def process
-                name = statement.parameters[0].jump(:tstring_content, :ident).source
-                if statement.parameters.size == 4
-                    attr_name = statement.parameters[1].jump(:tstring_content, :ident).source
-                else
-                    attr_name = name
-                end
-                options = statement.parameters.jump(:assoc)
-
-                is_map = false
-                if options != statement.parameters
-                    key = options[0].jump(:ident).source
-                    value = options[1].jump(:ident).source
-                    if key == "map" && value == "true"
-                        is_map = true
-                    end
-                end
-
-                key_type, value_type = nil
-
-                object = YARD::CodeObjects::MethodObject.new(namespace, attr_name, scope) do |o|
-                    o.dynamic = true
-                    o.aliases << "self_#{name}"
-                end
-                register(object)
-                key_name ||=
-                    if object.docstring.has_tag?('key_name')
-                        object.docstring.tag('key_name').text
-                    else
-                        'key'
-                    end
-                return_type ||=
-                    if object.docstring.has_tag?('return')
-                        object.docstring.tag('return').types.first
-                    elsif is_map
-                        'Hash<Object,Object>'
-                    else
-                        'Array<Object>'
-                    end
-                if return_type =~ /^\w+\<(.*)\>$/
-                    if is_map
-                        key_type, value_type = $1.split(',')
-                    else
-                        value_type = $1
-                    end
-                else
-                    key_type = "Object"
-                    value_type = "Object"
-                end
-
-                object = YARD::CodeObjects::MethodObject.new(namespace, "all_#{name}", scope)
-                object.dynamic = true 
-                register(object)
-                object.docstring.replace("The union, along the class hierarchy, of all the values stored in #{name}\n@return [Array<#{value_type}>]")
-
-                if is_map
-                    object = YARD::CodeObjects::MethodObject.new(namespace, "find_#{name}", scope)
-                    object.dynamic = true 
-                    register(object)
-                    object.parameters << [key_name]
-                    object.docstring.replace("
-Looks for objects registered in #{name} under the given key, and returns the first one in the ancestor chain
-(i.e. the one tha thas been registered in the most specialized class)
-                                             
-@return [#{value_type},nil] the found object, or nil if none is registered under that key")
-
-                    object = YARD::CodeObjects::MethodObject.new(namespace, "has_#{name}?", scope)
-                    object.dynamic = true 
-                    register(object)
-                    object.parameters << [key_name]
-                    object.docstring.replace("Returns true if an object is registered in #{name} anywhere in the class hierarchy\n@return [Boolean]")
-                    object.signature = "def has_#{name}?(key)"
-
-                    object = YARD::CodeObjects::MethodObject.new(namespace, "each_#{name}", scope)
-                    object.dynamic = true 
-                    register(object)
-                    object.parameters << [key_name, "nil"] << ["uniq", "true"]
-                    object.docstring.replace("
-@overload each_#{name}(#{key_name}, uniq = true)
-  Enumerates all objects registered in #{name} under the given key
-  @yield [element]
-  @yieldparam [#{value_type}] element
-@overload each_#{name}(nil, uniq = true)
-  Enumerates all objects registered in #{name}
-  @yield [#{key_name}, element]
-  @yieldparam [#{key_type}] #{key_name}
-  @yieldparam [#{value_type}] element
-                    ")
-                else
-                    object = YARD::CodeObjects::MethodObject.new(namespace, "each_#{name}", scope)
-                    object.dynamic = true 
-                    register(object)
-                    object.docstring.replace("Enumerates all objects registered in #{name}\n@return []\n@yield [element]\n@yieldparam [#{value_type}] element")
-                end
-
-                if is_map
-                    return key_type, value_type
-                else
-                    return value_type
-                end
-            end
-        end
-        YARD::Tags::Library.define_tag("Key for inherited_attribute(_, :map => true)", :key_name)
-
         class AttrEnumerableHandler < YARD::Handlers::Ruby::AttributeHandler
             handles method_call(:attr_enumerable)
             namespace_only

data/lib/utilrb.rb

@@ -1,2 +1,7 @@
 require 'utilrb/kernel/require'
-require_dir(__FILE__, /yard|doc|rake/)
+require 'utilrb/logger'
+module Utilrb
+    extend Logger::Root('Utilrb', Logger::WARN)
+end
+
+require_dir(__FILE__, /yard|doc|rake|test/)

data/lib/yard-utilrb.rb

@@ -0,0 +1 @@
+require 'utilrb/yard'