caruby-core 1.4.9 → 1.5.1

data/lib/caruby/resource.rb

@@ -4,12 +4,14 @@ require 'caruby/util/log'
 require 'caruby/util/pretty_print'
 require 'caruby/util/validation'
 require 'caruby/util/collection'
+require 'caruby/domain'
+require 'caruby/domain/mixin'
 require 'caruby/domain/merge'
 require 'caruby/domain/reference_visitor'
 require 'caruby/database/persistable'
 require 'caruby/domain/inversible'
-require 'caruby/domain/resource_metadata'
-require 'caruby/domain/resource_module'
+require 'caruby/domain/metadata'
+require 'caruby/domain/mixin'
 require 'caruby/migration/migratable'
 
 module CaRuby
@@ -19,9 +21,9 @@ module CaRuby
   module Resource
     include Mergeable, Migratable, Persistable, Inversible
     
-    # JRuby alert - Bug #5090 - JRuby 1.5 object_id no longer reserved, results in String value.
-    # See http://jira.codehaus.org/browse/JRUBY-5090.
-    # Work-around is to make a proxy object id.
+    # @quirk JRuby Bug #5090 - JRuby 1.5 object_id is no longer a reserved method, and results
+    #   in a String value rather than an Integer (cf. http://jira.codehaus.org/browse/JRUBY-5090).
+    #   Work-around is to make a proxy object id.
     #
     # @return [Integer] the object id
     def proxy_object_id
@@ -38,10 +40,9 @@ module CaRuby
 
     # Sets the default attribute values for this domain object and its dependents. If this Resource
     # does not have an identifier, then missing attributes are set to the values defined by
-    # {ResourceAttributes#add_attribute_defaults}.
+    # {Attributes#add_attribute_defaults}.
     #
-    # _Implementation Note_: subclasses should override the private {#add_defaults_local} method
-    # rather than this method.
+    # Subclasses should override the private {#add_defaults_local} method rather than this method.
     #
     # @return [Resource] self
     def add_defaults
@@ -61,7 +62,7 @@ module CaRuby
       add_defaults_recursive
     end
 
-    # Validates this domain object and its #{ResourceAttributes.unproxied_save_template_attributes}
+    # Validates this domain object and its #{Attributes.unproxied_savable_template_attributes}
     # for completeness prior to a database create operation.
     # An object without an identifer is valid if it contains a non-nil value for each mandatory property.
     # Objects which have an identifier or have already been validated are skipped.
@@ -69,18 +70,30 @@ module CaRuby
     # Subclasses should not override this method, but override the private {#local_validate} instead.
     #
     # @return [Resource] this domain object
-    # @raise (see #local_validate)
+    # @raise (see #validate_local)
     def validate
       if identifier.nil? and not @validated then
         validate_local
         @validated = true
       end
-      self.class.unproxied_save_template_attributes.each do |attr|
+      self.class.unproxied_savable_template_attributes.each do |attr|
         send(attr).enumerate { |dep| dep.validate }
       end
       self
     end
     
+    # Adds the default values to this object, if it is not already fetched, and its dependents.
+    #
+    # This method is intended for use only by the {#add_defaults} method.
+    def add_defaults_recursive
+      # Add the local defaults.
+      # The lazy loader is enabled in order to allow subclass add_defaults_local implementations
+      # to pick up load-on-demand references used to set defaults. 
+      database.lazy_loader.enable { add_defaults_local }
+      # add dependent defaults
+      each_defaults_dependent { |dep| dep.add_defaults_recursive }
+    end
+    
     # @return [Boolean] whether this domain object has {#searchable_attributes}
     def searchable?
       not searchable_attributes.nil?
@@ -104,11 +117,12 @@ module CaRuby
       return key_attrs if key_searchable?(key_attrs)
     end
 
-    # Returns a new domain object with the given attributes copied from this domain object. The attributes
-    # argument consists of either attribute Symbols or a single Enumerable consisting of Symbols.
-    # The default attributes are the {ResourceAttributes#nondomain_attributes}.
+    # Returns a new domain object with the given attributes copied from this domain object.
+    # The attributes argument consists of either attribute Symbols or a single Enumerable
+    # consisting of Symbols.
+    # The default attributes are the {Attributes#nondomain_attributes}.
     #
-    # @param [<Symbol>] attributes the attributes to copy
+    # @param [<Symbol>, (<Symbol>)] attributes the attributes to copy
     # @return [Resource] a copy of this domain object
     def copy(*attributes)
       if attributes.empty? then
@@ -121,7 +135,7 @@ module CaRuby
     end
 
     # Clears the given attribute value. If the current value responds to the +clear+ method,
-    # then the current value is cleared. Otherwise, the value is set to {ResourceMetadata#empty_value}.
+    # then the current value is cleared. Otherwise, the value is set to {Metadata#empty_value}.
     #
     # @param [Symbol] attribute the attribute to clear
     def clear_attribute(attribute)
@@ -199,7 +213,7 @@ module CaRuby
     end
 
     # Returns an attribute => value hash for the specified attributes with a non-nil, non-empty value.
-    # The default attributes are this domain object's class {ResourceAttributes#attributes}.
+    # The default attributes are this domain object's class {Attributes#attributes}.
     # Only non-nil attributes defined by this Resource are included in the result hash.
     #
     # @param [<Symbol>, nil] attributes the attributes to merge
@@ -244,7 +258,7 @@ module CaRuby
     end
     
     # Returns the attributes which are required for save. This base implementation returns the
-    # class {ResourceAttributes#mandatory_attributes}. Subclasses can override this method
+    # class {Attributes#mandatory_attributes}. Subclasses can override this method
     # for domain object state-specific refinements.
     #
     # @return [<Symbol>] the required attributes for a save operation
@@ -327,7 +341,7 @@ module CaRuby
     end
 
     # Returns the difference between this Persistable and the other Persistable for the
-    # given attributes. The default attributes are the {ResourceAttributes#nondomain_attributes}.
+    # given attributes. The default attributes are the {Attributes#nondomain_attributes}.
     #
     # @param [Resource] other the domain object to compare
     # @param [<Symbol>, nil] attributes the attributes to compare
@@ -434,7 +448,7 @@ module CaRuby
 
     # Prints this domain object's content and recursively prints the referenced content.
     # The optional selector block determines the attributes to print. The default is the
-    # {ResourceAttributes#java_attributes}. The database lazy loader is disabled during
+    # {Attributes#java_attributes}. The database lazy loader is disabled during
     # the execution of this method. Thus, the printed content reflects the transient
     # in-memory object graph rather than the persistent content.
     #
@@ -503,14 +517,6 @@ module CaRuby
     
     protected
 
-    # Adds the default values to this object, if it is not already fetched, and its dependents.
-    def add_defaults_recursive
-      # add the local defaults unless there is an identifier
-      add_defaults_local
-      # add dependent defaults
-      each_defaults_dependent { |dep| dep.add_defaults_recursive }
-    end
-
     # Returns the required attributes for this domain object which are nil or empty.
     #
     # This method is in protected scope to allow the +CaTissue+ domain module to
@@ -697,6 +703,9 @@ module CaRuby
       end
     end
 
+    # @param [Attribute] attr_md the attribute to set
+    # @param [Resource] ref the inverse value
+    # @param [Symbol] the inverse => self writer method
     def delegate_to_inverse_setter(attr_md, ref, writer)
       logger.debug { "Setting #{qp} #{attr_md} by setting the #{ref.qp} inverse attribute #{attr_md.inverse}..." }
       ref.send(writer, self)
@@ -718,7 +727,7 @@ module CaRuby
     # Returns the Java type of the given attribute, or nil if attribute is not a Java property attribute.
     def java_type(attribute)
       attr_md = self.class.attribute_metadata(attribute)
-      attr_md.property_descriptor.property_type if JavaAttributeMetadata === attr_md
+      attr_md.property_descriptor.property_type if JavaAttribute === attr_md
     end
     
     # Executes the given block with the database lazy loader disabled, if any.
@@ -736,7 +745,7 @@ module CaRuby
     # oldval targets. If the matcher block is given, then that block is called on the sources
     # and targets. Otherwise, {Resource.match_all} is called.
     #
-    # @param [AttributeMetadata] attr_md the attribute to match
+    # @param [Attribute] attr_md the attribute to match
     # @param newval the source value
     # @param oldval the target value
     # @yield [sources, targets] matches sources to targets

data/lib/caruby/util/collection.rb

@@ -65,7 +65,14 @@ module Enumerable
   end
 
   # Returns a new Hash generated from this Enumerable with a block whose arguments include the enumerated item
-  # and its index. nil or empty values are excluded.
+  # and its index. Every value which is {#nil_or_empty} is excluded.
+  #
+  # @example
+  #   [1, 2, 3].to_compact_hash_with_index { |item, index| item + index } #=> { 1 => 1, 2 => 3, 3 => 5 }
+  # @yield [item, index] the hash value
+  # @yieldparam item the enumerated value
+  # @yieldparam index the enumeration index
+  # @return [Hash] this {Enumerable} converted to a hash by the given block
   def to_compact_hash_with_index
     hash = {}
     self.each_with_index do |item, index|
@@ -77,38 +84,38 @@ module Enumerable
     hash
   end
 
-  # Returns whether this Enumerable iterates over at least one item.
-  #
   # This method is functionally equivalent to +to_a.empty+ but is more concise and efficient.
+  #
+  # @return [Boolean] whether this Enumerable iterates over at least one item
   def empty?
     not any? { true }
   end
 
-  # Returns the first enumerated item in this Enumerable, or nil if this Enumerable is empty.
-  #
   # This method is functionally equivalent to +to_a.first+ but is more concise and efficient.
+  #
+  # @return the first enumerated item in this Enumerable, or nil if this Enumerable is empty
   def first
     detect { true }
   end
 
-  # Returns the last enumerated item in this Enumerable, or nil if this Enumerable is empty.
-  #
   # This method is functionally equivalent to +to_a.last+ but is more concise and efficient.
+  #
+  # @return the last enumerated item in this Enumerable, or nil if this Enumerable is empty
   def last
     detect { true }
   end
 
-  # Returns the count of items enumerated in this Enumerable.
-  #
   # This method is functionally equivalent to +to_a.size+ but is more concise and efficient
   # for an Enumerable which does not implement the {#size} method.
+  #
+  # @return [Integer] the count of items enumerated in this Enumerable
   def size
     inject(0) { |size, item| size + 1 }
   end
 
   alias :length :size
 
-  # Prints the content of this Enumerable as a series using {Array#to_series}.
+  # @return [String] the content of this Enumerable as a series using {Array#to_series}
   def to_series(conjunction=nil)
     to_a.to_series
   end
@@ -157,12 +164,12 @@ module Enumerable
   # Note, however, that unlike select, filter does not return an Array.
   # The default filter block returns the passed item.
   #
+  # @example
+  #   [1, nil, 3].filter.to_a #=> [1, 3]
   # @yield [item] filter the selection filter
   # @yieldparam item the collection member to filter
   # @return [Enumerable] the filtered result
-  # @example
-  #   [1, nil, 3].filter.to_a #=> [1, 3]
-  def filter(&filter) # :yields: item
+  def filter(&filter)
     Filter.new(self, &filter)
   end
 
@@ -238,6 +245,25 @@ module Enumerable
     Joiner.new(self, other)
   end
   
+  # Sorts this collection's members with a partial sort operator, i.e. the comparison returns -1, 0, 1 or nil.
+  # The resulting sorted order places each non-nil comparable items in the sort order. The order of nil
+  # comparison items is indeterminate.
+  #
+  # #example
+  #    [Array, Numeric, Enumerable, Set].partial_sort #=> [Array, Numeric, Set, Enumerable]
+  # @return [Enumerable] the items in this collection in partial sort order
+  def partial_sort
+    unless block_given? then return partial_sort { |item1, item2| item1 <=> item2 } end
+    sort { |item1, item2| yield(item1, item2) or 1 }
+  end
+  
+  # Sorts this collection's members with a partial sort operator on the results of applying the block.
+  #
+  # @return [Enumerable] the items in this collection in partial sort order
+  def partial_sort_by
+    partial_sort { |item1, item2| yield(item1) <=> yield(item2) }
+  end
+  
   # @yield [item] the transformer on the enumerated items
   # @yieldparam item an enumerated item
   # @return [Enumerable] the mapped values excluding null values
@@ -247,6 +273,7 @@ module Enumerable
 
   private
 
+  # This Filter helper class applies a selection block to a base enumeration.
   class Filter
     include Enumerable
 
@@ -272,7 +299,7 @@ module Enumerable
       super
     end
 
-    # Adds an item to the base Enumerable, if thif Filter's base supports it.
+    # Adds an item to the base Enumerable, if this Filter's base supports it.
     #
     # @param item the item to add
     # @return [Filter] self
@@ -297,6 +324,7 @@ module Enumerable
     end
   end
 
+  # This Transformer helper class applies a transformer block to a base enumeration.
   class Transformer
     include Enumerable
 
@@ -320,7 +348,9 @@ module Enumerable
   end
 
   # A MultiEnumerator iterates over several Enumerators in sequence. Unlike Array#+, MultiEnumerator reflects changes to the
-  # underlying enumerators, e.g.:
+  # underlying enumerators.
+  #
+  # @example
   #   a = [1, 2]
   #   b = [4, 5]
   #   ab = MultiEnumerator.new(a, b)
@@ -328,26 +358,32 @@ module Enumerable
   #   a << 3; b << 6; ab.to_a #=> [1, 2, 3, 4, 5, 6]
   class MultiEnumerator
     include Enumerable
+    
+    # @return [<Enumerable>] the enumerated collections
+    attr_reader :components
 
-    # Creates a new MultiEnumerator on the given Enumerator enums.
+    # Initializes a new {MultiEnumerator} on the given components.
+    #
+    # @param [<Enumerable>] the component enumerators to compose
     def initialize(*enums)
       super()
-      @enums = enums
-      @enums.compact!
+      @components = enums
+      @components.compact!
     end
 
     # Iterates over each of this MultiEnumerator's Enumerators in sequence.
     def each
-      @enums.each { |enum| enum.each { |item| yield item  } }
+      @components.each { |enum| enum.each { |item| yield item  } }
     end
   end
 end
 
-# The Collector utility module implements the {on} method to apply a block to
-# a collection transitive closure.
+# The Collector utility implements the {on} method to apply a block to a collection
+# transitive closure.
 module Collector
   # Collects the result of applying the given block to the given obj.
-  # If obj is a collection, then collects the result of recursively calling this Collector on the enumerated members.
+  # If obj is a collection, then collects the result of recursively calling this
+  # Collector on the enumerated members.
   # If obj is nil, then returns nil.
   # Otherwise, calls block on obj and returns the result.
   #
@@ -355,6 +391,7 @@ module Collector
   #  Collector.on([1, 2, [3, 4]]) { |n| n * 2 } #=> [2, 4, [6, 8]]]
   #  Collector.on(nil) { |n| n * 2 } #=> nil
   #  Collector.on(1) { |n| n * 2 } #=> 2
+  # @param obj the collection or item to enumerate
   def self.on(obj, &block)
     obj.collection? ? obj.map { |item| on(item, &block) } : yield(obj) unless obj.nil?
   end
@@ -366,12 +403,17 @@ class Object
   # item in this Enumerable.
   # * Otherwise, if this object is non-nil, then the the block is called on self.
   # * Otherwise, this object is nil and this method is a no-op.
+  #
+  # @yield [item] the block to apply to this object
+  # @yieldparam item the enumerated items, or this object if it is non-nil and not an Enumerable 
   def enumerate(&block)
     Enumerable === self ? each(&block) : yield(self) unless nil?
   end
 
   # Returns an enumerator on this Object. This default implementation returns an Enumerable::Enumerator
   # on enumerate.
+  #
+  # @return [Enumerable] this object as an enumerable item
   def to_enum
     Enumerable::Enumerator.new(self, :enumerate)
   end
@@ -395,8 +437,9 @@ class Flattener
     obj.collection? ? obj.each { |item| on(item, &block) } : yield(obj) unless obj.nil?
   end
 
-  # Creates a new Flattener on the given object. obj can be an Enumerable,
-  # a single non-collection object or nil.
+  # Initializes a new Flattener on the given object.
+  #
+  # @param obj the Enumerable or non-collection object
   def initialize(obj)
     @base = obj
   end
@@ -416,9 +459,9 @@ class Flattener
   end
 end
 
-# ConditionalEnumerator applies a filter to another Enumerable, e.g.:
+# ConditionalEnumerator applies a filter to another Enumerable.
+# @example
 #   ConditionalEnumerator.new([1, 2, 3]) { |i| i < 3 }.to_a #=> [1, 2]
-#
 class ConditionalEnumerator
   include Enumerable
 
@@ -456,13 +499,28 @@ module Hashable
     each { |key, value| yield key }
   end
 
-  # @return [Object,nil] the key for which the block given to this method returns a non-nil, non-false value,
+  # @yield [key] the detector block
+  # @yieldparam key the hash key
+  # @return [Object, nil] the key for which the detector block returns a non-nil, non-false value,
   #   or nil if none
+  # @example
+  #   {1 => :a, 2 => :b, 3 => :c}.detect_key { |k| k > 1 } #=> 2
   def detect_key
     each_key { |key| return key if yield key }
     nil
   end
 
+  # @yield [value] the detector block
+  # @yieldparam value the hash value
+  # @return [Object, nil] the key for which the detector block returns a non-nil, non-false value,
+  #   or nil if none
+  # @example
+  #   {:a => 1, :b => 2, :c => 3}.detect_key_with_value { |v| v > 1 } #=> :b
+  def detect_key_with_value
+    each { |key, value| return key if yield value }
+    nil
+  end
+
   # @see Hash#each_value
   def each_value
     each { |key, value| yield value }
@@ -793,29 +851,32 @@ module Hashable
   # Combines hashes. See Hash#+ for details.
   class MultiHash
     include Hashable
+    
+    # @return [<Hashable>] the enumerated hashes
+    attr_reader :components
 
     def initialize(*hashes)
       if hashes.include?(nil) then raise ArgumentError.new("MultiHash is missing a component hash.") end
-      @hashes = hashes
+      @components = hashes
     end
 
     def [](key)
-      @hashes.each { |hash| return hash[key] if hash.has_key?(key) }
+      @components.each { |hash| return hash[key] if hash.has_key?(key) }
       nil
     end
 
     def has_key?(key)
-      @hashes.any? { |hash| hash.has_key?(key) }
+      @components.any? { |hash| hash.has_key?(key) }
     end
 
     def has_value?(value)
-      @hashes.any? { |hash| hash.has_value?(value) }
+      @components.any? { |hash| hash.has_value?(value) }
     end
 
     def each
-      @hashes.each_with_index do |hash, index|
+      @components.each_with_index do |hash, index|
         hash.each do |key, value|
-           yield(key, value) unless (0...index).any? { |i| @hashes[i].has_key?(key) }
+           yield(key, value) unless (0...index).any? { |i| @components[i].has_key?(key) }
         end
       end
       self

data/lib/caruby/util/coordinate.rb

@@ -1,4 +1,4 @@
-# JRuby alert - SyncEnumerator moved from generator to REXML in JRuby 1.5
+# JRuby SyncEnumerator moved from generator to REXML in JRuby 1.5
 require 'rexml/document'
 
 # A Coordinate is a convenience Array wrapper class with aliased #x, #y and {#z} dimensions.
@@ -41,22 +41,48 @@ class Coordinate < Array
     self[2] = value
   end
 
+  # @param [Coordinate] other the coordinate to compare
   # @return [Boolean] whether other is a Coordinate and has the same content as this Coordinate
   def ==(other)
     super rescue false
   end
+  
+  # @param (see #==)
+  # @return [Boolean] the comparison result
+  def <(other)
+    (self <=> other) < 0
+  end
+  
+  # @param (see #==)
+  # @return (see #<)
+  def <=(other)
+    (self <=> other) <= 0
+  end
+  
+  # @param (see #==)
+  # @return (see #<)
+  def >(other)
+    (self <=> other) > 0
+  end
+  
+  # @param (see #==)
+  # @return (see #<)
+  def >=(other)
+    (self <=> other) >= 0
+  end
 
   # Returns the comparison of the highest dimension which differs from the other
   # coordinate, or zero if all dimensions are the same. This comparator sorts
   # coordinates in z-y-x order.
   # @example
   #   Coordinate.new(2, 1) < Coordinate.new(1, 2) #=> true
+  # @param [Coordinate] other the coordinate to compare
   # @return [Integer] the high-to-low dimension comparison
   # @raise [ArgumentError] if this Coordinate dimension size Coordinate differs from that
   #   of the other Dimension or any of the dimension values are nil
   # @raise [TypeError] if other is not a Coordinate
   def <=>(other)
-    return true if equal?(other)
+    return 0 if equal?(other)
     raise TypeError.new("Can't compare #{self} with #{other} since it is not a Coordinate") unless Coordinate === other
     raise ArgumentError.new("Can't compare #{self} with #{other} since it has a different dimension count") unless size == other.size
     REXML::SyncEnumerator.new(self.reverse, other.reverse).each_with_index do |pair, index|

data/lib/caruby/util/log.rb

@@ -5,7 +5,7 @@ require 'caruby/util/collection'
 
 # @return [CaRuby::Logger] the global logger
 def logger
-  CaRuby::Log::instance.logger
+  CaRuby::Log.instance.logger
 end
 
 module CaRuby
@@ -50,7 +50,7 @@ module CaRuby
       shift_age = Options.get(:shift_age, options, 4)
       shift_size = Options.get(:shift_size, options, 16 * 1048576)
       @logger = MultilineLogger.new(dev, shift_age, shift_size)
-      @logger.level = Options.get(:debug, options) ? Logger::DEBUG : Logger::INFO
+      @logger.level = Options.get(:debug, options, ENV['DEBUG']) ? Logger::DEBUG : Logger::INFO
       @logger.info('============================================')
       @logger.info('Logging started.')
       @dev = dev
@@ -83,8 +83,8 @@ module CaRuby
       log_ndx = ARGV.index("--log") || ARGV.index("-l")
       if log_ndx then
         ARGV[log_ndx + 1]
-      elsif ENV.has_key?("CA_LOG") then
-        ENV["CA_LOG"]
+      elsif ENV.has_key?("LOG") then
+        ENV["LOG"]
       elsif defined?(DEF_LOG_FILE)
         DEF_LOG_FILE
       else

data/lib/caruby/util/module.rb

@@ -1,34 +1,18 @@
 class Module
-  # Returns the class or module with name in the parent module.
-  # If parent is nil, then name is looked up in the global context.
-  # Otherwise, this method returns {#module_with_name}.
-  def self.module_with_name(parent, name)
-    return parent.module_with_name(name) if parent
-    begin
-      constant = eval(name)
-    rescue Exception
-      return
-    end
-    constant if constant.is_a?(Module)
-  end
-
-  # Returns the class or module with name in this module.
-  # name can qualified by parent modules, e.g. +MyApp::Person+.
+  # Returns the class or module with the given name defined in this module.
+  # The name can qualified by parent modules, e.g. +MyApp::Person+.
   # If name cannot be resolved as a Module, then this method returns nil.
+  #
+  # @param [String] the class name
+  # @return [Module, nil] the class or module defined in this module, or nil if none 
   def module_with_name(name)
-    begin
-      constant = name.split('::').inject(parent) { |parent, name| parent.const_get(name) }
-    rescue Exception
-      return
-    end
-    constant if constant.is_a?(Module)
+    name.split('::').inject(self) { |parent, part| parent.const_get(part) } rescue nil
   end
-
-  # Returns the class with name in this module.
-  # name can qualified by parent modules, e.g. +MyApp::Person+.
-  # If name cannot be resolved as a Class, then this method returns nil.
-  def class_with_name
-    mod = module_with_name
-    mod if mod.is_a?(Class)
+  
+  # @example
+  #   A::B.parent_module #=> A
+  # @return [Module] this module's definition context
+  def parent_module
+    Kernel.module_with_name(name.split('::')[0..-2].join('::'))
   end
 end

data/lib/caruby/util/partial_order.rb

@@ -9,7 +9,6 @@
 #   module Queued
 #     attr_reader :queue
 #     def <=>(other)
-#       raise TypeError.new("Comparison argument is not another Queued item") unless Queued === other
 #       queue.index(self) <=> queue.index(other) if queue.equal?(other.queue)
 #     end
 #   end
@@ -19,18 +18,18 @@
 #   b < c #=> nil
 module PartialOrder
   include Comparable
-
+  
   Comparable.instance_methods(false).each do |m|
     define_method(m.to_sym) do |other|
        self <=> other ? super : nil
     end
-
-    # Returns true if other is an instance of this object's class and other == self,
-    # false otherwise.
-    def eql?(other)
-      self.class === other and super
-    end
-
-    alias :== :eql?
   end
+  
+  # @return [Boolean] true if other is an instance of this object's class and other == self,
+  #   false otherwise
+  def eql?(other)
+    self.class === other and super
+  end
+
+  alias :== :eql?
 end