jinx 2.1.1 → 2.1.2

data/lib/jinx/resource.rb

@@ -85,7 +85,7 @@ module Jinx
     # @return [Resource] this domain object
     # @raise (see #validate_local)
     def validate
-      if not @validated then
+      unless @validated then
         validate_local
         @validated = true
       end
@@ -104,7 +104,7 @@ module Jinx
       if attributes.empty? then
         attributes = self.class.nondomain_attributes
       elsif Enumerable === attributes.first then
-        Jinx.fail(ArgumentError, "#{qp} copy attributes argument is not a Symbol: #{attributes.first}") unless attributes.size == 1
+        raise ArgumentError.new("#{qp} copy attributes argument is not a Symbol: #{attributes.first}") unless attributes.size == 1
         attributes = attributes.first
       end
       self.class.new.merge_attributes(self, attributes)
@@ -136,10 +136,13 @@ module Jinx
     #
     # @see Mergeable#merge_attribute
     def set_property_value(attribute, value)
-      # bail out if the value argument is the current value
-      return value if value.equal?(send(attribute))
-      clear_attribute(attribute)
-      merge_attribute(attribute, value)
+      prop = self.class.property(attribute)
+      if prop.domain? and prop.collection? then
+        clear_attribute(attribute)
+        merge_attribute(attribute, value)
+      else
+        set_typed_property_value(prop, value)
+      end
     end
     
     # Returns the first non-nil {#key_value} for the primary, secondary
@@ -208,7 +211,7 @@ module Jinx
     # @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 Jinx.fail(NoMethodError, "#{self.class.qp} does not have a unique owner attribute") end
+      if pa.nil? then raise NoMethodError.new("#{self.class.qp} does not have a unique owner attribute") end
       set_property_value(pa, owner)
     end
 
@@ -324,6 +327,26 @@ module Jinx
       matches_key_attributes?(other, self.class.alternate_key_attributes)
     end
 
+    # Matches this domain object with the other domain object. The match
+    # succeeds if and only if the object classes match and for each
+    # attribute, at least one of the following conditions hold:
+    # * this object's attribute value is nil or empty
+    # * the other object's attribute value is nil or empty
+    # * if the attribute is a nondomain attribute, then the respective values
+    #   are equal
+    # * if the attribute value is a Resource, then the value recursively
+    #   matches the other value
+    # * if the attribute value is a Resource collection, then every
+    #   item in the collection matches some item in the other collection
+    #
+    # @param [Resource] the domain object to match
+    # @return [Boolean] whether this object matches the other object on class
+    #   and content
+    def content_matches?(other)
+      logger.debug { "Matching #{self} content against #{other}..." }
+      content_matches_recursive?(other)
+    end
+
     # Matches this dependent domain object with the others on type and key attributes
     # in the scope of a parent object.
     # Returns the object in others which matches this domain object, or nil if none.
@@ -448,7 +471,7 @@ module Jinx
     #
     # @yield [dep] operation on the visited domain object
     # @yieldparam [Resource] dep the domain object to visit 
-    def visit_dependents(&operator) # :yields: dependent
+    def visit_dependents(&operator)
       DEPENDENT_VISITOR.visit(self, &operator)
     end
 
@@ -472,9 +495,6 @@ module Jinx
     # 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
     # {Propertied#java_attributes}.
-    #
-    #
-    # TODO caRuby override to do_without_lazy_loader
     # 
     # @yield [owner] the owner attribute selector
     # @yieldparam [Resource] owner the domain object to print
@@ -569,6 +589,46 @@ module Jinx
       # Recurse to the dependents.
       each_defaultable_reference { |ref| ref.add_defaults_recursive }
     end
+    
+    # @param [Resource] (see #content_matches?) 
+    # @param [<Resource>] visited the matched references
+    # @return (see #content_matches?)
+    def content_matches_recursive?(other, visited=Set.new)
+      return false unless self.class == other.class
+      return false unless self.class.nondomain_attributes.all? do |pa|
+        v = send(pa)
+        ov = other.send(pa)
+        if v.nil? || ov.nil? or Resource.value_equal?(v, ov) then
+          true
+        else
+          logger.debug { "#{self} does not match #{other} on property #{pa}: #{v.qp} vs #{ov.qp}" }
+          false
+        end
+      end  
+      self.class.domain_attributes.all? do |pa|
+        v = send(pa)
+        ov = other.send(pa)
+        if v.nil_or_empty? or ov.nil_or_empty? or visited.include?(v) then
+          true
+        else
+          logger.debug { "Matching #{self} #{pa} value #{v.qp} against #{other} #{pa} value #{ov.qp}..." }
+          if Enumerable === v then
+            v.all? do |ref|
+              oref = ref.match_in(ov)
+              if oref.nil? then
+                logger.debug { "#{self} does not match #{other} on property #{pa}: #{v.pp_s} vs #{ov.pp_s}" }
+                false
+              else
+                ref.content_matches_recursive?(oref, visited)
+              end
+            end
+          else
+            visited << v
+            v.content_matches_recursive?(ov, visited)
+          end
+        end
+      end  
+    end
 
     private
 
@@ -614,7 +674,7 @@ module Jinx
       invalid = missing_mandatory_attributes
       unless invalid.empty? then
         logger.error("Validation of #{qp} unsuccessful - missing #{invalid.join(', ')}:\n#{dump}")
-        Jinx.fail(ValidationError, "Required attribute value missing for #{self}: #{invalid.join(', ')}")
+        raise ValidationError.new("Required attribute value missing for #{self}: #{invalid.join(', ')}")
       end
       validate_owner
     end
@@ -632,12 +692,24 @@ module Jinx
       if self.class.owner_attributes.size > 1 then
         vh = value_hash(self.class.owner_attributes)
         if vh.size > 1 then
-          Jinx.fail(ValidationError, "Dependent #{self} references multiple owners #{vh.pp_s}:\n#{dump}")
+          raise ValidationError.new("Dependent #{self} references multiple owners #{vh.pp_s}:\n#{dump}")
         end
       end
       # If there is an owner reference attribute, then there must be an owner.
       if self.class.bidirectional_dependent? then
-        Jinx.fail(ValidationError, "Dependent #{self} does not reference an owner")
+        raise ValidationError.new("Dependent #{self} does not reference an owner")
+      end
+    end
+       
+    # @param [Property] property the property to set
+    # @param value the new value
+    # @raise [TypeError] if the value is incompatible with the property
+    def set_typed_property_value(property, value)
+      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} - " + $!)
       end
     end
     

data/lib/jinx/resource/match_visitor.rb

@@ -20,7 +20,7 @@ module Jinx
     # @yield (see ReferenceVisitor#initialize)
     # @yieldparam [Resource] source the matched source object
     def initialize(opts=nil)
-      Jinx.fail(ArgumentError, "Reference visitor missing domain reference selector") unless block_given?
+      raise ArgumentError.new("Reference visitor missing domain reference selector") unless block_given?
       opts = Options.to_hash(opts)
       @matcher = opts.delete(:matcher) || DEF_MATCHER
       @matchable = opts.delete(:matchable)
@@ -35,9 +35,11 @@ module Jinx
       # only a matched reference is visited.
       super do |src|
         tgt = @matches[src]
-        attrs = yield(src)
-        match_references(src, tgt, attrs)
-        attrs
+        # the attributes to match on
+        mas = yield(src)
+        # match the attribute references
+        match_references(src, tgt, mas)
+        mas
       end
     end
 
@@ -98,7 +100,7 @@ module Jinx
     # @raise [ValidationError] if there is no match
     def match_for_visited(source)
       target = @matches[source]
-      if target.nil? then Jinx.fail(ValidationError, "Match visitor target not found for #{source}") end
+      if target.nil? then raise ValidationError.new("Match visitor target not found for #{source}") end
       target
     end
 

data/lib/jinx/resource/merge_visitor.rb

@@ -54,20 +54,13 @@ module Jinx
       return target if source.equal?(target)
       # the domain attributes to merge
       mas = @mergeable.call(source)
-      logger.debug { format_merge_log_message(source, target, mas) }
+      unless mas.empty? then
+        logger.debug { "Merging #{source.qp} #{mas.to_series} into #{target.qp}..." }
+      end
       # merge the non-domain attributes
       target.merge_attributes(source)
       # merge the source domain attributes into the target
       target.merge(source, mas, @matches)
     end
-    
-    # @param source (see #merge)
-    # @param target (see #merge)
-    # @param attributes (see Mergeable#merge)
-    # @return [String] the log message
-    def format_merge_log_message(source, target, attributes)
-      attr_clause = " including domain attributes #{attributes.to_series}" unless attributes.empty?
-      "Merging #{source.qp} into #{target.qp}#{attr_clause}..."
-    end
   end
 end

data/lib/jinx/resource/mergeable.rb

@@ -87,19 +87,19 @@ module Jinx
       # Discriminate between a domain and non-domain attribute.
       prop = self.class.property(attribute)
       if prop.domain? then
-        merge_domain_attribute_value(prop, oldval, newval, matches)
+        merge_domain_property_value(prop, oldval, newval, matches)
       else
-        merge_nondomain_attribute_value(prop, oldval, newval)
+        merge_nondomain_property_value(prop, oldval, newval)
       end
     end
 
     private
 
     # @see #merge_attribute
-    def merge_nondomain_attribute_value(prop, oldval, newval)
+    def merge_nondomain_property_value(property, oldval, newval)
       if oldval.nil? then
-        send(prop.writer, newval)
-      elsif prop.collection? then
+        set_typed_property_value(property, newval)
+      elsif property.collection? then
         oldval.merge(newval)
       else
         oldval
@@ -107,12 +107,12 @@ module Jinx
     end
     
     # @see #merge_attribute
-    def merge_domain_attribute_value(prop, oldval, newval, matches)
+    def merge_domain_property_value(property, oldval, newval, matches)
       # the dependent owner writer method, if any
-      if prop.dependent? then
-        val = prop.collection? ? newval.first : newval
+      if property.dependent? then
+        val = property.collection? ? newval.first : newval
         klass = val.class if val
-        inv_prop = self.class.inverse_property(prop, klass)
+        inv_prop = self.class.inverse_property(property, klass)
         if inv_prop and not inv_prop.collection? then
           owtr = inv_prop.writer
         end
@@ -122,14 +122,14 @@ module Jinx
       # collection value and add each unmatched source to the collection.
       # Otherwise, if the attribute is not yet set and there is a new value, then set it
       # to the new value match or the new value itself if unmatched.
-      if prop.collection? then
+      if property.collection? then
         # TODO - refactor into method
         if oldval.nil? then
-          Jinx.fail(ValidationError, "Merge into #{qp} #{prop} with nil collection value is not supported")
+          raise ValidationError.new("Merge into #{qp} #{property} with nil collection value is not supported")
         end
         # the references to add
         adds = []
-        logger.debug { "Merging #{newval.qp} into #{qp} #{prop} #{oldval.qp}..." } unless newval.nil_or_empty?
+        logger.debug { "Merging #{newval.qp} into #{qp} #{property} #{oldval.qp}..." } unless newval.nil_or_empty?
         newval.enumerate do |src|
           # If the match target is in the current collection, then update the matched
           # target from the source.
@@ -150,11 +150,11 @@ module Jinx
           end
         end
         # add the unmatched sources
-        logger.debug { "Adding #{qp} #{prop} unmatched #{adds.qp}..." } unless adds.empty?
+        logger.debug { "Adding #{qp} #{property} unmatched #{adds.qp}..." } unless adds.empty?
         adds.each do |ref|
           # If there is an owner writer attribute, then add the ref to the attribute collection by
           # delegating to the owner writer. Otherwise, add the ref to the attribute collection directly.
-          owtr ? delegate_to_inverse_setter(prop, ref, owtr) : oldval << ref
+          owtr ? delegate_to_inverse_setter(property, ref, owtr) : oldval << ref
         end
         oldval
       elsif newval.nil? then
@@ -167,10 +167,10 @@ module Jinx
         # No target; set the attribute to the source.
         # The target is either a source match or the source itself.
         ref = (matches[newval] if matches) || newval
-        logger.debug { "Setting #{qp} #{prop} reference #{ref.qp}..." }
+        logger.debug { "Setting #{qp} #{property} reference #{ref.qp}..." }
         # 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(prop, ref, owtr) : send(prop.writer, ref)
+        owtr ? delegate_to_inverse_setter(property, ref, owtr) : set_typed_property_value(property, ref)
       end
       newval
     end

data/lib/jinx/resource/reference_enumerator.rb

@@ -5,7 +5,6 @@ require 'jinx/helpers/collections'
 
 require 'jinx/helpers/validation'
 require 'jinx/helpers/visitor'
-require 'jinx/helpers/math'
 
 module Jinx
   # A ReferenceEnumerator iterates over domain property references.

data/lib/jinx/resource/reference_path_visitor.rb

@@ -28,7 +28,7 @@ module Jinx
       super(opts) do |ref|
         # Collect the path attributes whose type is the ref type up to the
         # next position in the path.
-        max = lineage.size.min(path.size)
+        max = Math.min(lineage.size, path.size)
         pas = (0...max).map { |i| path[i].attribute if path[i].declarer === ref }
         pas.compact!
         ref.class.attribute_filter(pas)

data/lib/jinx/resource/reference_visitor.rb

@@ -5,7 +5,6 @@ require 'jinx/helpers/collections'
 
 require 'jinx/helpers/validation'
 require 'jinx/helpers/visitor'
-require 'jinx/helpers/math'
 
 module Jinx
   # A ReferenceVisitor traverses reference attributes.
@@ -23,7 +22,7 @@ module Jinx
     #   current domain object
     # @yieldparam [Resource] obj the current domain object
     def initialize(opts=nil, &selector)
-      Jinx.fail(ArgumentError, "Reference visitor missing domain reference selector") unless block_given?
+      raise ArgumentError.new("Reference visitor missing domain reference selector") unless block_given?
       # the property selector
       @flt_sel = selector
       # the reference filter
@@ -33,11 +32,11 @@ module Jinx
       @ref_enums = {}
       super do |ref|
         # the reference property filter
-        attrs = attributes_to_visit(ref)
-        if attrs then
-          logger.debug { "#{qp} visiting #{ref} attributes #{attrs.pp_s(:single_line)}..." } if @verbose
+        ras = attributes_to_visit(ref)
+        if ras then
+          logger.debug { "#{qp} visiting #{ref} attributes #{ras.pp_s(:single_line)}..." } if @verbose
           # an enumerator on the reference properties
-          enum = ReferenceEnumerator.new(ref, attrs.properties)
+          enum = ReferenceEnumerator.new(ref, ras.properties)
           # If there is a reference filter, then apply it to the enum references.
           flt ? enum.filter(&flt) : enum
         end

data/lib/jinx/resource/unique.rb

@@ -8,7 +8,7 @@ module Jinx
     # Raises TypeError if value is neither nil nor a String.
     def uniquify_value(value)
       unless String === value or value.nil? then
-        Jinx.fail(TypeError, "Cannot uniquify #{qp} non-String value #{value}")
+        raise TypeError.new("Cannot uniquify #{qp} non-String value #{value}")
       end
       Uniquifier.instance.uniquify(self, value)
     end

data/lib/jinx/version.rb

@@ -1,3 +1,3 @@
 module Jinx
-  VERSION = "2.1.1"
+  VERSION = '2.1.2'
 end

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

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../../../helper'
+require 'test/unit'
+require 'jinx/helpers/associative'
+
+class AssociativeTest < Test::Unit::TestCase
+  def test_get
+    hash = {'a' => 1}
+    assoc = Jinx::Associative.new { |k| hash[k.to_s] }
+    assert_equal(1, assoc[:a], "Associative access incorrect.")
+    assert_nil(assoc[:b], "Associative access incorrectly returns a value.")
+  end
+  
+  def test_set
+    hash = {'a' => 1}
+    assoc = Jinx::Associative.new { |k| hash[k.to_s] }.writer { |k, v| hash[k.to_s] = v }
+    assert_equal(1, assoc[:a], "Associative access incorrect.")
+    assert_nil(assoc[:b], "Associative access incorrectly returns a value.")
+    assoc[:b] = 2
+    assert_equal(2, assoc[:b], "Associative writer incorrect.")
+    # reset the value
+    assoc[:a] = 3
+    assert_equal(3, assoc[:a], "Associative writer incorrect.")
+    # test the ||= idiom
+    assert_equal(4, assoc[:c] ||= 4, "Associative writer incorrect.") 
+  end
+end

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

@@ -3,7 +3,6 @@ require 'test/unit'
 require 'jinx/helpers/collections'
 require 'jinx/helpers/lazy_hash'
 require 'jinx/helpers/case_insensitive_hash'
-require 'jinx/helpers/key_transformer_hash'
 require 'jinx/helpers/conditional_enumerator'
 require 'jinx/helpers/multi_enumerator'
 
@@ -313,7 +312,7 @@ class CollectionsTest < Test::Unit::TestCase
     assert_equal(:a, hash[3], 'Key transformer hash equivalent value not found')
   end
 
-  def test_transformed_hash
+  def test_transform_value
     hash = {:a => 1, :b => 2}
     xfm = hash.transform_value { |v| v * 2 }
     assert_equal(2, xfm[:a], 'Transformed hash accessor incorrect')
@@ -326,6 +325,19 @@ class CollectionsTest < Test::Unit::TestCase
     assert_equal(8, xfm[:c], 'Transformed hash does not reflect base hash change')
   end
 
+  def test_transform_key
+    hash = {'a' => 1, 'b' => 2}
+    xfm = hash.transform_key { |k| k.to_sym }
+    assert_equal(1, xfm[:a], 'Transformed hash accessor incorrect')
+    assert_equal([:a, :b], xfm.keys.sort { |k1, k2| k1.to_s <=> k2.to_s }, 'Transformed hash keys incorrect')
+    assert(xfm.has_key?(:a), 'Transformed hash key query incorrect')
+    assert(!xfm.has_key?('a'), 'Transformed hash key query incorrect')
+    # base hash should be reflected in transformed hash
+    hash['b'] = 3; hash['c'] = 4
+    assert_equal(3, xfm[:b], 'Transformed hash does not reflect base hash change')
+    assert_equal(4, xfm[:c], 'Transformed hash does not reflect base hash change')
+  end
+
   def test_hashinator
     base = {:a => 1, :b => 2}.to_a
     hash = Jinx::Hashinator.new(base)

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

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../../../helper'
+require 'test/unit'
+require 'jinx/helpers/uniquifier'
+
+class UniquifierTest < Test::Unit::TestCase
+  def test_uniquify
+    u1 = Jinx::Uniquifier.instance.uniquify('Groucho')
+    u2 = Jinx::Uniquifier.instance.uniquify('Groucho')
+    assert_not_equal(u1, u2, "Consequetive uniquifier calls not unique")
+  end
+end