utilrb 1.3.3 → 1.4.0

data/lib/utilrb/kernel/with_module.rb

@@ -0,0 +1,53 @@
+require 'utilrb/common'
+module Kernel
+    if Utilrb::RUBY_IS_191
+    def with_module(*consts, &blk)
+        slf = self
+
+        l = if !block_given? && consts.last.respond_to?(:to_str)
+                eval_string = consts.pop
+                lambda { slf.instance_eval(eval_string) }
+            else
+                lambda { slf.instance_eval(&blk) }
+            end
+
+        consts.inject(l) {|l, k| lambda { k.class_eval(&l) } }.call
+    end
+    else
+    module WithModuleConstResolutionExtension
+        def const_missing(const_name)
+            if with_module_setup = Thread.current[:__with_module__]
+                if consts = with_module_setup.last
+                    consts.each do |mod|
+                        if mod.const_defined?(const_name)
+                            return mod.const_get(const_name)
+                        end
+                    end
+                end
+            end
+            super
+        end
+    end
+
+    def with_module(*consts, &block)
+        Thread.current[:__with_module__] ||= Array.new
+        Thread.current[:__with_module__].push consts
+        Kernel.send(:extend, WithModuleConstResolutionExtension)
+        Object.extend WithModuleConstResolutionExtension
+
+        eval_string =
+            if !block_given? && consts.last.respond_to?(:to_str)
+                consts.pop
+            end
+        if eval_string
+            instance_eval(eval_string)
+        else
+            instance_eval(&block)
+        end
+
+    ensure
+        Thread.current[:__with_module__].pop
+    end
+    end
+end
+

data/lib/utilrb/logger/hierarchy.rb

@@ -20,13 +20,29 @@ class Logger
     # be returned.
     module Hierarchy
         attr_writer :logger
+
+        def has_own_logger?
+            defined?(@logger) && @logger
+        end
+
+        def make_own_logger(new_level = nil)
+            if !has_own_logger?
+                @logger = self.logger.dup
+            end
+            if new_level
+                @logger.level = new_level
+            end
+            @logger
+        end
+
         def logger
             return @logger if defined?(@logger) && @logger
-	    @logger = if kind_of?(Module)
-			  constant(self.spacename).logger
-		      else
-			  self.class.logger
-		      end
+	    @logger =
+                if kind_of?(Module)
+                    constant(self.spacename).logger
+                else
+                    self.class.logger
+                end
         end
     end
 end

data/lib/utilrb/logger/io.rb

@@ -0,0 +1,25 @@
+class Logger
+    # An IO-like interface for a logger object
+    class LoggerIO
+        attr_reader :logger
+        attr_reader :level
+
+        def initialize(logger, level)
+            @logger, @level = logger, level
+            @buffer = ''
+        end
+        def puts(msg)
+            print msg
+            logger.send(level, @buffer)
+            @buffer = ''
+        end
+        def print(msg)
+            @buffer << msg
+        end
+    end
+
+    def io(level)
+        LoggerIO.new(self, level)
+    end
+end
+

data/lib/utilrb/marshal/load_with_missing_constants.rb

@@ -0,0 +1,63 @@
+module Marshal
+    if defined? BasicObject
+        class BlackHole < BasicObject
+        end
+    end
+
+    class BlackHole
+        class << self
+            :name
+        end
+
+        def initialize(*args)
+        end
+
+        attr_reader :__content__
+        def method_missing(*args)
+        end
+        def self._load(*args)
+            hole = BlackHole.new
+            hole.instance_variable_set(:@__content__, args)
+        end
+
+        def self.method_missing(*args)
+        end
+    end
+
+    def self.load_with_missing_constants(str_or_io)
+        if str_or_io.respond_to?(:tell)
+            original_pos = str_or_io.tell
+        end
+
+        self.load(str_or_io)
+    rescue Exception => e
+        case e.message
+        when /undefined class\/module ((?:\w+::)+)$/
+            names = $1.split('::')
+            missing = names.pop
+            base = names.inject(Object) { |m, n| m.const_get(n) }
+            base.const_set(missing, Module.new)
+
+            if original_pos
+                str_or_io.seek(original_pos)
+            end
+            retry
+        when /undefined class\/module ((?:\w+::)+)(\w+)$/
+            mod, klass   = $1, $2
+            full_name = "#{mod}#{klass}"
+            mod = mod.split('::').inject(Object) { |m, n| m.const_get(n) }
+
+            blackhole = Class.new(BlackHole) do
+                @name = full_name
+            end
+            mod.const_set(klass, blackhole)
+
+            if original_pos
+                str_or_io.seek(original_pos)
+            end
+            retry
+        end
+        raise
+    end
+end
+

data/lib/utilrb/module/ancestor_p.rb

@@ -1,24 +1,18 @@
 require 'utilrb/common'
 class Module
-    Utilrb.if_ext 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 || (is_singleton? && superclass.has_ancestor?(klass))
-	end
+    def has_ancestor?(klass) # :nodoc:
+        self <= klass
     end
-    Utilrb.unless_ext do
-	def has_ancestor?(klass) # :nodoc:
-	    self <= klass || superclass == klass || superclass < 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/cached_enum.rb

@@ -1,3 +1,15 @@
+require 'utilrb/object/attribute'
+module CachedValuesSupport
+    attribute(:cached_variables) { Set.new }
+    def initialize_copy(other)
+        super
+
+        cached_variables.each do |varname|
+            instance_variable_set(varname, nil)
+        end
+    end
+end
+
 class Module
     # Creates <tt>enum_#{name}</tt> method which returs an Enumerator object
     # for the <tt>each_#{enum_name}</tt> method. This enumerator is created
@@ -7,16 +19,19 @@ class Module
     # one argument, which is given in argument of the 'enum' method. In that
     # case, an enumerator is created for each argument
     def cached_enum(enum_name, name, with_arg)
+        include CachedValuesSupport
 	if with_arg
 	    class_eval <<-EOD
 		def enum_#{name}(arg)
 		    @enum_#{name} ||= Hash.new
+                    cached_variables << :@enum_#{name}
 		    @enum_#{name}[arg] ||= enum_for(:each_#{enum_name}, arg)
 		end
 		EOD
 	else
 	    class_eval <<-EOD
 		def enum_#{name}
+                    cached_variables << :@enum_#{name}
 		    @enum_#{name} ||= enum_for(:each_#{enum_name})
 		end
 		EOD

data/lib/utilrb/module/const_defined_here_p.rb

@@ -0,0 +1,11 @@
+class Module
+    if Utilrb::RUBY_IS_191 || Utilrb::RUBY_IS_19
+    def const_defined_here?(name)
+        const_defined?(name, false)
+    end
+    else
+    def const_defined_here?(name)
+        const_defined?(name)
+    end
+    end
+end

data/lib/utilrb/module/define_or_reuse.rb

@@ -1,26 +1,19 @@
+require 'utilrb/module/const_defined_here_p'
 class Module
-    if Utilrb::RUBY_IS_19
-        # :call-seq
-        #   define_or_reuse(name, value)   ->              value
-        #   define_or_reuse(name) { ... }  ->              value
-        #
-        # Defines a new constant under a given module, or reuse the
-        # already-existing value if the constant is already defined.
-        #
-        # In the first form, the method gets its value from its argument. 
-        # In the second case, it calls the provided block
-        def define_or_reuse(name, value = nil)
-            if const_defined?(name, false)
-                const_get(name)
-            else
-                const_set(name, (value || yield))
-            end
-        end
-    else
-        def define_or_reuse(name, value = nil)
-            if const_defined?(name)
-                const_get(name)
-            else
+    # :call-seq
+    #   define_or_reuse(name, value)   ->              value
+    #   define_or_reuse(name) { ... }  ->              value
+    #
+    # Defines a new constant under a given module, or reuse the
+    # already-existing value if the constant is already defined.
+    #
+    # In the first form, the method gets its value from its argument. 
+    # In the second case, it calls the provided block
+    def define_or_reuse(name, value = nil)
+        if const_defined_here?(name)
+            const_get(name)
+        else
+            module_eval do
                 const_set(name, (value || yield))
             end
         end

data/lib/utilrb/module/include.rb

@@ -14,6 +14,18 @@ class Module
     # * if it is included in a Class, the ClassExtension module
     #   extends the class.
     def include(mod)
+	if mod.const_defined?(:ModuleExtension)
+	    if is_a?(Module)
+		unless const_defined?(:ModuleExtension)
+		    const_set(:ModuleExtension, Module.new)
+		end
+		const_get(:ModuleExtension).class_eval do
+		    __instance_include__ mod.const_get(:ModuleExtension)
+		end
+		extend mod.const_get(:ModuleExtension)
+	    end
+            # Do nothing on classes
+	end
 	if mod.const_defined?(:ClassExtension)
 	    if !is_a?(Class)
 		unless const_defined?(:ClassExtension)

data/lib/utilrb/module/inherited_enumerable.rb

@@ -11,6 +11,11 @@ class Module
 
 	options[:enum_with] ||= :each
 
+        class_eval <<-EOF
+        def all_#{name}; each_#{name}.to_a end
+        def self_#{name}; @#{attribute_name} end
+        EOF
+
         if options[:map]
             class_eval <<-EOF
             def each_#{name}(key = nil, uniq = true)
@@ -49,6 +54,12 @@ class Module
 		end
                 self
             end
+            def find_#{name}(key)
+                each_#{name}(key, true) do |value|
+                    return value
+                end
+                nil
+            end
             def has_#{name}?(key)
 		for klass in ancestors
 		    if klass.instance_variable_defined?(:@#{attribute_name})
@@ -61,6 +72,10 @@ class Module
         else
             class_eval <<-EOF
             def each_#{name}
+	        if !block_given?
+	            return enum_for(:each_#{name})
+		end
+
 		for klass in ancestors
 		    if klass.instance_variable_defined?(:@#{attribute_name})
 			klass.#{attribute_name}.#{options[:enum_with]} { |el| yield(el) }

data/lib/utilrb/object/scoped_eval.rb

@@ -0,0 +1,17 @@
+require 'utilrb/common'
+require 'utilrb/kernel/with_module'
+class Object
+    if Utilrb::RUBY_IS_191
+        def scoped_eval(type = :instance_eval, &b)
+            modules = b.binding.eval "Module.nesting"
+            with_module(*modules) do
+                send(type, &b)
+            end
+        end
+    else
+        def scoped_eval(type = :instance_eval, &b)
+            send(type, &b)
+        end
+    end
+end
+

data/lib/utilrb/object/singleton_class.rb

@@ -1,30 +1,8 @@
 require 'utilrb/common'
 require 'utilrb/object/address'
 
-class Class
-    unless method_defined?(:__ancestors__)
-	alias __ancestors__ ancestors
-    end
-
-    attr_reader :singleton_instance
-
-    Utilrb.require_ext("Object#ancestors") do
-        def ancestors
-            if is_singleton?
-                __ancestors__.unshift(self) 
-            else
-                __ancestors__
-            end
-        end
-    end
-end
-
-class Object
-    # Returns true if this object has its own singleton class
-    def has_singleton?; defined? @singleton_class end
-end
-
 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 
@@ -35,27 +13,8 @@ class Object
     # defined, which returns the object instance the class is the singleton
     # of.
     def singleton_class
-	unless defined? @singleton_class
-	    klass = class << self; self end
-	    klass.instance_variable_set(:@singleton_instance, self)
-	    @singleton_class = klass
-
-	    unless Utilrb::RUBY_IS_19
-		instance = self
-		klass.class_eval do
-		    @superclass = instance.class
-		    class << self
-			attr_reader :superclass
-			def name
-			    "#{superclass.name}!0x#{@singleton_instance.address.to_s(16)}"
-			end
-		    end
-		end
-	    end
-	    klass
-	end
-
-	@singleton_class
+        class << self; self end
+    end
     end
 end