caruby-core 1.5.5 → 2.1.1

data/lib/caruby/domain/inverse.rb

@@ -1,172 +0,0 @@
-require 'caruby/import/java'
-require 'caruby/domain/java_attribute'
-
-module CaRuby
-  module Domain
-    # Meta-data mix-in to infer and set inverse attributes.
-    module Inverse
-      # Returns the inverse of the given attribute. If the attribute has an #{Attribute#inverse_metadata},
-      # then that attribute's inverse is returned. Otherwise, if the attribute is an #{Attribute#owner?},
-      # then the target class dependent attribute which matches this type is returned, if it exists.
-      #
-      # @param [Attribute] attr_md the subject attribute
-      # @param [Class, nil] klass the target class
-      # @return [Attribute, nil] the inverse attribute, if any
-      def inverse_attribute_metadata(attr_md, klass=nil)
-        inv_md = attr_md.inverse_metadata
-        return inv_md if inv_md
-        if attr_md.dependent? and klass then
-          klass.owner_attribute_metadata_hash.each { |otype, oattr_md|
-          return oattr_md if self <= otype }
-        end
-      end
-      
-      protected
-      
-      # Infers the inverse of the given attribute declared by this class. A domain attribute is
-      # recognized as an inverse according to the {Inverse#detect_inverse_attribute}
-      # criterion.
-      #
-      # @param [Attribute] attr_md the attribute to check
-      def infer_attribute_inverse(attr_md)
-        inv = attr_md.type.detect_inverse_attribute(self)
-        if inv then set_attribute_inverse(attr_md.to_sym, inv) end
-      end
-      
-      # Sets the given bi-directional association attribute's inverse.
-      #
-      # @param [Symbol] attribute the subject attribute
-      # @param [Symbol] the attribute inverse
-      # @raise [TypeError] if the inverse type is incompatible with this Resource
-      def set_attribute_inverse(attribute, inverse)
-        attr_md = attribute_metadata(attribute)
-        # return if inverse is already set
-        return if attr_md.inverse == inverse
-        # the default inverse
-        inverse ||= attr_md.type.detect_inverse_attribute(self)
-        # the inverse attribute meta-data
-        inv_md = attr_md.type.attribute_metadata(inverse)
-        # If the attribute is the many side of a 1:M relation, then delegate to the one side.
-        if attr_md.collection? and not inv_md.collection? then
-          return attr_md.type.set_attribute_inverse(inverse, attribute)
-        end
-        # This class must be the same as or a subclass of the inverse attribute type.
-        unless self <= inv_md.type then
-          raise TypeError.new("Cannot set #{qp}.#{attribute} inverse to #{attr_md.type.qp}.#{attribute} with incompatible type #{inv_md.type.qp}")
-        end
-        # If the attribute is not declared by this class, then make a new attribute
-        # metadata specialized for this class.
-        unless attr_md.declarer == self then
-          attr_md = restrict_attribute_inverse(attr_md, inverse)
-        end
-        # Set the inverse in the attribute metadata.
-        attr_md.inverse = inverse
-        # If attribute is the one side of a 1:M or non-reflexive 1:1 relation, then add the inverse updater.
-        unless attr_md.collection? then
-          # Make the 
-          add_inverse_updater(attribute, inverse)
-          unless attr_md.type == inv_md.type or inv_md.collection? then
-            attr_md.type.delegate_writer_to_inverse(inverse, attribute)
-          end
-        end
-      end
-      
-      # Detects an unambiguous attribute which refers to the given referencing class.
-      # If there is exactly one attribute with the given return type, then that attribute is chosen.
-      # Otherwise, the attribute whose name matches the underscored referencing class name is chosen,
-      # if any.
-      #
-      # @param [Class] klass the referencing class
-      # @return [Symbol, nil] the inverse attribute for the given referencing class and inverse,
-      #   or nil if no owner attribute was detected
-      def detect_inverse_attribute(klass)
-        # The candidate attributes return the referencing type and don't already have an inverse.
-        candidates = domain_attributes.compose { |attr_md| klass <= attr_md.type and attr_md.inverse.nil? }
-        attr = detect_inverse_attribute_from_candidates(klass, candidates)
-        if attr then
-          logger.debug { "#{qp} #{klass.qp} inverse attribute is #{attr}." }
-        else
-          logger.debug { "#{qp} #{klass.qp} inverse attribute was not detected." }
-        end
-        attr
-      end
-      
-      # Redefines the attribute writer method to delegate to its inverse writer.
-      # This is done to enforce inverse integrity.
-      #
-      # For a +Person+ attribute +account+ with inverse +holder+, this is equivalent to the following:
-      #   class Person
-      #     alias :set_account :account=
-      #     def account=(acct)
-      #       acct.holder = self if acct
-      #       set_account(acct)
-      #     end
-      #   end
-      def delegate_writer_to_inverse(attribute, inverse)
-        attr_md = attribute_metadata(attribute)
-        # nothing to do if no inverse
-        inv_attr_md = attr_md.inverse_metadata || return
-        logger.debug { "Delegating #{qp}.#{attribute} update to the inverse #{attr_md.type.qp}.#{inv_attr_md}..." }
-        # redefine the write to set the dependent inverse
-        redefine_method(attr_md.writer) do |old_writer|
-          # delegate to the CaRuby::Resource set_inverse method
-          lambda { |dep| set_inverse(dep, old_writer, inv_attr_md.writer) }
-        end
-      end
-  
-      private
-      
-      # Copies the given attribute metadata from its declarer to this class. The new attribute metadata
-      # has the same attribute access methods, but the declarer is this class and the inverse is the
-      # given inverse attribute.
-      #
-      # @param [Attribute] attr_md the attribute to copy
-      # @param [Symbol] the attribute inverse
-      # @return [Attribute] the copied attribute metadata
-      def restrict_attribute_inverse(attr_md, inverse)
-        rst_attr_md = attr_md.dup
-        rst_attr_md.declarer = self
-        add_attribute_metadata(rst_attr_md)
-        logger.debug { "Copied #{attr_md.declarer}.#{attr_md} to #{qp} with inverse #{inverse}." }
-        rst_attr_md
-      end
-      
-      # @param klass (see #detect_inverse_attribute)
-      # @param [<Symbol>] candidates the attributes constrained to the target type
-      # @return (see #detect_inverse_attribute)
-      def detect_inverse_attribute_from_candidates(klass, candidates)
-        return if candidates.empty?
-        # there can be at most one owner attribute per owner.
-        return candidates.first.to_sym if candidates.size == 1
-        # by convention, if more than one attribute references the owner type,
-        # then the attribute named after the owner type is the owner attribute
-        tgt = klass.name[/\w+$/].underscore.to_sym
-        tgt if candidates.detect { |attr| attr == tgt }
-      end
-      
-      # Modifies the given attribute writer method to update the given inverse.
-      #
-      # @param (see #set_attribute_inverse)
-      def add_inverse_updater(attribute, inverse)
-        attr_md = attribute_metadata(attribute)
-        # the reader and writer methods
-        rdr, wtr = attr_md.accessors
-        logger.debug { "Injecting inverse #{inverse} updater into #{qp}.#{attribute} writer method #{wtr}..." }
-        # the inverse atttribute metadata
-        inv_attr_md = attr_md.inverse_metadata
-        # the inverse attribute reader and writer
-        inv_rdr, inv_wtr = inv_accessors = inv_attr_md.accessors
-        # Redefine the writer method to update the inverse by delegating to the inverse
-        redefine_method(wtr) do |old_wtr|
-          # the attribute reader and (superseded) writer
-          accessors = [rdr, old_wtr]
-          if inv_attr_md.collection? then
-            lambda { |other| add_to_inverse_collection(other, accessors, inv_rdr) }
-          else
-            lambda { |other| set_inversible_noncollection_attribute(other, accessors, inv_wtr) }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/caruby/domain/inversible.rb

@@ -1,90 +0,0 @@
-require 'caruby/util/log'
-require 'caruby/database/persistable'
-require 'caruby/util/pretty_print'
-
-module CaRuby
-  # {Resource} inverse integrity aspect mix-in.
-  module Inversible
-    # Sets an attribute inverse by calling the attribute writer method with the other argument.
-    # If other is non-nil, then the inverse writer method is called on self.
-    #
-    # @param other [Resource] the attribute value to set
-    # @param [Symbol] writer the attribute writer method
-    # @param [Symbol] inv_writer the attribute inverse writer method defined for the other object
-    def set_inverse(other, writer, inv_writer)
-      other.send(inv_writer, self) if other
-      send(writer, other)
-    end
-    
-    # Sets a non-collection attribute value in a way which enforces inverse integrity.
-    #
-    # @param [Object] newval the value to set
-    # @param [(Symbol, Symbol)] accessors the reader and writer methods to use in setting the
-    #   attribute
-    # @param [Symbol] inverse_writer the inverse attribute writer method
-    def set_inversible_noncollection_attribute(newval, accessors, inverse_writer)
-      rdr, wtr = accessors
-      # the previous value
-      oldval = send(rdr)
-      # bail if no change
-      return newval if newval.equal?(oldval)
-
-      # clear the previous inverse
-      logger.debug { "Moving #{qp} from #{oldval.qp} to #{newval.qp}..." } if oldval and newval
-      if oldval then
-        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)
-        logger.debug { "Moved #{qp} from #{oldval.qp} to #{newval.qp}." } if oldval
-      end
-      
-      newval
-    end
-
-    # Sets a collection attribute value in a way which enforces inverse integrity.
-    # The inverse of the attribute is a collection accessed by calling inverse on newval.
-    #
-    # @param [Resource] newval 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
-    # @yield a factory to create a new collection on demand (default is an Array)
-    def add_to_inverse_collection(newval, accessors, inverse)
-      rdr, wtr = accessors
-      # the current inverse
-      oldval = send(rdr)
-      # no-op if no change
-      return newval if newval == oldval
-
-      # delete self from the current inverse reference collection
-      if oldval then
-        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)
-        if coll.nil? then
-          coll = block_given? ? yield : Array.new
-          newval.set_attribute(inverse, coll)
-        end
-        coll << self
-        if oldval then
-          logger.debug { "Moved #{qp} from #{rdr} #{oldval.qp} #{inverse} to #{newval.qp}." }
-        else
-          logger.debug { "Added #{qp} to #{rdr} #{newval.qp} #{inverse}." }
-        end
-      end
-      
-      newval
-    end
-  end
-end

data/lib/caruby/domain/java_attribute.rb

@@ -1,173 +0,0 @@
-require 'caruby/util/inflector'
-require 'caruby/domain/attribute'
-
-module CaRuby
-  module Domain
-    # The attribute metadata for an introspected Java property. 
-    class JavaAttribute < Attribute
-  
-      # This attribute's Java property descriptor.
-      attr_reader :property_descriptor
-  
-      # This attribute's Java property [reader, writer] accessors, e.g. +[:getActivityStatus, :setActivityStatus]+.
-      attr_reader :property_accessors
-  
-      # Creates a Ruby Attribute symbol corresponding to the given Ruby Java class wrapper klazz
-      # and Java property_descriptor.
-      #
-      # The attribute name is the lower-case, underscore property descriptor name with the alterations
-      # described in {JavaAttribute.to_attribute_symbol} and {Class#unocclude_reserved_method}.
-      #
-      # The attribute type is inferred as follows:
-      # * If the property descriptor return type is a primitive Java type, then that type is returned.
-      # * If the return type is a parameterized collection, then the parameter type is returned.
-      # * If the return type is an unparameterized collection, then this method infers the type from
-      #   the property name, e.g. +StudyProtocolCollection+type is inferred as +StudyProtocol+
-      #   by stripping the +Collection+ suffix, capitalizing the prefix and looking for a class of
-      #   that name in the {Metadata#domain_module}.
-      # * If the declarer class metadata configuration includes a +domain_attributes+ property, then
-      #   the type specified in that property is returned.
-      # * Otherwise, this method returns Java::Javalang::Object.
-      #
-      # The optional restricted_type argument restricts the attribute to a subclass of the declared
-      # property type.
-      def initialize(pd, declarer, restricted_type=nil)
-        symbol = create_standard_attribute_symbol(pd, declarer)
-        super(symbol, declarer, restricted_type)
-        @property_descriptor = pd
-        # deficient Java introspector does not recognize 'is' prefix for a Boolean property
-        rm = declarer.property_read_method(pd)
-        raise ArgumentError.new("Property does not have a read method: #{declarer.qp}.#{pd.name}") unless rm
-        reader = rm.name.to_sym
-        unless declarer.method_defined?(reader) then
-          reader = "is#{reader.to_s.capitalize_first}".to_sym
-          unless declarer.method_defined?(reader) then
-            raise ArgumentError.new("Reader method not found for #{declarer} property #{pd.name}")
-          end
-        end
-        unless pd.write_method then
-          raise ArgumentError.new("Property does not have a write method: #{declarer.qp}.#{pd.name}")
-        end
-        writer = pd.write_method.name.to_sym
-        unless declarer.method_defined?(writer) then
-          raise ArgumentError.new("Writer method not found for #{declarer} property #{pd.name}")
-        end
-        @property_accessors = [reader, writer]
-        qualify(:collection) if collection_java_class?
-        @type = infer_type
-      end
-      
-      # @return [Symbol] the JRuby wrapper method for the Java property reader
-      def property_reader
-        property_accessors.first
-      end
-      
-      # @return [Symbol] the JRuby wrapper method for the Java property writer
-      def property_writer
-        property_accessors.last
-      end
-  
-      # Returns a lower-case, underscore symbol for the given property_name.
-      # A name ending in 'Collection' is changed to a pluralization.
-      #
-      # @example
-      #   JavaAttribute.to_attribute_symbol('specimenEventCollection') #=> :specimen_events
-      def self.to_attribute_symbol(property_name)
-        name = if property_name =~ /(.+)Collection$/ then
-          property_name[0...-'Collection'.length].pluralize.underscore
-        else
-          property_name.underscore
-        end
-        name.to_sym
-      end
-  
-      private
-  
-      # @param pd the Java property descriptor
-      # @param [Class] klass the declarer
-      # @return [String] the lower-case, underscore symbol for the given property descriptor
-      def create_standard_attribute_symbol(pd, klass)
-        propname = pd.name
-        name = propname.underscore
-        renamed = klass.unocclude_reserved_method(pd)
-        if renamed then
-          logger.debug { "Renamed #{klass.qp} reserved Ruby method #{name} to #{renamed}." }
-          renamed
-        else
-          JavaAttribute.to_attribute_symbol(propname)
-        end
-      end
-  
-      # @return [Boolean] whether this property's Java type is +Iterable+
-      def collection_java_class?
-        # the Java property type
-        ptype = @property_descriptor.property_type
-        # Test whether the corresponding JRuby wrapper class or module is an Iterable.
-        Class.to_ruby(ptype) < Java::JavaLang::Iterable
-      end
-  
-      # @return [Class] the type for the specified klass property descriptor pd as described in {#initialize}
-      def infer_type
-        collection? ? infer_collection_type : infer_non_collection_type
-      end
-  
-      # Returns the domain type for this attribute's Java Collection property descriptor.
-      # If the property type is parameterized by a single domain class, then that generic type argument is the domain type.
-      # Otherwise, the type is inferred from the property name as described in {#infer_collection_type_from_name}.
-      #
-      # @return [Class] this property's Ruby type
-      def infer_collection_type
-         generic_parameter_type or infer_collection_type_from_name or Java::JavaLang::Object
-      end
-  
-      # @return [Class] this property's Ruby type
-      def infer_non_collection_type
-        jtype = @property_descriptor.property_type
-        Class.to_ruby(jtype)
-      end
-  
-      # @return [Class, nil] the domain type of this attribute's property descriptor Collection generic
-      #   type argument, or nil if none
-      def generic_parameter_type
-        method = @property_descriptor.readMethod || return
-        gtype = method.genericReturnType
-        return unless Java::JavaLangReflect::ParameterizedType === gtype
-        atypes = gtype.actualTypeArguments
-        return unless atypes.size == 1
-        atype = atypes[0]
-        klass = java_to_ruby_class(atype)
-        logger.debug { "Inferred #{declarer.qp} #{self} domain type #{klass.qp} from generic parameter #{atype.name}." } if klass
-        klass
-      end
-  
-      # @param [Class, String] jtype the Java class or class name
-      # @return [Class] the corresponding Ruby type 
-      def java_to_ruby_class(jtype)
-        name = String === jtype ? jtype : jtype.name
-        Class.to_ruby(name)
-      end
-  
-      # Returns the domain type for this attribute's collection Java property descriptor name.
-      # By convention, caBIG domain collection properties often begin with a domain type
-      # name and end in 'Collection'. This method strips the Collection suffix and checks
-      # whether the prefix is a domain class.
-      #
-      # For example, the type of the property named +distributionProtocolCollection+
-      # is inferred as +DistributionProtocol+ by stripping the +Collection+ suffix,
-      # capitalizing the prefix and looking for a class of that name in this classifier's
-      # domain_module.
-      #
-      # @return [Class] the collection item type
-      def infer_collection_type_from_name
-        # the property name
-        pname = @property_descriptor.name
-        # The potential class name is the capitalized property name without a 'Collection' suffix.
-        cname = pname.capitalize_first.sub(/Collection$/, '')
-        jname = [@declarer.parent_module, cname].join('::')
-        klass = eval jname rescue nil
-        if klass then logger.debug { "Inferred #{declarer.qp} #{self} collection domain type #{klass.qp} from the attribute name." } end
-        klass
-      end
-    end
-  end
-end

data/lib/caruby/domain/merge.rb

@@ -1,185 +0,0 @@
-require 'caruby/util/validation'
-
-module CaRuby
-  # A Mergeable supports merging {Resource} attribute values.
-  module Mergeable
-    # Merges the values of the other attributes into this object and returns self.
-    # The other argument can be either a Hash or an object whose class responds to the
-    # +mergeable_attributes+ method.
-    # The optional attributes argument can be either a single attribute symbol or a
-    # collection of attribute symbols.
-    #
-    # A hash argument consists of attribute name => value associations.
-    # For example, given a Mergeable +person+ object with attributes +ssn+ and +children+, the call:
-    #   person.merge_attributes(:ssn => '555-55-5555', :children => children)
-    # is equivalent to:
-    #   person.ssn ||= '555-55-5555'
-    #   person.children ||= []
-    #   person.children.merge(children, :deep)
-    # An unrecognized attribute is ignored.
-    #
-    # If other is not a Hash, then the other object's attributes values are merged into
-    # this object. The default attributes is this mergeable's class
-    # {Domain::Attributes#mergeable_attributes}.
-    #
-    # The merge is performed by calling {#merge_attribute} on each attribute with the matches
-    # and merger block given to this method.
-    #
-    # @param [Mergeable, {Symbol => Object}] other the source domain object or value hash to merge from
-    # @param [<Symbol>, nil] attributes the attributes to merge (default {Domain::Attributes#nondomain_attributes})
-    # @param [{Resource => Resource}, nil] the optional merge source => target reference matches
-    # @yield [attribute, oldval, newval] the optional merger block
-    # @yieldparam [Symbol] attribute the merge target attribute
-    # @yieldparam oldval the current merge attribute value
-    # @yieldparam newval the new merge attribute value
-    # @return [Mergeable] self
-    # @raise [ArgumentError] if none of the following are true:
-    #   * other is a Hash
-    #   * attributes is non-nil
-    #   * the other class responds to +mergeable_attributes+
-    def merge_attributes(other, attributes=nil, matches=nil, &merger)
-      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
-      vh.each { |attr, value| merge_attribute(attr, value, matches, &merger) }
-      self
-    end
-
-    alias :merge :merge_attributes
-
-    alias :merge! :merge
-    
-    # Merges the value newval into the attribute as follows:
-    # * If the value is nil, empty or equal to the current attribute value, then no merge
-    #   is performed.
-    # * Otherwise, if a merger block is given to this method, then that block is called
-    #   to perform the merge.
-    # * Otherwise, if the attribute is a non-domain attribute and the current value is non-nil,
-    #   then no merge is performed.
-    # * Otherwise, if the attribute is a non-domain attribute and the current value is nil,
-    #   then set the attribute to the newval.
-    # * Otherwise, if the attribute is a domain non-collection attribute, then newval is recursively
-    #   merged into the current referenced domain object.
-    # * Otherwise, attribute is a domain collection attribute and matching newval members are
-    #   merged into the corresponding current collection members and non-matching newval members
-    #   are added to the current collection.
-    #
-    # @param [Symbol] attribute the merge attribute
-    # @param newval the value to merge
-    # @param [{Resource => Resource}, nil] the optional merge source => target reference matches
-    # @yield (see #merge_attributes)
-    # @yieldparam (see #merge_attributes)
-    # @return the merged attribute value
-    def merge_attribute(attribute, newval, matches=nil)
-      # the previous value
-      oldval = send(attribute)
-      # If nothing to merge or a block can take over, then bail. 
-      if newval.nil? or mergeable__equal?(oldval, newval) then
-        return oldval
-      elsif block_given? then
-        return yield(attribute, oldval, value)
-      end
-      
-      # Discriminate between a domain and non-domain attribute.
-      attr_md = self.class.attribute_metadata(attribute)
-      if attr_md.domain? then
-        merge_domain_attribute_value(attr_md, oldval, newval, matches)
-      else
-        merge_nondomain_attribute_value(attr_md, oldval, newval)
-      end
-    end
-
-    private
-
-    # @see #merge_attribute
-    def merge_nondomain_attribute_value(attr_md, oldval, newval)
-      if oldval.nil? then
-        send(attr_md.writer, newval)
-      elsif attr_md.collection? then
-        oldval.merge(newval)
-      else
-        oldval
-      end
-    end
-    
-    # @see #merge_attribute
-    def merge_domain_attribute_value(attr_md, oldval, newval, matches)
-      # the dependent owner writer method, if any
-      if attr_md.dependent? then
-        val = attr_md.collection? ? newval.first : newval
-        klass = val.class if val
-        inv_md = self.class.inverse_attribute_metadata(attr_md, klass)
-        if inv_md and not inv_md.collection? then
-          owtr = inv_md.writer
-        end
-      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
-        if oldval.nil? then
-          raise ValidationError.new("Merge into #{qp} #{attr_md} with nil collection value is not supported")
-        end
-        # 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 && matches.has_key?(src) then
-            # the source match
-            tgt = matches[src]
-            if tgt then
-              if oldval.include?(tgt) then
-                tgt.merge_attributes(src)
-              else
-                adds << tgt
-              end
-            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
-        oldval
-      elsif newval.nil? then
-        # no merge source
-        oldval
-      elsif oldval then
-        # merge the source into the target
-        oldval.merge(newval)
-      else
-        # 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} #{attr_md} 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(attr_md, ref, owtr) : send(attr_md.writer, ref)
-      end
-      newval
-    end
-
-    # Java Java TreeSet comparison uses the TreeSet comparator rather than an
-    # element-wise comparator. Work around this rare aberration by converting the TreeSet
-    # to a Ruby Set.
-    def mergeable__equal?(v1, v2)
-      Java::JavaUtil::TreeSet === v1 && Java::JavaUtil::TreeSet === v2 ? v1.to_set == v2.to_set : v1 == v2
-    end
-  end
-end