utilrb 2.0.2.b2 → 2.1.0.rc1

data/lib/utilrb/models/inherited_enumerable.rb

@@ -1,341 +0,0 @@
-require 'utilrb/object/attribute'
-require 'utilrb/object/singleton_class'
-require 'utilrb/enumerable/uniq'
-require 'utilrb/module/include'
-
-module Utilrb
-module Models
-    # Helper method for inherited_enumerable
-    #
-    # It is called in the context of the singleton class of the module/class on
-    # which inherited_enumerable is called
-    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}=" }
-
-        promote = method_defined?("promote_#{name}")
-	options[:enum_with] ||= :each
-
-        class_eval <<-EOF, __FILE__, __LINE__+1
-        def all_#{name}; each_#{name}.to_a end
-        def self_#{name}; @#{attribute_name} end
-        EOF
-
-        if options[:map]
-            class_eval <<-EOF, __FILE__, __LINE__+1
-            def find_#{name}(key)
-                raise ArgumentError, "nil cannot be used as a key in find_#{name}" if !key
-                each_#{name}(key, true) do |value|
-                    return value
-                end
-                nil
-            end
-            def has_#{name}?(key)
-                ancestors = self.ancestors
-                if ancestors.first != self
-                    ancestors.unshift self
-                end
-                for klass in ancestors
-                    if klass.instance_variable_defined?(:@#{attribute_name})
-                        return true if klass.#{attribute_name}.has_key?(key)
-                    end
-                end
-                false
-            end
-            EOF
-        end
-
-        class_eval <<-EOF, __FILE__, __LINE__+1
-        def clear_#{attribute_name}
-            #{attribute_name}.clear
-            for klass in ancestors
-                if klass.instance_variable_defined?(:@#{attribute_name})
-                    klass.#{attribute_name}.clear
-                end
-            end
-        end
-        EOF
-
-        if !promote
-            if options[:map]
-                define_inherited_enumerable_map_without_promotion(name, attribute_name, options)
-            else
-                define_inherited_enumerable_nomap_without_promotion(name, attribute_name, options)
-            end
-        else
-            if options[:map]
-                define_inherited_enumerable_map_with_promotion(name, attribute_name, options)
-            else
-                define_inherited_enumerable_nomap_with_promotion(name, attribute_name, options)
-            end
-        end
-    end
-
-    def define_inherited_enumerable_map_without_promotion(name, attribute_name, options)
-        class_eval <<-EOF, __FILE__, __LINE__+1
-        def each_#{name}(key = nil, uniq = true)
-            if !block_given?
-                return enum_for(:each_#{name}, key, uniq)
-            end
-
-            ancestors = self.ancestors
-            if ancestors.first != self
-                ancestors.unshift self
-            end
-            if key
-                for klass in ancestors
-                    if klass.instance_variable_defined?(:@#{attribute_name})
-                        if klass.#{attribute_name}.has_key?(key)
-                            yield(klass.#{attribute_name}[key])
-                            return self if uniq
-                        end
-                    end
-                end
-            elsif !uniq
-                for klass in ancestors
-                    if klass.instance_variable_defined?(:@#{attribute_name})
-                        klass.#{attribute_name}.#{options[:enum_with]} do |el|
-                            yield(el)
-                        end
-                    end
-                end
-            else
-                seen = Set.new
-                for klass in ancestors
-                    if klass.instance_variable_defined?(:@#{attribute_name})
-                        klass.#{attribute_name}.#{options[:enum_with]} do |el| 
-                            unless seen.include?(el.first)
-                                seen << el.first
-                                yield(el)
-                            end
-                        end
-                    end
-                end
-
-            end
-            self
-        end
-        EOF
-    end
-
-    def define_inherited_enumerable_nomap_without_promotion(name, attribute_name, options)
-        class_eval <<-EOF, __FILE__, __LINE__+1
-        def each_#{name}
-            if !block_given?
-                return enum_for(:each_#{name})
-            end
-
-            ancestors = self.ancestors
-            if ancestors.first != self
-                ancestors.unshift self
-            end
-            for klass in ancestors
-                if klass.instance_variable_defined?(:@#{attribute_name})
-                    klass.#{attribute_name}.#{options[:enum_with]} { |el| yield(el) }
-                end
-            end
-            self
-        end
-        EOF
-    end
-
-    def define_inherited_enumerable_map_with_promotion(name, attribute_name, options)
-        class_eval <<-EOF, __FILE__, __LINE__+1
-        def each_#{name}(key = nil, uniq = true)
-            if !block_given?
-                return enum_for(:each_#{name}, key, uniq)
-            end
-
-            ancestors = self.ancestors
-            if ancestors.first != self
-                ancestors.unshift self
-            end
-            if key
-                promotions = []
-                for klass in ancestors
-                    if klass.instance_variable_defined?(:@#{attribute_name})
-                        if klass.#{attribute_name}.has_key?(key)
-                            value = klass.#{attribute_name}[key]
-                            for p in promotions
-                                value = p.promote_#{name}(key, value)
-                            end
-                            yield(value)
-                            return self if uniq
-                        end
-                    end
-                    promotions.unshift(klass) if klass.respond_to?("promote_#{name}")
-                end
-            elsif !uniq
-                promotions = []
-                for klass in ancestors
-                    if klass.instance_variable_defined?(:@#{attribute_name})
-                        klass.#{attribute_name}.#{options[:enum_with]} do |key, value|
-                            for p in promotions
-                                value = p.promote_#{name}(key, value)
-                            end
-                            yield(key, value)
-                        end
-                    end
-                    promotions.unshift(klass) if klass.respond_to?("promote_#{name}")
-                end
-            else
-                seen = Set.new
-                promotions = []
-                for klass in ancestors
-                    if klass.instance_variable_defined?(:@#{attribute_name})
-                        klass.#{attribute_name}.#{options[:enum_with]} do |key, value|
-                            unless seen.include?(key)
-                                for p in promotions
-                                    value = p.promote_#{name}(key, value)
-                                end
-                                seen << key
-                                yield(key, value)
-                            end
-                        end
-                    end
-                    promotions.unshift(klass) if klass.respond_to?("promote_#{name}")
-                end
-            end
-            self
-        end
-        EOF
-    end
-
-    def define_inherited_enumerable_nomap_with_promotion(name, attribute_name, options)
-        class_eval <<-EOF, __FILE__, __LINE__+1
-        def each_#{name}
-            if !block_given?
-                return enum_for(:each_#{name})
-            end
-
-            ancestors = self.ancestors
-            if ancestors.first != self
-                ancestors.unshift self
-            end
-            promotions = []
-            for klass in ancestors
-                if klass.instance_variable_defined?(:@#{attribute_name})
-                    klass.#{attribute_name}.#{options[:enum_with]} do |value|
-                        for p in promotions
-                            value = p.promote_#{name}(value)
-                        end
-                        yield(value)
-                    end
-                end
-                promotions.unshift(klass) if klass.respond_to?("promote_#{name}")
-            end
-            self
-        end
-        EOF
-    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:: 
-    #   If true, the attribute should respond to +[]+. In that case, the
-    #   enumeration method is each_value(key = nil, uniq = false) 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). See the examples below
-    # enum_with:: the enumeration method of the enumerable, if it is not +each+
-    #
-    # === Example
-    # Let's define some classes and look at the ancestor chain
-    #
-    #   class A;  end
-    #   module M; end
-    #   class B < A; include M end
-    #   A.ancestors # => [A, Object, Kernel]
-    #   B.ancestors # => [B, M, A, Object, Kernel]
-    #
-    # ==== Attributes for which 'map' is not set
-    #
-    #   class A
-    #     inherited_enumerable("value", "values") do
-    #         Array.new
-    #     end
-    #   end
-    #   module M
-    #     inherited_enumerable("mod") do
-    #         Array.new
-    #     end
-    #   end
-    #   
-    #   A.values << 1 # => [1]
-    #   B.values << 2 # => [2]
-    #   M.mod << 1 # => [1]
-    #   b = B.new 
-    #   class << b
-    #       self.values << 3 # => [3]
-    #       self.mod << 4 # => [4]
-    #   end
-    #   M.mod << 2 # => [1, 2]
-    #   
-    #   A.enum_for(:each_value).to_a # => [1]
-    #   B.enum_for(:each_value).to_a # => [2, 1]
-    #   b.singleton_class.enum_for(:each_value).to_a # => [3, 2, 1]
-    #   b.singleton_class.enum_for(:each_mod).to_a # => [4, 1, 2]
-    #
-    # ==== Attributes for which 'map' is set
-    #
-    #   class A
-    #     inherited_enumerable("mapped", "map", :map => true) do
-    #         Hash.new { |h, k| h[k] = Array.new }
-    #     end
-    #   end
-    #   
-    #   A.map['name'] = 'A' # => "A"
-    #   A.map['universe'] = 42
-    #   B.map['name'] = 'B' # => "B"
-    #   B.map['half_of_it'] = 21
-    #   
-    # Let's see what happens if we don't specify the key option.  
-    #   A.enum_for(:each_mapped).to_a # => [["name", "A"], ["universe", 42]]
-    # If the +uniq+ option is set (the default), we see only B's value for 'name'
-    #   B.enum_for(:each_mapped).to_a # => [["half_of_it", 21], ["name", "B"], ["universe", 42]]
-    # If the +uniq+ option is not set, we see both values for 'name'. Note that
-    # since 'map' is a Hash, the order of keys in one class is not guaranteed.
-    # Nonetheless, we have the guarantee that values from B appear before
-    # those from A
-    #   B.enum_for(:each_mapped, nil, false).to_a # => [["half_of_it", 21], ["name", "B"], ["name", "A"], ["universe", 42]]
-    #
-    #
-    # Now, let's see how 'key' behaves
-    #   A.enum_for(:each_mapped, 'name').to_a # => ["A"]
-    #   B.enum_for(:each_mapped, 'name').to_a # => ["B"]
-    #   B.enum_for(:each_mapped, 'name', false).to_a # => ["B", "A"]
-    #
-    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_here?(: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
-end
-

data/lib/utilrb/models/registration.rb

@@ -1,115 +0,0 @@
-require 'facets/kernel/call_stack'
-require 'utilrb/object/attribute'
-require 'utilrb/module/attr_predicate'
-module Utilrb
-    module Models
-
-        # Handling of registration of model hierarchies
-        #
-        # It depends on the mixed-in object to provide a #supermodel method that
-        # returns the model that is parent of +self+
-        module Registration
-            # The place where this model got defined in the source code
-            # The tuple is (file,lineno,method), and can be obtained with
-            # facet's #call_stack
-            # @return [Array<(String,Integer,Symbol)>]
-            attr_accessor :definition_location
-
-            # Tells {#clear_submodels} whether this model should be removed from
-            # the model set or not. The default is false (it should be removed)
-            #
-            # @return [Boolean]
-            attr_predicate :permanent_model?, true
-
-            # [ValueSet] the set of models that are children of this one
-            attribute(:submodels) { ValueSet.new }
-
-            # Returns the model that is parent of this one
-            #
-            # The default implementation returns superclass if it is extended by
-            # this Registration module, and nil otherwise
-            def supermodel
-                if superclass.respond_to?(:register_submodel)
-                    superclass
-                end
-            end
-
-            # Call to register a model that is a submodel of +self+
-            def register_submodel(klass)
-                if !klass.definition_location
-                    klass.definition_location = call_stack
-                end
-
-                if klass.name && !klass.permanent_model?
-                    begin
-                        if constant("::#{klass.name}") == klass
-                            klass.permanent_model = true
-                        end
-                    rescue NameError
-                    end
-                end
-
-                submodels << klass
-                if m = supermodel
-                    m.register_submodel(klass)
-                end
-            end
-
-            # Enumerates all models that are submodels of this class
-            def each_submodel
-                return enum_for(:each_submodel) if !block_given?
-                submodels.each do |obj|
-                    yield(obj)
-                end
-            end
-
-            # Clears all registered submodels
-            def clear_submodels
-                children = self.submodels.find_all { |m| !m.permanent_model? }
-                if !deregister_submodels(children)
-                    return
-                end
-
-                # This contains the permanent submodels
-                #
-                # We can call #clear_submodels while iterating here as it is a
-                # constraint that all models in #submodels are permanent (and
-                # will therefore not be removed)
-                submodels.each { |m| m.clear_submodels }
-                # And this the non-permanent ones
-                children.each { |m| m.clear_submodels }
-                true
-            end
-
-            # Deregisters a set of submodels on this model and all its
-            # supermodels
-            #
-            # This is usually not called directly. Use #clear_submodels instead
-            #
-            # @param [ValueSet] set the set of submodels to remove
-            def deregister_submodels(set)
-                current_size = submodels.size
-                submodels.difference!(set.to_value_set)
-                if (submodels.size != current_size)
-                    if m = supermodel
-                        m.deregister_submodels(set)
-                    end
-                    true
-                else false
-                end
-            end
-
-            # Registers submodels when a subclass is created (when models are
-            # represented as classes)
-            def inherited(subclass)
-                subclass.definition_location = call_stack
-                super
-                register_submodel(subclass)
-                subclass.permanent_model = true
-            end
-        end
-    end
-end
-
-
-

data/lib/utilrb/module/inherited_enumerable.rb

@@ -1,6 +0,0 @@
-require 'utilrb/models/inherited_enumerable'
-
-class Module
-    include Utilrb::Models
-end
-

data/lib/utilrb/objectstats.rb

@@ -1,193 +0,0 @@
-require 'utilrb/gc/force'
-require 'utilrb/object/attribute'
-require 'utilrb/column_formatter'
-
-module ObjectStats
-    # The count of objects currently allocated
-    #
-    # It allocates no objects, which means that if
-    #	a = ObjectStats.count
-    #	b = ObjectStats.count
-    #	then a == b
-    def self.count
-        count = 0
-        ObjectSpace.each_object { |obj| count += 1 }
-
-	count
-    end
-
-    # Returns a klass => count hash counting the currently allocated objects
-    # 
-    # It allocates 1 Hash, which is included in the count
-    def self.count_by_class(threshold = nil)
-        by_class = Hash.new(0)
-        ObjectSpace.each_object { |obj|
-            by_class[obj.class] += 1
-            by_class
-        }
-        if threshold
-            by_class.delete_if { |kl, count| count < threshold }
-        end
-
-        by_class
-    end
-
-    LIVE_OBJECTS_KEY = :live_objects
-
-    # Profiles how much objects has been allocated by the block. Returns a
-    # klass => count hash like count_by_class
-    #
-    # If alive is true, then only live objects are returned.
-    def self.profile(alive = false)
-	if alive
-	    GC.force
-	    profile do
-		yield
-		GC.force
-	    end
-	end
-
-        already_disabled = GC.disable
-        before = count_by_class
-	if ObjectSpace.respond_to?(:live_objects)
-	    before_live_objects = ObjectSpace.live_objects
-	end
-        yield
-	if ObjectSpace.respond_to?(:live_objects)
-	    after_live_objects = ObjectSpace.live_objects
-	end
-        after  = count_by_class
-	if after_live_objects
-	    before[LIVE_OBJECTS_KEY] = before_live_objects
-	    after[LIVE_OBJECTS_KEY]  = after_live_objects - 1 # correction for yield
-	end
-        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
-end
-
-# BenchmarkAllocation is a Benchmark-like interface to benchmark object allocation. 
-#
-# == Formatting
-# BenchmarkAllocation formats its output in two ways (see examples below)
-# * first, each part of a class path is displayed in its own line, to reduce
-#   the output width
-# * then, output is formatted so that it does not exceed
-#   BenchmarkAllocation::SCREEN_WIDTH width
-#
-#
-# == Examples
-#
-# For instance, 
-#
-#   require 'utilrb/objectstats'
-#   
-#   module Namespace
-#	class MyClass
-#	end
-#   end
-#
-#   BenchmarkAllocation.bm do |x|
-#       x.report("array") { Array.new }
-#       x.report("hash") { Hash.new }
-#       x.report("myclass") { MyClass.new }
-#   end
-#
-# will produce the output
-#
-#            Array  Hash  Namespace::
-#                             MyClass
-#     array      1     -            -
-#      hash      -     1            -
-#   myclass      -     -            1
-#  
-# Like Benchmark, a rehearsal benchmark method, BenchmarkAllocation.bmbm
-# is provided:
-#
-#   require 'utilrb/objectstats'
-#   require 'delegate'
-#   
-#   module Namespace
-#       class MyClass
-#       end
-#   end
-#   
-#   delegate_klass = nil
-#   BenchmarkAllocation.bmbm do |x|
-#       x.report("array") { Array.new }
-#       x.report("hash") { Hash.new }
-#       x.report("myclass") { Namespace::MyClass.new }
-#       x.report("delegate") do
-#   	delegate_klass ||= Class.new(DelegateClass(Namespace::MyClass)) do
-#   	    def self.name; "Delegate(MyClass)" end
-#   	end
-#   	delegate_klass.new(Namespace::MyClass.new)
-#       end
-#   end
-#
-# produces
-#
-#   Rehearsal --------------------------------------------------------------------------------
-#   
-#             Array  Class  Delegate(MyClass)  Hash  Namespace::  String
-#                                                        MyClass
-#      array      1      -                  -     -            -       -
-#       hash      -      -                  -     1            -       -
-#    myclass      -      -                  -     -            1       -
-#   delegate      5      2                  1     2            1     247
-#   ------------------------------------------------------------------------------------------
-#   
-#             Array  Delegate(MyClass)  Hash  Namespace::
-#                                                 MyClass
-#      array      1                  -     -            -
-#       hash      -                  -     1            -
-#    myclass      -                  -     -            1
-#   delegate      -                  1     -            1
-#   
-class BenchmarkAllocation
-    SCREEN_WIDTH = 90
-    MARGIN = 2
-
-    def self.bm(label_width = nil)
-	yield(gather = new)
-	gather.format
-    end
-    def self.bmbm(label_width = nil)
-	yield(gather = new)
-
-	title = "Rehearsal"
-	puts title + " " + "-" * (SCREEN_WIDTH - title.length - 1)
-	gather.format
-	puts "-" * SCREEN_WIDTH
-
-	yield(gather = new)
-	gather.format
-    end
-
-    def format(screen_width = SCREEN_WIDTH, margin = MARGIN)
-	data = profiles.map do |label, line_data|
-	    line_data['label'] = label
-	    line_data
-	end
-	ColumnFormatter.from_hashes(data, screen_width)
-    end
-
-    attribute(:profiles) { Array.new }
-    def report(label)
-	result = ObjectStats.profile do
-	    yield
-	end
-	result.inject({}) do |result, (klass, count)|
-	    klass = klass.to_s
-	    klass = "unknown" if !klass || klass.empty?
-	    result[klass] = count
-	    result
-	end
-	profiles << [label, result]
-    end
-end
-