jinx 2.1.3 → 2.1.4

data/lib/jinx/metadata/property.rb

@@ -272,8 +272,8 @@ module Jinx
       end
       @flags << flag
       case flag
-        when :owner then owner_flag_set
-        when :dependent then dependent_flag_set
+      when :owner then owner_flag_set
+      when :dependent then dependent_flag_set
       end
     end
     
@@ -286,12 +286,17 @@ module Jinx
       if dependent? then
         raise MetadataError.new("#{declarer.qp}.#{self} cannot be set as a #{type.qp} owner since it is already defined as a #{type.qp} dependent")
       end
-      inv_attr = type.dependent_attribute(@declarer)
-      if inv_attr.nil? then
-        raise MetadataError.new("#{@declarer.qp} owner attribute #{self} does not have a #{type.qp} dependent inverse")
+      inv_prop = inverse_property
+      if inv_prop then
+        inv_prop.qualify(:dependent) unless inv_prop.dependent?
+      else
+        inv_attr = type.dependent_attribute(@declarer)
+        if inv_attr.nil? then
+          raise MetadataError.new("The #{@declarer.qp} owner attribute #{self} of type #{type.qp} does not have an inverse")
+        end
+        logger.debug { "#{declarer.qp}.#{self} inverse is the #{type.qp} dependent attribute #{inv_attr}." }
+        self.inverse = inv_attr
       end
-      logger.debug { "#{declarer.qp}.#{self} inverse is the #{type.qp} dependent attribute #{inv_attr}." }
-      self.inverse = inv_attr
     end
     
     # Validates that this is not an owner attribute.
@@ -299,7 +304,7 @@ module Jinx
     # @raise [MetadataError] if this is an owner attribute
     def dependent_flag_set
       if owner? then
-        raise MetadataError.new("#{declarer.qp}.#{self} cannot be set as a  #{type.qp} dependent since it is already defined as a #{type.qp} owner")
+        raise MetadataError.new("#{declarer.qp}.#{self} cannot be set as a #{type.qp} dependent since it is already defined as a #{type.qp} owner")
       end
     end
   end

data/lib/jinx/metadata/property_characteristics.rb

@@ -30,8 +30,8 @@ module Jinx
     # @return [Boolean] whether the subject attribute returns a domain object or a collection
     #   of domain objects
     def domain?
-      # the type must be a Ruby class rather than a Java Class, and include the Domain mix-in
-      Class === type and type < Resource
+      # the type must be a Ruby class that extends the {Metadata} mix-in
+      Class === type and type < Resource and type.introspected?
     end
 
     # @return [Boolean] whether the subject attribute is not a domain object attribute

data/lib/jinx/resource.rb

@@ -29,13 +29,16 @@ module Jinx
   #   module Domain
   #     include Jinx::Resource  
   #     # The caTissue Java package name.
-  #     packages 'app.domain'
+  #     package 'app.domain'
   #     # The JRuby mix-ins directory.
   #     definitions File.expand_path('domain', dirname(__FILE__))
   #   end
   module Resource
     include Mergeable, Inversible
     
+    # A proxied subclass can override the +domain_class+.
+    alias :domain_class :class
+    
     # @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.
@@ -45,6 +48,13 @@ module Jinx
       # make a hash code on demand
       @_hc ||= (Object.new.object_id * 31) + 17
     end
+     
+    # Initialization hook. This default implementation is a no-op.
+    #
+    # @quirk JRuby calling super in a module initialize method results in an infinite loop.
+    #   The work-around is to add a post_initialize method that mix-in modules can override.
+    def post_initialize
+    end
     
     # Prints this object's class demodulized name and object id.
     def print_class_and_id
@@ -134,12 +144,13 @@ module Jinx
     # is preserved, e.g. an Array value is assigned to a set domain type by first clearing the set
     # and then merging the array content into the set.
     #
-    # @see Mergeable#merge_attribute
-    def set_property_value(attribute, value)
-      prop = self.class.property(attribute)
+    # @param [Property, Symbol] prop the property or attribute to set
+    # @param value the new value
+    def set_property_value(prop, value)
+      prop = self.class.property(prop) if Symbol === prop
       if prop.domain? and prop.collection? then
-        clear_attribute(attribute)
-        merge_attribute(attribute, value)
+        clear_attribute(prop.attribute)
+        merge_attribute(prop.attribute, value)
       else
         set_typed_property_value(prop, value)
       end
@@ -196,8 +207,10 @@ module Jinx
       self.class.owner_attributes.detect_value { |pa| send(pa) }
     end
 
-    # @return [(Property, Resource), nil] the (property, value) pair for which there is an
-    # owner reference, or nil if this domain object does not reference an owner
+    # Returns the (property, value) pair for which there is an owner reference, or nil if
+    # this domain object does not reference an owner.
+    #
+    # @return [(Property, Resource), nil] the owner (property, value) pair
     def effective_owner_property_value
       self.class.owner_properties.detect_value do |op|
         ref = send(op.attribute)
@@ -207,12 +220,17 @@ module Jinx
     
     # Sets this dependent's owner attribute to the given domain object.
     #
-    # @param [Resource] owner the owner domain object
-    # @raise [NoMethodError] if this Resource's class does not have exactly one owner attribute
-    def owner=(owner)
-      pa = self.class.owner_attribute
-      if pa.nil? then raise NoMethodError.new("#{self.class.qp} does not have a unique owner attribute") end
-      set_property_value(pa, owner)
+    # @param [Resource] obj the owner domain object
+    # @raise [NoMethodError] if this Resource's class does not have an owner property
+    #   which accepts the given domain object
+    def owner=(obj)
+      if obj.nil? then
+        op, ov = effective_owner_property_value || return
+      else
+        op = self.class.owner_properties.detect { |prop| prop.type === obj }
+      end
+      if op.nil? then raise NoMethodError.new("#{self.class.qp} does not have an owner attribute for #{obj}") end
+      set_property_value(op.attribute, obj)
     end
 
     # @param [Resource] other the domain object to check
@@ -220,26 +238,36 @@ module Jinx
     #  {#owner_ancestor?} of this object's {#owner}
     def owner_ancestor?(other)
       ownr = self.owner
-      ownr and (ownr == other or ownr.owner_ancestor?(other))
+      if ownr then
+        ownr == other or ownr.owner_ancestor?(other)
+      elsif self.class.owner_types.size == self.class.owner_properties.size then
+        false
+      else
+        path = other.class.dependency_path_to(self.class)
+        !!path and other.reachable?(self, path)
+      end
     end
     
+    # @param [Resource] other the domain object to check
+    # @param [<Property>] the property path to follow
+    # @return [Boolean] whether following there is a path from this object through the given
+    #   properties to the other object
+    def reachable?(other, path)
+      return false if path.empty?
+      prop = path.shift
+      send(prop.attribute).to_enum.any? do |ref|
+        ref == other or ref.reachable?(other, path)
+      end
+    end
+        
     # @param [Resource] other the domain object to check
     # @return [Boolean] whether the other domain object is a dependent of this object
     #  and has an update-only non-domain attribute.
     def dependent_update_only?(other)
       other.owner == self and
-      other.class.nondomain_attributes.detect_with_property { |prop| prop.updatable? and not prop.creatable? }
-    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 {Propertied#attributes}.
-    # Only non-nil attributes defined by this Resource are included in the result hash.
-    #
-    # @param [<Symbol>, nil] attributes the attributes to merge
-    # @return [{Symbol => Object}] the attribute => value hash
-    def value_hash(attributes=nil)
-      attributes ||= self.class.attributes
-      attributes.to_compact_hash { |pa| send(pa) if self.class.method_defined?(pa) }
+      other.class.nondomain_attributes.detect_attribute_with_property do |prop|
+        prop.updatable? and not prop.creatable?
+      end
     end
 
     # Returns the domain object references for the given attributes.
@@ -398,13 +426,15 @@ module Jinx
     #
     # @param [Resource] other the domain object to compare
     # @param [<Symbol>, nil] attributes the attributes to compare
-    # @return (see Hashable#diff)
-    def diff(other, attributes=nil)
+    # @return (see Hasher#diff)
+    def difference(other, attributes=nil)
       attributes ||= self.class.nondomain_attributes
       vh = value_hash(attributes)
       ovh = other.value_hash(attributes)
       vh.diff(ovh) { |key, v1, v2| Resource.value_equal?(v1, v2) }
     end
+    
+    alias :diff :difference
 
     # Returns the domain object in others which matches this dependent domain object
     # within the scope of a parent on a minimally acceptable constraint. This method
@@ -696,7 +726,7 @@ module Jinx
         end
       end
       # If there is an owner reference attribute, then there must be an owner.
-      if self.class.bidirectional_dependent? then
+      if self.class.bidirectional_java_dependent? then
         raise ValidationError.new("Dependent #{self} does not reference an owner")
       end
     end
@@ -708,8 +738,8 @@ module Jinx
       begin
         send(property.writer, value)
       rescue TypeError
-        # Add the attribute to the error message.
-        raise TypeError.new("Cannot set #{self.class.qp} #{property} to #{value.qp} - " + $!)
+        logger.error("Cannot set #{self.class.qp} #{property} to #{value.qp} - " + $!)
+        raise
       end
     end
     

data/lib/jinx/resource/inversible.rb

@@ -34,8 +34,10 @@ module Jinx
         clr_wtr = self.class === oldval && oldval.send(rdr).equal?(self) ? wtr : inverse_writer
         oldval.send(clr_wtr, nil)
       end
+      
       # call the writer
       send(wtr, newval)
+      
       # call the inverse writer on self
       if newval then
         newval.send(inverse_writer, self)
@@ -67,8 +69,10 @@ module Jinx
         coll = oldval.send(inverse)
         coll.delete(self) if coll
       end
+      
       # call the writer on this object
       send(wtr, newval)
+      
       # add self to the inverse collection
       if newval then
         coll = newval.send(inverse)

data/lib/jinx/resource/match_visitor.rb

@@ -149,7 +149,6 @@ module Jinx
       # add residual matches
       rsd_mtchs.each { |src, tgt| add_match(src, tgt) }
       logger.debug { "#{qp} matched #{rsd_mtchs.qp}..." } if @verbose and not rsd_mtchs.empty?
-      
       # The source => target match hash.
       # If there is a copier, then copy each unmatched source.
       matches = srcs.to_compact_hash { |src| match_for(src) or copy_unmatched(src) }

data/lib/jinx/resource/mergeable.rb

@@ -39,10 +39,9 @@ module Jinx
       return self if other.nil? or other.equal?(self)
       attributes = [attributes] if Symbol === attributes
       attributes ||= self.class.mergeable_attributes
-
-      # if the source object is not a hash, then convert it to an attribute => value hash
-      vh = Hashable === other ? other : other.value_hash(attributes)
-      # merge the value hash
+      # If the source object is not a hash, then convert it to an attribute => value hash.
+      vh = Hasher === other ? other : other.value_hash(attributes)
+      # Merge the Java values hash.
       vh.each { |pa, value| merge_attribute(pa, value, matches, &filter) }
       self
     end
@@ -100,6 +99,17 @@ module Jinx
       end
     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 {Propertied#attributes}.
+    # Only non-nil values of attributes defined by this domain object are included in the result hash.
+    #
+    # @param [<Symbol>, nil] attributes the attributes to merge
+    # @return [{Symbol => Object}] the attribute => value hash
+    def value_hash(attributes=nil)
+      attributes ||= self.class.attributes
+      attributes.to_compact_hash { |pa| send(pa) rescue nil }
+    end
+
     private
 
     # @see #merge_attribute
@@ -118,7 +128,7 @@ module Jinx
       # the dependent owner writer method, if any
       if property.dependent? then
         val = property.collection? ? newval.first : newval
-        klass = val.class if val
+        klass = val.domain_class if val
         inv_prop = self.class.inverse_property(property, klass)
         if inv_prop and not inv_prop.collection? then
           owtr = inv_prop.writer
@@ -178,8 +188,8 @@ module Jinx
         # If the target is a dependent, then set the dependent owner, which will in turn
         # set the attribute to the dependent. Otherwise, set the attribute to the target.
         owtr ? delegate_to_inverse_setter(property, ref, owtr) : set_typed_property_value(property, ref)
+        ref
       end
-      newval
     end
 
     # @quirk Java Java TreeSet comparison uses the TreeSet comparator rather than an

data/lib/jinx/resource/reference_enumerator.rb

@@ -2,14 +2,13 @@ require 'enumerator'
 require 'generator'
 require 'jinx/helpers/options'
 require 'jinx/helpers/collections'
-
 require 'jinx/helpers/validation'
 require 'jinx/helpers/visitor'
 
 module Jinx
   # A ReferenceEnumerator iterates over domain property references.
   class ReferenceEnumerator
-    include Enumerable
+    include Enumerable, Collection
     
     # @return [Resource] the domain object containing the references
     attr_reader :subject

data/lib/jinx/version.rb

@@ -1,3 +1,3 @@
 module Jinx
-  VERSION = '2.1.3'
+  VERSION = '2.1.4'
 end

data/test/lib/jinx/helpers/collections_test.rb

@@ -66,6 +66,10 @@ class CollectionsTest < Test::Unit::TestCase
    assert_nil([1, 2, 3].detect_value { |item| item * 2 if item > 3 }, "Value incorrectly detected")
   end
 
+  def test_hash_detect_value
+   assert_equal(4, {1 => 2, 3 => 4}.detect_value { |k, v| v if k > 1 }, "Detect hash value incorrect")
+  end
+
   def test_detect_with_value
     assert_equal([2, 1], [1, 2].detect_with_value { |item| item / 2 if item % 2 == 0 }, "Detect with value incorrect")
   end
@@ -96,12 +100,15 @@ class CollectionsTest < Test::Unit::TestCase
 
   def test_union
     base = [1, 2]
-    sum = base.union([4])
-    assert_equal([1, 2, 4], sum.to_a, 'Enumerator union incorrect')
-    assert(sum.include?(2), "Enumerator union missing first array element")
-    assert(sum.include?(4), "Enumerator union missing second array element")
+    u = base.union([4])
+    assert_equal([1, 2, 4], u.to_a, 'Enumerator on union incorrect')
+    assert(u.include?(2), "Enumerator on union missing first array element")
+    assert(u.include?(4), "Enumerator on union missing second array element")
     base << 3
-    assert_equal([1, 2, 3, 4], sum.to_a, 'Enumerator union does not reflect operand modification')
+    assert_equal([1, 2, 3, 4], u.to_a, 'Enumerator on union does not reflect operand modification')
+    # A union of a unions yields the flattened result.
+    uu = u.union([5])
+    assert_equal([1, 2, 3, 4, 5], uu.to_a, 'Enumerator on union of unions incorrect')
   end
 
   def test_intersection
@@ -137,9 +144,16 @@ class CollectionsTest < Test::Unit::TestCase
   end
   
   def test_partial_sort
-    sorted = [Array, Object, Numeric, Enumerable, Set].partial_sort
+    sorted = [Enumerable, Array, Object, String].partial_sort
     assert(sorted.index(Array) < sorted.index(Enumerable), "Partial sort order incorrect")
-    assert(sorted.index(Set) < sorted.index(Enumerable), "Partial sort order incorrect")
+    assert(sorted.index(Array) < sorted.index(Object), "Partial sort order incorrect")
+    assert(sorted.index(String) < sorted.index(Enumerable), "Partial sort order incorrect")
+    assert(sorted.index(String) < sorted.index(Object), "Partial sort order incorrect")
+  end
+  
+  def test_partial_sort_with_block
+    sorted = [Array, Module, Enumerable].partial_sort { |a, b| b <=> a }
+    assert(sorted.index(Array) > sorted.index(Enumerable), "Partial sort order incorrect")
   end
 
   def test_hash_union
@@ -182,7 +196,7 @@ class CollectionsTest < Test::Unit::TestCase
     assert_equal(expected, actual, 'Association hash incorrect')
   end
 
-  def test_hashable_equal
+  def test_hasher_equal
     assert_equal({:a => 1}, {:a => 1}.filter, "Hash equal incorrect")
   end
 
@@ -305,11 +319,12 @@ class CollectionsTest < Test::Unit::TestCase
   end
 
   def test_key_transformer_hash
-    hash = Jinx::KeyTransformerHash.new { |k| k % 2 }
-    hash[1] = :a
-    assert_equal(:a, hash[1], 'Key transformer hash entered value not found')
-    assert_nil(hash[2], 'Transformed hash unentered value found')
-    assert_equal(:a, hash[3], 'Key transformer hash equivalent value not found')
+    h = {1 => :a, 2 => :b}
+    xfm = h.transform_key { |n| n * 2 }
+    assert_equal([2, 4], xfm.keys, 'Key transformer hash keys incorrect') 
+    assert_equal(:a, xfm[2], 'Key transformer hash access incorrect') 
+    h[3] = :c
+    assert_equal(:c, xfm[6], 'Key transformer hash does not reflect change to underlying hash')
   end
 
   def test_transform_value
@@ -347,7 +362,7 @@ class CollectionsTest < Test::Unit::TestCase
     assert_nil(hash[:c], "Hashinator has association not in the base")
     base.first[1] = 3
     assert_equal(3, hash[:a], "Hashinator does not reflect change to underlying Enumerator")
-    assert_equal(base, hash.to_hash.to_a, "Hashable to_hash incorrect")
+    assert_equal(base, hash.to_hash.to_a, "Hasher to_hash incorrect")
   end
 
   def test_collector

data/test/lib/jinx/helpers/visitor_test.rb

@@ -83,21 +83,6 @@ class VistorTest < Test::Unit::TestCase
     assert_equal(3, child.value, "Child visited twice")
   end
 
-  def test_root_cycle
-    parent = Node.new(1)
-    c1 = Node.new(2, parent)
-    c2 = Node.new(3, parent)
-    c2.children << parent
-    gc11 = Node.new(4, c1)
-    gc12 = Node.new(5, c1)
-    gc12.children << c1
-    gc121 = Node.new(6, gc12)
-    gc121.children << parent
-    visitor = Jinx::Visitor.new { |node| node.children }
-    result = visitor.visit(parent)
-    assert_equal([[2, 5, 2], [1, 2, 5, 6, 1], [1, 3, 1]], visitor.cycles.map { |cycle| cycle.map { |node| node.value } }, "Root cycles incorrect")
-  end
-
   def increment(parent, limit)
     visitor = Jinx::Visitor.new { |node| node.children }
     visitor.visit(parent) { |node| node.value < limit ? node.value += 1 : return }
@@ -122,11 +107,13 @@ class VistorTest < Test::Unit::TestCase
     c1 = Node.new(2, parent)
     c2 = Node.new(3, parent)
     visitor = Jinx::Visitor.new { |node| node.children }
-    result = visitor.to_enum(parent).map { |node| node.value }
-    assert_equal([1, 2, 3], result, "Enumeration result incorrect")
+    result = visitor.to_enum(parent).to_a
+    assert_equal([parent, c1, c2], result, "Enumeration result incorrect")
   end
 
-  def test_exclude_cycles
+  def test_prune_cycle
+    # Make a graph with paths parent -> c1 -> gc11 -> c1 and
+    # parent -> c2 -> gc21 -> parent.
     parent = Node.new(1)
     c1 = Node.new(2, parent)
     gc11 = Node.new(3, c1)
@@ -135,8 +122,8 @@ class VistorTest < Test::Unit::TestCase
     gc21 = Node.new(5, c2)
     gc21.children << parent
     visitor = Jinx::Visitor.new(:prune_cycle) { |node| node.children }
-    result = visitor.to_enum(parent).map { |node| node.value }
-    assert_equal([1, 2, 3], result, "Exclude result incorrect")
+    result = visitor.to_enum(parent).to_a
+    assert_equal([parent, c1], result, "Exclude result incorrect")
   end
 
   def test_missing_block