caruby-core 1.4.2 → 1.4.3

data/lib/caruby/import/java.rb

@@ -11,9 +11,7 @@ require 'caruby/util/class'
 require 'caruby/util/inflector'
 require 'caruby/util/collection'
 
-# include some standard Java classes
 module Java
-  
   # Adds the directories in the given path and all Java jar files contained in the directories
   # to the execution classpath.
   #
@@ -165,13 +163,13 @@ module Java
       def to_ruby_date
         calendar = java.util.Calendar.instance
         calendar.setTime(self)
-        secs = calendar.timeInMillis / 1000
+        secs = calendar.timeInMillis.to_f / 1000
         # millis since epoch
         time = Time.at(secs)
         # convert UTC timezone millisecond offset to Rational fraction of a day
         offset_millis = calendar.timeZone.getOffset(calendar.timeInMillis).to_f
         # adjust for DST
-        if calendar.timeZone.useDaylightTime and not time.isdst then
+        if calendar.timeZone.useDaylightTime and time.isdst then
           offset_millis -= MILLIS_PER_HR
         end
         offset_days = offset_millis / MILLIS_PER_DAY
@@ -200,7 +198,7 @@ module Java
         # the Java date factory
         calendar = java.util.Calendar.instance
         # adjust for DST
-        if calendar.timeZone.useDaylightTime and not Time.at(time).isdst then
+        if calendar.timeZone.useDaylightTime and Time.at(time).isdst then
           millis += MILLIS_PER_HR
         end
         calendar.setTimeInMillis(millis)
@@ -234,13 +232,13 @@ class Class
   # Otherwise, this method returns the Ruby class for the name of the presumed Java klass.
   def self.to_ruby(klass)
     case klass
-    when Class then klass
-    when String then Java.module_eval(klass)
-    else to_ruby(klass.name)
+      when Class then klass
+      when String then Java.module_eval(klass)
+      else to_ruby(klass.name)
     end
   end
 
-  # Returns whether this class is abstract.
+  # @return [Boolean] whether this is a wrapper for an abstract Java class
   def abstract?
     java_class? and Java::JavaLangReflect::Modifier.isAbstract(java_class.modifiers)
   end
@@ -260,6 +258,7 @@ class Class
   # If the hierarchy flag is set to +false+, then only this class's properties
   # will be introspected.
   def java_properties(hierarchy=true)
+    return Array::EMPTY_ARRAY  unless java_class?
     info = hierarchy ? Java::JavaBeans::Introspector.getBeanInfo(java_class) : Java::JavaBeans::Introspector.getBeanInfo(java_class, java_class.superclass)
     info.propertyDescriptors.select { |pd| pd.write_method and property_read_method(pd) }
   end

data/lib/caruby/migration/migrator.rb

@@ -1,7 +1,7 @@
 # load the required gems
 require 'rubygems'
 
-# the UOM gem
+# the Units of Measurement gem
 gem 'uom'
 
 require 'enumerator'
@@ -15,7 +15,7 @@ require 'caruby/util/options'
 require 'caruby/util/pretty_print'
 require 'caruby/util/properties'
 require 'caruby/util/collection'
-require 'caruby/migration/resource'
+require 'caruby/migration/migratable'
 
 module CaRuby
   class MigrationError < RuntimeError; end
@@ -33,7 +33,8 @@ module CaRuby
     # @option opts [String] :input required source file to migrate
     # @option opts [String] :shims optional array of shim files to load
     # @option opts [String] :bad optional invalid record file
-    # @option opts [String] :offset zero-based starting source record number to process (default 0)
+    # @option opts [Integer] :offset zero-based starting source record number to process (default 0)
+    # @option opts [Boolean] :quiet suppress output messages
     def initialize(opts)
       parse_options(opts)
       build
@@ -72,6 +73,7 @@ module CaRuby
         migrate do |target|
           save(target, db)
           yield target if block_given?
+          db.clear
         end
       end
     end
@@ -97,12 +99,14 @@ module CaRuby
       @offset = opts[:offset] ||= 0
       @input = Options.get(:input, opts)
       raise MigrationError.new("Migrator missing required source file parameter") if @input.nil?
-      @database = Options.get(:database, opts)
+      @database = opts[:database]
       raise MigrationError.new("Migrator missing required database parameter") if @database.nil?
-      @target_class = Options.get(:target, opts)
+      @target_class = opts[:target]
       raise MigrationError.new("Migrator missing required target class parameter") if @target_class.nil?
       @bad_rec_file = opts[:bad]
       logger.info("Migration options: #{opts.reject { |option, value| value.nil_or_empty? }.pp_s}.")
+      # flag indicating whether to print a progress monitor
+      @print_progress = !opts[:quiet]
     end
 
     def build
@@ -282,6 +286,7 @@ module CaRuby
         rec_cnt += 1 && next if rec_cnt < @offset
         begin
           # migrate the row
+          logger.debug { "Migrating record #{rec_no}..." }
           target = migrate_row(row)
           # call the block on the migrated target
           if target then
@@ -298,6 +303,7 @@ module CaRuby
           logger.debug { "Migrated record #{rec_no}." }
           #memory_usage = `ps -o rss= -p #{Process.pid}`.to_f / 1024 # in megabytes
           #logger.debug { "Migrated rec #{@rec_cnt}; memory usage: #{sprintf("%.1f", memory_usage)} MB." }
+          if @print_progress then print_progress(mgt_cnt) end
           mgt_cnt += 1
           # clear the migration state
           clear(target)
@@ -315,6 +321,13 @@ module CaRuby
       end
       logger.info("Migrated #{mgt_cnt} of #{rec_cnt} records.")
     end
+    
+    # Prints a +\++ progress indicator to stdout.
+    #
+    # @param [Integer] count the progress step count
+    def print_progress(count)
+      if count % 72 == 0 then puts "+" else print "+" end
+    end
 
     # Clears references to objects allocated for migration of a single row into the given target.
     # This method does nothing. Subclasses can override.
@@ -334,10 +347,10 @@ module CaRuby
       migrated = @creatable_classes.map { |klass| create(klass, row, created) }
       # migrate each object from the input row
       created.each { |obj| obj.migrate(row, migrated) }
-      # set the references
-      migrated.each { |obj| obj.migrate_references(row, migrated, @mgt_mth_hash[obj.class]) }
       # remove invalid migrations
       migrated.delete_if { |obj| not migration_valid?(obj) }
+      # set the references
+      migrated.each { |obj| obj.migrate_references(row, migrated, @mgt_mth_hash[obj.class]) }
       # the target object
       target = migrated.detect { |obj| @target_class === obj }
       if target then

data/lib/caruby/migration/resource_module.rb

@@ -1,5 +1,3 @@
-require 'caruby/domain/resource_module'
-
 module CaRuby
   module ResourceModule
     # Declares the given classes which will be dynamically modified for migration.

data/lib/caruby/resource.rb

@@ -7,40 +7,17 @@ require 'caruby/util/collection'
 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/migration/migratable'
 
 module CaRuby
   # The Domain module is included by Java domain classes.
   # This module defines essential common domain methods that enable the jRuby-Java API bridge.
   # Classes which include Domain must implement the +metadata+ Domain::Metadata accessor method.
   module Resource
-    include Comparable, Mergeable, Persistable, Validation
-
-    # @param [{Symbol => Object}] the optional attribute => value hash
-    # @return a new instance of this Resource class initialized from the optional attribute => value hash
-    def initialize(hash=nil)
-      super()
-      if hash then
-        unless Hashable === hash then
-          raise ArgumentError.new("#{qp} initializer argument type not supported: #{hash.class.qp}")
-        end
-        merge_attributes(hash)
-      end
-    end
-
-    # Returns the database identifier.
-    # This method aliases a Java +id+ property accessor, since +id+ is a reserved Ruby attribute.
-    def identifier
-      getId
-    end
-
-    # Sets the database identifier to the given id value.
-    # This method aliases the caTissue Java +id+ property setter,
-    # since +id+ is a reserved Ruby attribute.
-    def identifier=(id)
-      setId(id)
-    end
+    include Mergeable, Migratable, Persistable, Inversible, Validation
 
     # 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
@@ -52,7 +29,7 @@ module CaRuby
     # @return [Resource] self
     def add_defaults
       # apply owner defaults
-      if owner then
+      if owner and owner.identifier.nil? then
         owner.add_defaults
       else
         logger.debug { "Adding defaults to #{qp} and its dependents..." }
@@ -71,7 +48,7 @@ module CaRuby
     # @raise [ValidationError] if a mandatory attribute value is missing
     def validate
       unless @validated then
-        logger.debug { "Validating #{qp} required attributes #{self.class.mandatory_attributes.to_a.to_series}..." }
+        logger.debug { "Validating #{qp} required attributes #{self.mandatory_attributes.to_a.to_series}..." }
         invalid = missing_mandatory_attributes
         unless invalid.empty? then
           logger.error("Validation of #{qp} unsuccessful - missing #{invalid.join(', ')}:\n#{dump}")
@@ -124,61 +101,10 @@ module CaRuby
       self.class.new.merge_attributes(self, attributes)
     end
 
-    # Merges the other into this domain object. The non-domain attributes are always merged.
-    #
-    # @param [Resource] other the merge source domain object
-    # @param [<Symbol>] attributes the domain attributes to merge
-    # @yield [source, target]  mergethe source into the target
-    # @yieldparam [Resource] source the reference to merge from
-    # @yieldparam [Resource] target the reference the source is merge into
-    # @raise [ArgumentError] if other is not an instance of this domain object's class
-    # @see #merge_attribute_value
-    def merge_match(other, attributes, &matcher)
-      raise ArgumentError.new("Incompatible #{qp} merge source: #{other.qp}") unless self.class === other
-      logger.debug { format_merge_log_message(other, attributes) }
-      # merge the non-domain attributes
-      merge_attributes(other)
-      # merge the domain attributes
-      unless attributes.nil_or_empty? then
-        merge_attributes(other, attributes) do |attr, oldval, newval|
-          merge_attribute_value(attr, oldval, newval, &matcher)
-        end
-      end
-    end
-
-    # Merges the attribute newval into oldval as follows:
-    # * If attribute is a non-domain attribute and oldval is either nil or the attribute is not saved,
-    #   then the attribute value is set to newval.
-    # * Otherwise, if attribute is a domain non-collection attribute, then newval is recursively
-    #   merged into oldval.
-    # * Otherwise, if attribute is a domain collection attribute, then matching newval members are
-    #   merged into the corresponding oldval member and non-matching newval members are added to
-    #   newval.
-    # * Otherwise, the attribute value is not changed.
-    #
-    # The domain value match is performed by the matcher block. The block arguments are newval and
-    # oldval and the return value is a source => target hash of matching references. The default
-    # matcher is {Resource#match_in}.
-    #
-    # @param [Symbol] attribute the merge attribute
-    # @param oldval the current value
-    # @param newval the value to merge
-    # @yield [newval, oldval] the value matcher used if attribute is a domain collection 
-    # @yieldparam newval the merge source value
-    # @yieldparam oldval this domain object's current attribute value
-    # @return the merged attribute value
-    def merge_attribute_value(attribute, oldval, newval, &matcher)
-      attr_md = self.class.attribute_metadata(attribute)
-      if attr_md.nondomain? then
-        if oldval.nil? and not newval.nil? then
-          send(attr_md.writer, newval)
-          newval
-        end
-      else
-        merge_domain_attribute_value(attr_md, oldval, newval, &matcher)
-      end
-    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}.
+    #
+    # @param [Symbol] attribute the attribute to clear
     def clear_attribute(attribute)
       # the current value to clear
       current = send(attribute)
@@ -188,7 +114,9 @@ module CaRuby
       if current.respond_to?(:clear) then
         current.clear
       else
-        send(self.class.attribute_metadata(attribute).writer, empty_value(attribute))
+        writer = self.class.attribute_metadata(attribute).writer
+        value = self.class.empty_value(attribute)
+        send(writer, value)
       end
     end
 
@@ -197,7 +125,7 @@ module CaRuby
     # 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 #merge_attribute
+    # @see Mergeable#merge_attribute
     def set_attribute(attribute, value)
       # bail out if the value argument is the current value
       return value if value.equal?(send(attribute))
@@ -207,26 +135,42 @@ module CaRuby
 
     # Returns the secondary key attribute values as follows:
     # * If there is no secondary key, then this method returns nil.
-    # * Otherwise, if the secondary key attributes is a singleton Array, then the key is the value of the sole key attribute.
+    # * Otherwise, if the secondary key attributes is a singleton Array, then the key is the
+    #   value of the sole key attribute.
     # * Otherwise, the key is an Array of the key attribute values.
+    #
+    # @return [Array, Object] the key attribute values
     def key
       attrs = self.class.secondary_key_attributes
       case attrs.size
-      when 0 then nil
-      when 1 then send(attrs.first)
-      else attrs.map { |attr| send(attr) }
+        when 0 then nil
+        when 1 then send(attrs.first)
+        else attrs.map { |attr| send(attr) }
       end
     end
 
-    # Returns the domain object that owns this object, or nil if this object is not dependent on an owner.
+    # @return [Resource, nil] the domain object that owns this object, or nil if this object
+    #   is not dependent on an owner
     def owner
       self.class.owner_attributes.detect_value { |attr| send(attr) }
     end
+    
+    # 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)
+      attr = self.class.owner_attribute
+      if attr.nil? then raise NoMethodError.new("#{self.class.qp} does not have a unique owner attribute") end
+      set_attribute(attr, owner)
+    end
 
-    # Returns whether the other domain object is this object's #owner or an #owner_ancestor? of this object's {#owner}.
+    # @param [Resource] other the domain object to check
+    # @return [Boolean] whether the other domain object is this object's {#owner} or an
+    #  {#owner_ancestor?} of this object's {#owner}
     def owner_ancestor?(other)
-      ref = owner
-      ref and (ref == other or ref.owner_ancestor?(other))
+      owner = self.owner
+      owner and (owner == other or owner.owner_ancestor?(other))
     end
 
     # Returns an attribute => value hash for the specified attributes with a non-nil, non-empty value.
@@ -249,12 +193,12 @@ module CaRuby
       attributes.map { |attr| send(attr) }.flatten.compact
     end
 
-    # Returns whether this domain object is dependent on another entity.
+    # @return [Boolean] whether this domain object is dependent on another entity
     def dependent?
       self.class.dependent?
     end
 
-    # Returns whether this domain object is not dependent on another entity.
+    # @return [Boolean] whether this domain object is not dependent on another entity
     def independent?
       not dependent?
     end
@@ -265,14 +209,23 @@ module CaRuby
     # @yieldparam [Resource] dep the dependent
     def each_dependent
       self.class.dependent_attributes.each do |attr|
-        send(attr).enumerate { |dep| yield dep }
+       send(attr).enumerate { |dep| yield dep }
       end
     end
     
-    # The dependent Enumerable.
+    # @return [Enumerable] this domain object's dependents
     def dependents
       enum_for(:each_dependent)
     end
+    
+    # Returns the attributes which are required for save. This base implementation returns the
+    # class {ResourceAttributes#mandatory_attributes}. Subclasses can override this method
+    # for domain object state-specific refinements.
+    #
+    # @return [<Symbol>] the required attributes for a save operation
+    def mandatory_attributes
+      self.class.mandatory_attributes
+    end
 
     # Returns the attribute references which directly depend on this owner.
     # The default is the attribute value.
@@ -285,26 +238,21 @@ module CaRuby
     # dependency path, e.g. in caTissue a Specimen is owned by both a SCG and a parent
     # Specimen. In that case, the SCG direct dependents consist of top-level Specimens
     # owned by the SCG but not derived from another Specimen.
+    #
+    # @param [Symbol] attribute the dependent attribute
+    # @return [<Resource>] the attribute value, wrapped in an array if necessary
     def direct_dependents(attribute)
       deps = send(attribute)
       case deps
-      when Enumerable then deps
-      when nil then Array::EMPTY_ARRAY
-      else [deps]
+        when Enumerable then deps
+        when nil then Array::EMPTY_ARRAY
+        else [deps]
       end
     end
 
-    # Returns pairs +[+_value1_, _value2_+]+ of correlated non-nil values for every attribute in attributes
-    # in this and the other domain object, e.g. given domain objects +site1+ and +site2+ with non-nil
-    # +address+ dependents:
-    #   site1.assoc_attribute_values(site2, [:address]) #=> [site1.address, site2.address]
-    def assoc_attribute_values(other, attributes)
-      return {} if other.nil? or attributes.empty?
-      # associate the attribute => value hashes for this object and the other hash into one attribute => [value1, value2] hash
-      value_hash(attributes).assoc_values(other.value_hash(attributes)).values.reject { |values| values.any? { |value| value.nil? } }
-    end
-
-    # Returns whether this object matches the fetched other object on class and key values.
+    # @param [Resource] the domain object to match
+    # @return [Boolean] whether this object matches the fetched other object on class
+    #   and key values
     def match?(other)
       match_in([other])
     end
@@ -321,6 +269,9 @@ module CaRuby
     # This domain object is matched against the others on the above attributes in succession
     # until a unique match is found. The key attribute matches are strict, i.e. each
     # key attribute value must be non-nil and match the other value.
+    #
+    # @param [<Resource>] the candidate domain object matches
+    # @return [Resource, nil] the matching domain object, or nil if no match
     def match_in(others)
       # trivial case: self is in others
       return self if others.include?(self)
@@ -332,37 +283,20 @@ module CaRuby
       match_unique_object_with_attributes(others, self.class.alternate_key_attributes)
     end
 
-    # Returns the match of this domain object in the scope of a matching owner, if any.
-    # If this domain object is dependent, then the match is performed in the context of a
-    # matching owner object. If {#match_in} returns a match, then that result is used.
-    # Otherwise, #match_without_owner_attribute is called.
+    # Returns the match of this domain object in the scope of a matching owner as follows:
+    # * If {#match_in} returns a match, then that match is the result is used.
+    # * Otherwise, if this is a dependent attribute then the match is attempted on a
+    #   secondary key without owner attributes. Defaults are added to this object in order
+    #   to pick up potential secondary key values.
     #
-    # @param [<Resource>] others the candidate domain objects for the match
-    # @return [Resource, nil] the matching domain object, if any
+    # @param (see #match_in)
+    # @return (see #match_in)
     def match_in_owner_scope(others)
-      match_in(others) or others.detect { |other| match_without_owner_attribute(other) }
+      match_in(others) or others.detect { |other| match_without_owner_attribute?(other) }
     end
 
-    # Returns whether the other domain object matches this domain object on a secondary
-    # key without owner attributes. Defaults are added to this object in order to pick up
-    # potential secondary key values.
-    # 
-    # @param [<Resource>] other the domain object to match against
-    # @return [Boolean] whether the other domain object matches this domain object on a
-    #   secondary key without owner attributes
-    def match_without_owner_attribute(other)
-      oattrs = self.class.owner_attributes
-      return if oattrs.empty?
-      # add defaults to pick up potential secondary key value
-      add_defaults_local
-      # match on the secondary key
-      self.class.secondary_key_attributes.all? do |attr|
-        oattrs.include?(attr) or matches_attribute_value?(other, attr, send(attr))
-      end
-    end
-
-    # @return [{Resouce => Resource}] a source => target hash of the given sources which match the
-    #  targets using the {#match_in} method
+    # @return [{Resouce => Resource}] a source => target hash of the given sources which match
+    #   the targets using the {#match_in} method
     def self.match_all(sources, targets)
       DEF_MATCHER.match(sources, targets)
     end
@@ -465,6 +399,8 @@ module CaRuby
       yield(ref) and ref.visit_owners(&operator) if ref
     end
 
+    # @param q the PrettyPrint queue 
+    # @return [String] the formatted content of this Resource
     def pretty_print(q)
       q.text(qp)
       content = printable_content
@@ -472,14 +408,16 @@ module CaRuby
     end
 
     # Prints this domain object's content and recursively prints the referenced content.
-    # The optional selector block determines the attributes to print. The default is all
-    # Java domain attributes.
+    # The optional selector block determines the attributes to print. The default is the
+    # {ResourceAttributes#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.
     #
     # @yield [owner] the owner attribute selector
     # @yieldparam [Resource] owner the domain object to print
     # @return [String] the domain object content
     def dump(&selector)
-      DetailPrinter.new(self, &selector).pp_s
+      database.lazy_loader.disable { DetailPrinter.new(self, &selector).pp_s }
     end
 
     # Prints this domain object in the format:
@@ -508,27 +446,18 @@ module CaRuby
     # @return [{Symbol => String}] the attribute => content hash
     def printable_content(attributes=nil, &reference_printer) # :yields: reference
       attributes ||= printworthy_attributes
-      vh = suspend_lazy_loader { value_hash(attributes) }
+      vh = value_hash(attributes)
       vh.transform { |value| printable_value(value, &reference_printer) }
     end
 
     # Returns whether value equals other modulo the given matches according to the following tests:
     # * _value_ == _other_
-    # * _value_ and _other_ are Ruby DateTime instances and _value_ equals _other_,
-    #    modulo the Java-Ruby DST differences described in the following paragraph
-    # * _value_ == matches[_other_]
     # * _value_ and _other_ are Resource instances and _value_ is a {#match?} with _other_.
     # * _value_ and _other_ are Enumerable with members equal according to the above conditions.
-    # The DateTime comparison accounts for differences in the Ruby -> Java -> Ruby roundtrip
-    # of a date attribute.
+    # * _value_ and _other_ are DateTime instances and are equal to within one second.
     #
-    # Ruby alert - Unlike Java, Ruby does not adjust the offset for DST.
-    # This adjustment is made in the {Java::JavaUtil::Date#to_ruby_date}
-    # and {Java::JavaUtil::Date.from_ruby_date} methods.
-    # A date sent to the database is stored correctly.
-    # However, a date sent to the database does not correctly compare to
-    # the data fetched from the database.
-    # This method accounts for the DST discrepancy when comparing dates.
+    # The DateTime comparison accounts for differences in the Ruby -> Java -> Ruby roundtrip
+    # of a date attribute, which loses the seconds fraction.
     #
     # @return whether value and other are equal according to the above tests
     def self.value_equal?(value, other, matches=nil)
@@ -537,7 +466,7 @@ module CaRuby
       elsif value.collection? and other.collection? then
         collection_value_equal?(value, other, matches)
       elsif DateTime === value and DateTime === other then
-        value == other or dates_equal_modulo_dst(value, other)
+        (value - other).abs.floor.zero?
       elsif Resource === value and value.class === other then
         value.match?(other)
       elsif matches then
@@ -552,7 +481,7 @@ module CaRuby
     # 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 unless identifier
+      add_defaults_local
       # add dependent defaults
       each_defaults_dependent { |dep| dep.add_defaults_recursive }
     end
@@ -563,7 +492,7 @@ module CaRuby
     # work around a caTissue bug (see that module for details). Other definitions
     # of this method are discouraged.
     def missing_mandatory_attributes
-      self.class.mandatory_attributes.select { |attr| send(attr).nil_or_empty? }
+      mandatory_attributes.select { |attr| send(attr).nil_or_empty? }
     end
 
     private
@@ -603,8 +532,8 @@ module CaRuby
     # If a subclass overrides this method, then it should call super before setting the local
     # default attributes. This ensures that configuration defaults takes precedence.
     def add_defaults_local
+      logger.debug { "Adding defaults to #{qp}..." }
       merge_attributes(self.class.defaults)
-      self
     end
     
     # Enumerates the dependents for setting defaults. Subclasses can override if the
@@ -616,46 +545,9 @@ module CaRuby
       not (attributes.empty? or attributes.any? { |attr| send(attr).nil? })
     end
 
-    # Returns the source => target hash of matches for the given attr_md newval sources and
-    # 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 newval the source value
-    # @param oldval the target value
-    # @yield [sources, targets] matches sources to targets
-    # @yieldparam [<Resource>] sources an Enumerable on the source value
-    # @yieldparam [<Resource>] targets an Enumerable on the target value
-    # @return [{Resource => Resource}] the source => target matches
-    def match_attribute_value(attr_md, newval, oldval)
-      # make Enumerable targets and sources for matching
-      sources = newval.to_enum
-      targets = oldval.to_enum
-      
-      # match sources to targets
-      logger.debug { "Matching source #{newval.qp} to target #{qp} #{attr_md} #{oldval.qp}..." }
-      block_given? ? yield(sources, targets) : Resource.match_all(sources, targets)
-    end
-    
-    # @param [DateTime] d1 the first date
-    # @param [DateTime] d2 the second date
-    # @return whether d1 matches d2 on the non-offset fields
-    # @see #value_equal
-    def self.dates_equal_modulo_dst(d1, d2)
-      d1.strftime('%FT%T') == d1.strftime('%FT%T')
-    end
-
     def self.collection_value_equal?(value, other, matches=nil)
       value.size == other.size and value.all? { |v| other.include?(v) or (matches and other.include?(matches[v])) }
     end
-    
-    # @param (see #merge_match)
-    # @return [String] the log message
-    def format_merge_log_message(other, attributes)
-      attr_list = attributes.sort { |a1, a2| a1.to_s <=> a2.to_s }
-      attr_clause = " including domain attributes #{attr_list.to_series}" unless attr_list.empty?
-      "Merging #{other.qp} into #{qp}#{attr_clause}..."
-    end
 
     # A DetailPrinter formats a domain object value for printing using {#to_s} the first time the object
     # is encountered and a ReferencePrinter on the object subsequently.
@@ -749,68 +641,19 @@ module CaRuby
       end
     end
 
-    # @see #merge_attribute_value
-    def merge_domain_attribute_value(attr_md, oldval, newval, &matcher)
-      # the source => target matches
-      matches = match_attribute_value(attr_md, newval, oldval, &matcher)
-      logger.debug { "Matched #{qp} #{attr_md}: #{matches.qp}." } unless matches.empty?
-      merge_matching_attribute_references(attr_md, oldval, newval, matches)
-      # return the merged result
-      send(attr_md.reader)
-    end
-
-    # @see #merge_attribute_value
-    def merge_matching_attribute_references(attr_md, oldval, newval, matches)
-      # the dependent owner writer method, if any
-      inv_md = attr_md.inverse_attribute_metadata
-      if inv_md and not inv_md.collection? then
-        owtr = inv_md.writer
-      end
-
-      # if the attribute is a collection, then merge the matches into the current attribute
-      # 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 attr_md.collection? then
-        # TODO - refactor into method
-        # the references to add
-        adds = []
-        logger.debug { "Merging #{newval.qp} into #{qp} #{attr_md} #{oldval.qp}..." } unless newval.empty?
-        newval.each do |src|
-          # if the match target is in the current collection, then update the matched
-          # target from the source.
-          # otherwise, if there is no match or the match is a new reference created
-          # from the match, then add the match to the oldval collection.
-          if matches.has_key?(src) then
-            # the source match
-            tgt = matches[src]
-            if oldval.include?(tgt) then
-              tgt.merge_attributes(src)
-            else
-              adds << tgt
-            end
-          else
-            adds << src
-          end
-        end
-        # add the unmatched sources
-        logger.debug { "Adding #{qp} #{attr_md} 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(attr_md, ref, owtr) : oldval << ref
-        end
-      elsif newval then
-        if oldval then
-          oldval.merge(newval)
-        else
-          # the target is either a new object created in the match or the source value
-          ref = matches.has_key?(newval) ? matches[newval] : newval
-          # if the target is a dependent, then set the dependent owner, which in turn will
-          # set the attribute to the dependent. otherwise, set attribute to the target.
-          logger.debug { "Setting #{qp} #{attr_md} to #{ref.qp}..." }
-          owtr ? delegate_to_inverse_setter(attr_md, ref, owtr) : send(attr_md.writer, ref)
-        end
+    # Returns whether the other domain object matches this domain object on a secondary
+    # key without owner attributes. Defaults are added to this object in order to pick up
+    # potential secondary key values.
+    # 
+    # @param (see #match_in)
+    # @return [Boolean] whether the other domain object matches this domain object on a
+    #   secondary key without owner attributes
+    def match_without_owner_attribute?(other)
+      oattrs = self.class.owner_attributes
+      return if oattrs.empty?
+      # match on the secondary key
+      self.class.secondary_key_attributes.all? do |attr|
+        oattrs.include?(attr) or matches_attribute_value?(other, attr, send(attr))
       end
     end
 
@@ -819,102 +662,17 @@ module CaRuby
       ref.send(writer, self)
     end
 
-    # Sets an exclusive dependent attribute to the given dependent dep.
-    # If dep is not nil, then this method calls the dep inv_writer with argument self
-    # before calling the writer with argument dep.
-    def set_exclusive_dependent(dep, writer, inv_writer)
-      dep.send(inv_writer, self) if dep
-      send(writer, dep)
-    end
-
-    # Sets the inversible attribute with the given accessors and inverse to
-    # the given newval. The inverse of the attribute is a collection accessed by
-    # calling inverse on newval.
-    #
-    # For an attribute +owner+ with writer +setOwner+ and inverse reader +deps+,
-    # this is equivalent to the following:
-    #   class Dependent
-    #     def owner=(o)
-    #      owner.deps.delete(owner) if owner
-    #       setOwner(o)
-    #       o.deps << self if o
-    #     end
-    #   end
-    #
-    # @param [Resource] new_ref the new attribute reference value
-    # @param [(Symbol, Symbol)] accessors the reader and writer to use in setting
-    #   the attribute
-    # @param [Symbol] inverse the inverse collection attribute to which
-    #   this domain object will be added
-    def add_to_inverse_collection(new_ref, accessors, inverse)
-      reader, writer = accessors
-      # the current inverse
-      old_ref = send(reader)
-      # no-op if no change
-      return new_ref if old_ref == new_ref
-
-      # delete self from the current inverse reference collection
-      if old_ref then
-        old_ref.suspend_lazy_loader do
-          oldcoll = old_ref.send(inverse)
-          oldcoll.delete(self) if oldcoll
-        end
-      end
-
-      # call the writer on this object
-      send(writer, new_ref)
-      # add self to the inverse collection
-      if new_ref then
-        new_ref.suspend_lazy_loader do
-          newcoll = new_ref.send(inverse)
-          newcoll << self
-          unless newcoll then
-            raise TypeError.new("Cannot create #{new_ref.qp} #{inverse} collection to hold #{self}")
-          end
-          if old_ref then
-            logger.debug { "Moved #{qp} from #{reader} #{old_ref.qp} #{inverse} to #{new_ref.qp}." }
-          else
-            logger.debug { "Added #{qp} to #{reader} #{new_ref.qp} #{inverse}." }
-          end
-        end
-      end
-      new_ref
-    end
-
-    # Sets the attribute with the given accessors and inverse_writer to the given newval.
-    #
-    # For an attribute +owner+ with writer +setOwner+ and inverse +dep+, this is equivalent
-    # to the following:
-    #   class Dependent
-    #     def owner=(o)
-    #       owner.dep = nil if owner
-    #       setOwner(o)
-    #       o.dep = self if o
-    #     end
-    #   end
-    def set_inversible_noncollection_attribute(newval, accessors, inverse_writer)
-      reader, writer = accessors
-      # the previous value
-      oldval = suspend_lazy_loader { send(reader) }
-      # bail if no change
-      return newval if newval.equal?(oldval)
-
-      # clear the previous inverse
-      oldval.send(inverse_writer, nil) if oldval
-      # call the writer
-      send(writer, newval)
-      logger.debug { "Moved #{qp} from #{oldval.qp} to #{newval.qp}." } if oldval and newval
-      # call the inverse writer on self
-      newval.send(inverse_writer, self) if newval
-      newval
-    end
-
     # Returns 0 if attribute is a Java primitive number,
-    # +false+ if attribute is a Java primitive boolean, nil otherwise.
+    # +false+ if attribute is a Java primitive boolean,
+    # an empty collectin if the Java property is a collection,
+    # nil otherwise.
     def empty_value(attribute)
-      type = java_type(attribute)
-      return unless type and type.primitive?
-      type.name == 'boolean' ? false : 0
+      type = java_type(attribute) || return
+      if type.primitive? then
+        type.name == 'boolean' ? false : 0
+      else
+        self.class.empty_value(attribute)
+      end
     end
 
     # Returns the Java type of the given attribute, or nil if attribute is not a Java property attribute.
@@ -923,6 +681,29 @@ module CaRuby
       attr_md.property_descriptor.property_type if JavaAttributeMetadata === attr_md
     end
 
+    # Returns the source => target hash of matches for the given attr_md newval sources and
+    # 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 newval the source value
+    # @param oldval the target value
+    # @yield [sources, targets] matches sources to targets
+    # @yieldparam [<Resource>] sources an Enumerable on the source value
+    # @yieldparam [<Resource>] targets an Enumerable on the target value
+    # @return [{Resource => Resource}] the source => target matches
+    def match_attribute_value(attr_md, newval, oldval)
+      # make Enumerable targets and sources for matching
+      sources = newval.to_enum
+      targets = oldval.to_enum
+      
+      # match sources to targets
+      logger.debug { "Matching source #{newval.qp} to target #{qp} #{attr_md} #{oldval.qp}..." } unless oldval.nil_or_empty?
+      matches = block_given? ? yield(sources, targets) : Resource.match_all(sources, targets)
+      logger.debug { "Matched #{qp} #{attr_md}: #{matches.qp}." } unless matches.empty?
+      matches
+    end
+    
     # Returns the object in others which uniquely matches this domain object on the given attributes,
     # or nil if there is no unique match. This method returns nil if any attributes value is nil.
     def match_unique_object_with_attributes(others, attributes)