utilrb 0.2

data/lib/utilrb/module.rb

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

data/lib/utilrb/module/ancestor_p.rb

@@ -0,0 +1,6 @@
+class Module
+    # Check if +klass+ is an ancestor of this class/module
+    def has_ancestor?(klass); ancestors.find { |a| a == klass } end
+end
+
+

data/lib/utilrb/module/attr_enumerable.rb

@@ -0,0 +1,28 @@
+require 'utilrb/object/attribute'
+
+class Module
+    # Define 'name' to be a read-only enumerable attribute. The method
+    # defines a +attr_name+ read-only attribute and an enumerator method 
+    # each_#{name}. +init_block+ is used to initialize the attribute.
+    #
+    # The enumerator method accepts a +key+ argument. If the attribute is
+    # a key => enumerable map, then the +key+ attribute can be used to iterate
+    # 
+    # +enumerator+ is the name of the enumeration method
+    def attr_enumerable(name, attr_name = name, enumerator = :each, &init_block)
+	class_eval do
+	    attribute(attr_name, &init_block)
+	end
+        class_eval <<-EOF
+            def each_#{name}(key = nil, &iterator)
+                return unless #{attr_name}
+                if key
+                    #{attr_name}[key].#{enumerator}(&iterator)
+                else
+                    #{attr_name}.#{enumerator}(&iterator)
+                end
+            end
+        EOF
+    end
+end
+

data/lib/utilrb/module/define_method.rb

@@ -0,0 +1,30 @@
+class Module
+    # Emulate block-passing by converting the block into a Proc object
+    # and passing it to the given block as last argument
+    # dule)
+    #
+    # For instance
+    #   define_method('my_method') do |a, &block|
+    #   end
+    #
+    # Is written as
+    #	define_method_with_block('my_method') do |block, a|
+    #	end
+    #
+    # The block is given first to allow the following construct:
+    #
+    #	define_method_with_block('my_method') do |block, *args|
+    #	end
+    #
+    # +block+ is +nil+ if no block is given on the method call
+    #
+    def define_method_with_block(name, &mdef)
+	class_eval <<-EOD
+	    def #{name}(*args, &block)
+		dmwb_#{name}_user_definition(block, *args) 
+	    end
+	EOD
+	define_method("dmwb_#{name}_user_definition", &mdef)
+    end
+end
+

data/lib/utilrb/module/include.rb

@@ -0,0 +1,30 @@
+class Module
+    unless (method(:__instance_include__) rescue nil)
+	alias :__instance_include__  :include
+    end
+
+    # Includes a module in this one, with support for class extensions
+    #
+    # If a module defines a ClassExtension submodule, then 
+    #  * if it is included in a module, the target's ClassExtension
+    #    module includes the source ClassExtension (and if there is no
+    #    ClassExtension in the target, it is created)
+    #  * if it is included in a Class, the ClassExtension module
+    #    extends the class.
+    def include(mod)
+	__instance_include__ mod
+	return unless mod.const_defined?(:ClassExtension)
+
+	if is_a?(Module) && !is_a?(Class)
+	    unless const_defined?(:ClassExtension)
+		const_set(:ClassExtension, Module.new)
+	    end
+	    const_get(:ClassExtension).class_eval do
+		__instance_include__ mod.const_get(:ClassExtension)
+	    end
+	else
+	    extend mod.const_get(:ClassExtension)
+	end
+    end
+end
+

data/lib/utilrb/module/inherited_enumerable.rb

@@ -0,0 +1,122 @@
+require 'utilrb/object/attribute'
+require 'utilrb/object/singleton_class'
+require 'utilrb/enumerable/uniq'
+require 'utilrb/module/include'
+
+class Module
+    def define_inherited_enumerable(name, attribute_name = name, options = Hash.new, &init) # :nodoc:
+        # Set up the attribute accessor
+	attribute(attribute_name, &init)
+	class_eval { private "#{attribute_name}=" }
+
+	options[:enum_with] ||= :each
+
+        if options[:map]
+            class_eval <<-EOF
+            def each_#{name}(key = nil, uniq = true)
+		if key
+		    if #{attribute_name}.has_key?(key)
+			yield(#{attribute_name}[key])
+			return self if uniq
+		    end
+		elsif uniq
+		    @enum_#{name}_uniq ||= enum_uniq(:each_#{name}, nil, false) { |k, v| k }
+		    @enum_#{name}_uniq.each { |el| yield(el) }
+		    return self
+		else
+                    #{attribute_name}.#{options[:enum_with]} { |el| yield(el) }
+		end
+		if superclass = ancestors[1..-1].find { |k| k.respond_to?(:each_#{name}) }
+		    superclass.each_#{name}(key, uniq) { |el| yield(el) }
+		end
+                self
+            end
+            def has_#{name}?(key)
+                return true if #{attribute_name}[key]
+		if superclass = ancestors[1..-1].find { |k| k.respond_to?(:has_#{name}) }
+		    superclass.has_#{name}(key)
+		end
+            end
+            EOF
+        else
+            class_eval <<-EOF
+            def each_#{name}(&iterator)
+                #{attribute_name}.#{options[:enum_with]}(&iterator) if #{attribute_name}
+		if superclass = ancestors[1..-1].find { |k| k.respond_to?(:each_#{name}) }
+		    superclass.each_#{name} { |el| yield(el) }
+		end
+                self
+            end
+            EOF
+        end
+    end
+
+    # Defines an attribute as being enumerable in the class instance and in the
+    # whole class inheritance hierarchy.  More specifically, it defines a
+    # <tt>each_#{name}(&iterator)</tt> instance method and a <tt>each_#{name}(&iterator)</tt>
+    # class method which iterates (in order) on 
+    # - the instance #{name} attribute
+    # - the singleton class #{name} attribute
+    # - the class #{name} attribute
+    # - the superclass #{name} attribute
+    # - the superclass' superclass #{name} attribute
+    # ...
+    #
+    # This method can be used on modules, in which case the module is used as if 
+    # it was part of the inheritance hierarchy.
+    #
+    # The +name+ option defines the enumeration method name (+value+ will
+    # define a +each_value+ method). +attribute_name+ defines the attribute
+    # name. +init+ is a block called to initialize the attribute. 
+    # Valid options in +options+ are: 
+    # map:: the attribute should respond to +[]+. The enumeration method takes two 
+    #	    arguments, +key+ and +uniq+. If +key+ is given, we iterate on the values
+    #	    given by <tt>attribute[key]</tt>. If +uniq+ is true, the enumeration will
+    #	    yield at most one value for each +key+ found (so, if both +key+ and +uniq+ are
+    #	    given, the enumeration yields at most one value)
+    #
+    # For instance
+    #
+    #	class A 
+    #	    class_inherited_enumerable("value", "enum") { Array.new }
+    #	end
+    #	module M
+    #	    inherited_enumerable("attr") { Array.new }
+    #	end
+    #	class B < A
+    #	    include M
+    #	end
+    #	b = B.new
+    #
+    #	A.enum << 1
+    #	B.enum << 2
+    #	M.attr << 1
+    #	class << b
+    #	    enum << 3
+    #	    attr << 4
+    #	end
+    #	M.attr << 2
+    #
+    #	A.each_enum => 1
+    #	B.each_enum => 2, 1
+    #	b.singleton_class.each_enum => 3, 2, 1
+    #	b.singleton_class.each_attr => 4, 1, 2
+    #
+    def inherited_enumerable(name, attribute_name = name, options = Hash.new, &init)
+	singleton_class.class_eval { define_inherited_enumerable(name, attribute_name, options, &init) }
+
+	if is_a?(Module) && !is_a?(Class)
+	    unless const_defined?(:ClassExtension)
+		const_set(:ClassExtension, Module.new)
+	    end
+	    class_extension = const_get(:ClassExtension)
+	    class_extension.class_eval do
+		define_inherited_enumerable(name, attribute_name, options, &init)
+	    end
+	end
+    end
+end
+
+
+
+

data/lib/utilrb/object.rb

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

data/lib/utilrb/object/address.rb

@@ -0,0 +1,14 @@
+
+class Object
+    # Return the object address (for non immediate
+    # objects). 
+    def address; Object.address_from_id(object_id) end
+
+    # Converts the object_id of a non-immediate object
+    # to its 32 bits address
+    def self.address_from_id(id)
+	id = 0xFFFFFFFF - ~id if id < 0
+	(id * 2) & 0xFFFFFFFF
+    end
+end
+

data/lib/utilrb/object/attribute.rb

@@ -0,0 +1,89 @@
+require 'utilrb/common'
+require 'utilrb/object/singleton_class'
+
+Utilrb.unless_faster 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
+	    def #{name}
+		if defined? @#{name} then @#{name}
+		else @#{name} = #{name}_defval
+		end
+	    end
+	    EOD
+	end
+    end
+end
+
+Utilrb.if_faster 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
+
+	    if is_singleton? || instance_of?(Module)
+		class_eval do
+		    attr_writer name
+		    define_method("#{name}_defval") do
+			defval || (instance_eval(&init) if init)
+		    end
+		end
+
+		class_eval <<-EOD
+		def #{name}
+		    if defined? @#{name} then @#{name}
+		    else @#{name} = #{name}_defval
+		    end
+		end
+		EOD
+	    else
+		class_eval { attr_writer name }
+		define_method(name) do
+		    singleton_class.class_eval { attr_reader name }
+		    instance_variable_set("@#{name}", defval || (instance_eval(&init) if init))
+		end
+	    end
+	end
+    end
+end
+
+class Object
+    def class_attribute(attr_def, &init)
+	singleton_class.class_eval { attribute(attr_def, &init) }
+    end
+end
+

data/lib/utilrb/object/singleton_class.rb

@@ -0,0 +1,53 @@
+require 'utilrb/object/address'
+if RUBY_VERSION >= "1.9"
+    class Object
+	def has_singleton?; defined? @singleton_class end
+	def singleton_class
+	    if defined? @singleton_class
+		return @singleton_class
+	    else
+		@singleton_class = class << self
+		    class << self
+			alias __ancestors__ ancestors
+			def ancestors; __ancestors__.unshift(self) end
+		    end
+		    
+		    self 
+		end
+
+		@singleton_class
+	    end
+	end
+    end
+else
+    class Object
+	def has_singleton?
+	    defined? @singleton_class
+	end
+	def singleton_class
+	    if defined? @singleton_class
+		return @singleton_class
+	    else
+		klass = class << self; self end
+		instance = self
+		klass.class_eval do
+		    @singleton_instance = instance
+		    @superclass		= instance.class
+		    class << self
+			attr_reader :superclass
+			attr_reader :singleton_instance
+			def name
+			    "#{@superclass.name}!0x#{@singleton_instance.address.to_s(16)}"
+			end
+
+			alias __ancestors__ ancestors
+			def ancestors; __ancestors__.unshift(self) end
+		    end
+		end
+
+		@singleton_class = klass
+	    end
+	end
+    end
+end
+

data/lib/utilrb/objectstats.rb

@@ -0,0 +1,52 @@
+require 'utilrb/gc/force'
+
+module ObjectStats
+    # Allocates no object
+    def self.count
+        count = 0
+        ObjectSpace.each_object { |obj| count += 1}
+
+	count
+    end
+
+    # Allocates 1 Hash, which is included in the count
+    def self.count_by_class
+        by_class = Hash.new(0)
+        ObjectSpace.each_object { |obj|
+            by_class[obj.class] += 1
+            by_class
+        }
+        by_class
+    end
+
+    # Profiles the memory allocation in the block
+    # If alive is true, then only non-gcable objects
+    # are returned.
+    def self.profile(alive = false)
+        already_disabled = GC.disable
+        before = count_by_class
+        yield
+        after  = count_by_class
+        GC.enable unless already_disabled
+
+        after[Hash] -= 1 # Correction for the call of count_by_class
+        profile = before.
+            merge(after) { |klass, old, new| new - old }.
+            delete_if { |klass, count| count == 0 }
+    end
+
+    def self.stats(filter = nil)
+        total_count = 0
+        output = ""
+        count_by_class.each do |klass, obj_count|
+            total_count += obj_count
+            if !filter || klass.name =~ filter
+                output << klass.name << " " << obj_count.to_s << "\n"
+            end
+        end
+        
+        (output << "Total object count: #{total_count}")
+    end
+end
+
+

data/lib/utilrb/time.rb

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