jinx 2.1.1 → 2.1.2

data/lib/jinx/helpers/visitor.rb

@@ -196,7 +196,7 @@ module Jinx
     # @yieldparam children the nodes slated by this Visitor to visit next
     # @raise [ArgumentError] if a block is not given to this method
     def filter
-      Jinx.fail(ArgumentError, "A filter block is not given to the visitor filter method") unless block_given?
+      raise ArgumentError.new("A filter block is not given to the visitor filter method") unless block_given?
       Visitor.new(@options) { |node| yield(node, node_children(node)) }
     end
   
@@ -319,7 +319,7 @@ module Jinx
       def visit(*nodes)
         if nodes.size == 1 then
           nodes = nodes.first
-          Jinx.fail(ArgumentError, "Sync visitor requires a pair of entry nodes") unless nodes.size == 2
+          raise ArgumentError.new("Sync visitor requires a pair of entry nodes") unless nodes.size == 2
         end
         super(nodes)
       end
@@ -331,7 +331,7 @@ module Jinx
       def to_enum(*nodes)
         if nodes.size == 1 then
           nodes = nodes.first
-          Jinx.fail(ArgumentError, "Sync visitor requires a pair of entry nodes") unless nodes.size == 2
+          raise ArgumentError.new("Sync visitor requires a pair of entry nodes") unless nodes.size == 2
         end
         super(nodes)
       end

data/lib/jinx/import/java.rb

@@ -91,7 +91,7 @@ module Java
       # merge return a new collection.
       def merge(other)
         return self if other.nil?
-        Jinx.fail(ArgumentError, "Merge argument must be enumerable: #{other}") unless Enumerable === other
+        raise ArgumentError.new("Merge argument must be enumerable: #{other}") unless Enumerable === other
         other.each { |item| self << item }
         self
       end

data/lib/jinx/importer.rb

@@ -69,6 +69,7 @@ module Jinx
     
     # @param [String] the module name to resolve in the context of this module
     # @return [Module] the corresponding module
+    # @raise [NameError] if the name cannot be resolved
     def module_for_name(name)
       begin
         # Incrementally resolve the module.
@@ -97,7 +98,7 @@ module Jinx
         begin
           eval "java_package Java::#{pkg}"
         rescue Exception => e
-          Jinx.fail(ArgumentError, "#{self} Java package #{pkg} not found - #{$!}")
+          raise ArgumentError.new("#{self} Java package #{pkg} not found - #{$!}")
         end
       end
       # The introspected classes.
@@ -221,7 +222,7 @@ module Jinx
       mod = klass.parent_module
       klass.each_property do |prop|
         ref = prop.type
-        if ref.nil? then Jinx.fail(MetadataError, "#{self} #{prop} domain type is unknown.") end
+        if ref.nil? then raise MetadataError.new("#{self} #{prop} domain type is unknown.") end
         unless @introspected.include?(ref) or ref.parent_module != mod then
           logger.debug { "Introspecting #{qp} #{prop} reference #{ref.qp}..." }
           add_metadata(ref)

data/lib/jinx/metadata/attribute_enumerator.rb

@@ -10,7 +10,7 @@ module Jinx
     # @yieldparam [Property] the metadata for the standard attribute
     # @raise [ArgumentError] if a parameter is missing 
     def initialize(hash, &filter)
-      Jinx.fail(ArgumentError, "Attribute filter missing hash argument") if hash.nil?
+      raise ArgumentError.new("Attribute filter missing hash argument") if hash.nil?
       @hash = hash
       @filter = block_given? ? filter : Proc.new { true }
     end

data/lib/jinx/metadata/dependency.rb

@@ -115,11 +115,11 @@ module Jinx
     # @raise [ValidationError] if the inverse is nil
     def add_owner(klass, inverse, attribute=nil)
       if inverse.nil? then
-        Jinx.fail(ValidationError, "Owner #{klass.qp} missing dependent attribute for dependent #{qp}")
+        raise ValidationError.new("Owner #{klass.qp} missing dependent attribute for dependent #{qp}")
       end
       logger.debug { "Adding #{qp} owner #{klass.qp}#{' attribute ' + attribute.to_s if attribute} with inverse #{inverse}..." }
       if @owner_prop_hash then
-        Jinx.fail(MetadataError, "Can't add #{qp} owner #{klass.qp} after dependencies have been accessed")
+        raise MetadataError.new("Can't add #{qp} owner #{klass.qp} after dependencies have been accessed")
       end
       
       # detect the owner attribute, if necessary
@@ -175,7 +175,7 @@ module Jinx
       if hash.include?(otype) then
         oa = hash[otype]
         unless oa.nil? then
-          Jinx.fail(MetadataError, "Cannot set #{qp} owner attribute to #{attribute} since it is already set to #{oa}")
+          raise MetadataError.new("Cannot set #{qp} owner attribute to #{attribute} since it is already set to #{oa}")
         end
         hash[otype] = prop
       else

data/lib/jinx/metadata/introspector.rb

@@ -2,6 +2,7 @@ require 'jinx/helpers/module'
 require 'jinx/import/java'
 require 'jinx/metadata/propertied'
 require 'jinx/metadata/java_property'
+require 'jinx/helpers/math'
 
 module Jinx
   # Meta-data mix-in to infer attribute meta-data from Java properties.
@@ -77,68 +78,71 @@ module Jinx
         return
       end
       # the standard underscore lower-case attributes
-      ja = add_java_property(pd).attribute
+      prop = add_java_property(pd)
       # delegate the standard attribute accessors to the attribute accessors
-      alias_property_accessors(ja, pd.name)
+      alias_property_accessors(prop)
       # add special wrappers
-      wrap_java_property(ja, pd)
+      wrap_java_property(prop)
       # create Ruby alias for boolean, e.g. alias :empty? for :empty
       if pd.property_type.name[/\w+$/].downcase == 'boolean' then
-        # strip leading is_, if any, before appending question mark
-        aliaz = ja.to_s[/^(is_)?(\w+)/, 2] << '?'
-        delegate_to_attribute(aliaz, ja)
+        # Strip the leading is_, if any, before appending a question mark.
+        aliaz = prop.to_s[/^(is_)?(\w+)/, 2] << '?'
+        delegate_to_property(aliaz, prop)
       end
     end
 
-    # Adds a filter to the attribute access method for the property descriptor pd if it is a String or Date.
-    def wrap_java_property(attribute, pd)
+    # Adds a filter to the given property access methods if it is a String or Date.
+    def wrap_java_property(property)
+      pd = property.property_descriptor
       if pd.property_type == Java::JavaLang::String.java_class then
-        wrap_java_string_attribute(attribute, pd)
+        wrap_java_string_property(property)
       elsif pd.property_type == Java::JavaUtil::Date.java_class then
-        wrap_java_date_attribute(attribute, pd)
+        wrap_java_date_property(property)
       end
     end
 
-    # Adds a to_s filter to this Class's String attribute access methods.
-    def wrap_java_string_attribute(attribute, pd)
+    # Adds a number -> string filter to the given String property Ruby access methods.
+    def wrap_java_string_property(property)
+      ra, wa = property.accessors
+      jra, jwa = property.java_accessors
       # filter the attribute writer
-      awtr = "#{attribute}=".to_sym
-      pwtr = pd.write_method.name.to_sym
-      define_method(awtr) do |value|
-        stdval = value.to_s unless value.nil_or_empty?
-        send(pwtr, stdval)
+      define_method(wa) do |value|
+        stdval = Math.numeric?(value) ? value.to_s : value
+        send(jwa, stdval)
       end
-      logger.debug { "Filtered #{qp} #{awtr} method with non-String -> String converter." }
+      logger.debug { "Filtered #{qp} #{wa} method with non-String -> String converter." }
     end
 
-    # Adds a date parser filter to this Class's Date attribute access methods.
-    def wrap_java_date_attribute(attribute, pd)
+    # Adds a Java-Ruby Date filter to the given Date property Ruby access methods.
+    # The reader returns a Ruby date. The writer sets a Java date.
+    def wrap_java_date_property(property)
+      ra, wa = property.accessors
+      jra, jwa = property.java_accessors
+      
       # filter the attribute reader
-      prdr = pd.read_method.name.to_sym
-      define_method(attribute) do
-        value = send(prdr)
+      define_method(ra) do
+        value = send(jra)
         Java::JavaUtil::Date === value ? value.to_ruby_date : value
       end
       
       # filter the attribute writer
-      awtr = "#{attribute}=".to_sym
-      pwtr = pd.write_method.name.to_sym
-      define_method(awtr) do |value|
+      define_method(wa) do |value|
         value = Java::JavaUtil::Date.from_ruby_date(value) if ::Date === value
-        send(pwtr, value)
+        send(jwa, value)
       end
 
-      logger.debug { "Filtered #{qp} #{attribute} and #{awtr} methods with Java Date <-> Ruby Date converter." }
+      logger.debug { "Filtered #{qp} #{ra} and #{wa} methods with Java Date <-> Ruby Date converter." }
     end
 
-    # Aliases the methods _aliaz_ and _aliaz=_ to _attribute_ and _attribute=_, resp.,
-    # where _attribute_ is the Java attribute name for the attribute.
-    def alias_property_accessors(aliaz, attribute)
+    # Aliases the given Ruby property reader and writer to its underlying Java property reader and writer, resp.
+    #
+    # @param [Property] property the property to alias
+    def alias_property_accessors(property)
+      # the Java reader and writer accessor method symbols
+      jra, jwa = property.java_accessors
       # strip the Java reader and writer is/get/set prefix and make a symbol
-      prdr, pwtr = property(attribute).property_accessors
-      alias_method(aliaz, prdr)
-      writer = "#{aliaz}=".to_sym
-      alias_method(writer, pwtr)
+      alias_method(property.reader, jra)
+      alias_method(property.writer, jwa)
     end
 
     # Makes a standard attribute for the given property descriptor.
@@ -154,7 +158,7 @@ module Jinx
       pa = prop.attribute
       # the Java property name as an attribute symbol
       ja = pd.name.to_sym
-      delegate_to_attribute(ja, pa) unless pa == ja
+      delegate_to_property(ja, prop) unless prop.reader == ja
       prop
     end
     
@@ -168,12 +172,12 @@ module Jinx
     # _attribute=_ accessor methods, resp.
     # Calling rather than aliasing the attribute accessor allows the aliaz accessor to
     # reflect a change to the attribute accessor.
-    def delegate_to_attribute(aliaz, attribute)
-      if aliaz == attribute then Jinx.fail(MetadataError, "Cannot delegate #{self} #{aliaz} to itself.") end
-      rdr, wtr = property(attribute).accessors
-      define_method(aliaz) { send(rdr) }
-      define_method("#{aliaz}=".to_sym) { |value| send(wtr, value) }
-      register_property_alias(aliaz, attribute)
+    def delegate_to_property(aliaz, property)
+      ra, wa = property.accessors
+      if aliaz == ra then raise MetadataError.new("Cannot delegate #{self} #{aliaz} to itself.") end
+      define_method(aliaz) { send(ra) }
+      define_method("#{aliaz}=".to_sym) { |value| send(wa, value) }
+      register_property_alias(aliaz, property.attribute)
     end
   end
 end

data/lib/jinx/metadata/inverse.rb

@@ -56,7 +56,7 @@ module Jinx
       end
       # This class must be the same as or a subclass of the inverse attribute type.
       unless self <= inv_prop.type then
-        Jinx.fail(TypeError, "Cannot set #{qp}.#{pa} inverse to #{prop.type.qp}.#{pa} with incompatible type #{inv_prop.type.qp}")
+        raise TypeError.new("Cannot set #{qp}.#{pa} inverse to #{prop.type.qp}.#{pa} with incompatible type #{inv_prop.type.qp}")
       end
       # Set the inverse in the attribute metadata.
       prop.inverse = inverse
@@ -70,6 +70,22 @@ module Jinx
       end
       logger.debug { "Set #{qp}.#{pa} inverse to #{inverse}." }
     end
+
+    # Clears the property inverse, if there is one.
+    def clear_inverse(property)
+      # the inverse property
+      ip = property.inverse_property || return
+      # If the property is a collection and the inverse is not, then delegate to
+      # the inverse.
+      if property.collection? then
+        return ip.declarer.clear_inverse(ip) unless ip.collection?
+      else
+        # Restore the property reader and writer to the Java reader and writer, resp.
+        alias_property_accessors(property)
+      end
+      # Unset the inverse.
+      property.inverse = nil
+    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.

data/lib/jinx/metadata/java_property.rb

@@ -9,7 +9,7 @@ module Jinx
     attr_reader :property_descriptor
 
     # This property's Java property [reader, writer] accessors, e.g. +[:getActivityStatus, :setActivityStatus]+.
-    attr_reader :property_accessors
+    attr_reader :java_accessors
 
     # Creates a Ruby Property symbol corresponding to the given Ruby Java class wrapper klazz
     # and Java property_descriptor.
@@ -34,34 +34,34 @@ module Jinx
       @property_descriptor = pd
       # deficient Java introspector does not recognize 'is' prefix for a Boolean property
       rm = declarer.property_read_method(pd)
-      Jinx.fail(ArgumentError, "Property does not have a read method: #{declarer.qp}.#{pd.name}") unless rm
+      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
-          Jinx.fail(ArgumentError, "Reader method not found for #{declarer} property #{pd.name}")
+          raise ArgumentError.new("Reader method not found for #{declarer} property #{pd.name}")
         end
       end
       unless pd.write_method then
-        Jinx.fail(ArgumentError, "Property does not have a write method: #{declarer.qp}.#{pd.name}")
+        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
-        Jinx.fail(ArgumentError, "Writer method not found for #{declarer} property #{pd.name}")
+        raise ArgumentError.new("Writer method not found for #{declarer} property #{pd.name}")
       end
-      @property_accessors = [reader, writer]
+      @java_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
+    def java_reader
+      java_accessors.first
     end
     
     # @return [Symbol] the JRuby wrapper method for the Java property writer
-    def property_writer
-      property_accessors.last
+    def java_writer
+      java_accessors.last
     end
 
     # Returns a lower-case, underscore symbol for the given property_name.

data/lib/jinx/metadata/propertied.rb

@@ -15,13 +15,10 @@ module Jinx
 
     # Returns whether this class has an attribute with the given symbol.
     #
-    # @param [Symbol] symbol the potential attribute
+    # @param [String, Symbol] name the potential attribute
     # @return [Boolean] whether there is a corresponding attribute
-    def property_defined?(symbol)
-      unless Symbol === symbol then
-        Jinx.fail(ArgumentError, "Property argument #{symbol.qp} of type #{symbol.class.qp} is not a symbol")
-      end
-      !!@alias_std_prop_map[symbol.to_sym]
+    def property_defined?(name)
+      !!@alias_std_prop_map[name.to_sym]
     end
 
     # Adds the given attribute to this Class.
@@ -80,7 +77,8 @@ module Jinx
       @prop_hash.each_value(&block)
     end
 
-    # @return the Property for the given attribute symbol or alias
+    # @param [Symbol] attribute the property attribute symbol or alias
+    # @return [Property] the corresponding property
     # @raise [NameError] if the attribute is not recognized
     def property(attribute)
       # Simple and predominant case is that the attribute is a standard attribute.
@@ -88,7 +86,7 @@ module Jinx
       prop = @prop_hash[attribute] || @prop_hash[standard_attribute(attribute)]
       # If not found, then raise a NameError.
       if prop.nil? then
-        Jinx.fail(NameError, "#{name.demodulize} attribute not found: #{attribute}")
+        raise NameError.new("#{name.demodulize} attribute not found: #{attribute}")
       end
       prop
     end
@@ -116,9 +114,9 @@ module Jinx
     # @raise [NameError] if the attribute is not found
     def standard_attribute(name_or_alias)
       if name_or_alias.nil? then
-        Jinx.fail(ArgumentError, "#{qp} standard attribute call is missing the attribute name/alias parameter")
+        raise ArgumentError.new("#{qp} standard attribute call is missing the attribute name/alias parameter")
       end
-      @alias_std_prop_map[name_or_alias.to_sym] or Jinx.fail(NameError, "#{self} attribute not found: #{name_or_alias}")
+      @alias_std_prop_map[name_or_alias.to_sym] or raise NameError.new("#{self} attribute not found: #{name_or_alias}")
     end
 
     ## Metadata ATTRIBUTE FILTERS ##
@@ -217,10 +215,15 @@ module Jinx
     # @return [AttributeEnumerator] a new attribute enumerator
     def attribute_filter(attributes=nil, &filter)
       # make the attribute filter
-      raise MetadataError.new("#{self} has not been introspected") if @prop_hash.nil?
+      raise MetadataError.new("#{self} has not been introspected") unless introspected?
       ph = attributes ? attributes.to_compact_hash { |pa| @prop_hash[pa] } : @prop_hash
       AttributeEnumerator.new(ph, &filter)
     end
+       
+    # @return [Boolean] whether this class's metadata has been introspected
+    def introspected?
+      !!@prop_hash
+    end
 
     protected
     
@@ -296,7 +299,7 @@ module Jinx
     # @param [Symbol] attribute the attribute to alias
     def alias_attribute(aliaz, attribute)
       if property_defined?(attribute) then
-        delegate_to_attribute(aliaz, attribute)
+        delegate_to_property(aliaz, property(attribute))
         register_property_alias(aliaz, attribute)
       else
         super
@@ -368,7 +371,7 @@ module Jinx
         prop.restrict(self, :type => klass)
         logger.debug { "Restricted #{prop.declarer.qp}.#{attribute}(#{prop.type.qp}) to #{qp} with return type #{klass.qp}." }
       else
-        Jinx.fail(ArgumentError, "Cannot reset #{qp}.#{attribute} type #{prop.type.qp} to incompatible #{klass.qp}")
+        raise ArgumentError.new("Cannot reset #{qp}.#{attribute} type #{prop.type.qp} to incompatible #{klass.qp}")
       end
     end
 
@@ -416,7 +419,7 @@ module Jinx
       prop = @local_prop_hash.delete(std_prop)
       if prop then
         # clear the inverse, if any
-        prop.inverse = nil
+        clear_inverse(prop)
         # remove from the mandatory attributes, if necessary
         @local_mndty_flt.delete(std_prop)
         # remove from the attribute => metadata hash
@@ -443,7 +446,7 @@ module Jinx
     # @param (see #alias_attribute)
     def register_property_alias(aliaz, attribute)
       std = standard_attribute(attribute)
-      Jinx.fail(ArgumentError, "#{self} attribute not found: #{attribute}") if std.nil?
+      raise ArgumentError.new("#{self} attribute not found: #{attribute}") if std.nil?
       @local_std_prop_hash[aliaz.to_sym] = std
     end
 
@@ -457,7 +460,7 @@ module Jinx
       return enum unless Class === self and superclass.parent_module == parent_module
       anc_enum = yield superclass
       if anc_enum.nil? then
-        Jinx.fail(MetadataError, "#{qp} superclass #{superclass.qp} does not have required metadata")
+        raise MetadataError.new("#{qp} superclass #{superclass.qp} does not have required metadata")
       end
       enum.union(anc_enum)
     end

data/lib/jinx/metadata/property.rb

@@ -121,13 +121,13 @@ module Jinx
       begin
         @inv_prop = type.property(attribute)
       rescue NameError => e
-        Jinx.fail(MetadataError, "#{@declarer.qp}.#{self} inverse attribute #{type.qp}.#{attribute} not found", e)
+        raise MetadataError.new("#{@declarer.qp}.#{self} inverse attribute #{type.qp}.#{attribute} not found")
       end
       # the inverse of the inverse
       inv_inv_prop = @inv_prop.inverse_property
       # If the inverse of the inverse is already set to a different attribute, then raise an exception.
       if inv_inv_prop and not (inv_inv_prop == self or inv_inv_prop.restriction?(self))
-        Jinx.fail(MetadataError, "Cannot set #{type.qp}.#{attribute} inverse attribute to #{@declarer.qp}.#{self}@#{object_id} since it conflicts with existing inverse #{inv_inv_prop.declarer.qp}.#{inv_inv_prop}@#{inv_inv_prop.object_id}")
+        raise MetadataError.new("Cannot set #{type.qp}.#{attribute} inverse attribute to #{@declarer.qp}.#{self}@#{object_id} since it conflicts with existing inverse #{inv_inv_prop.declarer.qp}.#{inv_inv_prop}@#{inv_inv_prop.object_id}")
       end
       # Set the inverse of the inverse to this attribute.
       @inv_prop.inverse = @attribute
@@ -270,10 +270,10 @@ module Jinx
       rtype = opts[:type] || @type
       rinv = opts[:inverse] || inverse
       unless declarer < @declarer then
-        Jinx.fail(ArgumentError, "Cannot restrict #{@declarer.qp}.#{self} to an incompatible declarer type #{declarer.qp}")
+        raise ArgumentError.new("Cannot restrict #{@declarer.qp}.#{self} to an incompatible declarer type #{declarer.qp}")
       end
       unless rtype <= @type then
-        Jinx.fail(ArgumentError, "Cannot restrict #{@declarer.qp}.#{self}({@type.qp}) to an incompatible return type #{rtype.qp}")
+        raise ArgumentError.new("Cannot restrict #{@declarer.qp}.#{self}({@type.qp}) to an incompatible return type #{rtype.qp}")
       end
       # Copy this attribute and its instance variables minus the restrictions and make a deep copy of the flags.
       rst = deep_copy
@@ -318,7 +318,7 @@ module Jinx
     # @param [Class] klass the declaring class of this restriction attribute
     def set_restricted_declarer(klass)
       if @declarer and not klass < @declarer then
-        Jinx.fail(MetadataError, "Cannot reset #{declarer.qp}.#{self} declarer to #{type.qp}")
+        raise MetadataError.new("Cannot reset #{declarer.qp}.#{self} declarer to #{type.qp}")
       end
       @declarer = klass
       @declarer.add_restriction(self)
@@ -350,11 +350,11 @@ module Jinx
       return unless @inv_prop
       logger.debug { "Clearing #{@declarer.qp}.#{self} inverse #{type.qp}.#{inverse}..." }
       # Capture the inverse before unsetting it.
-      inv_prop = @inv_prop
+      ip = @inv_prop
       # Unset the inverse.
       @inv_prop = nil
       # Clear the inverse of the inverse.
-      inv_prop.inverse = nil
+      ip.inverse = nil
       logger.debug { "Cleared #{@declarer.qp}.#{self} inverse." }
     end
     
@@ -363,7 +363,7 @@ module Jinx
     def set_flag(flag)
       return if @flags.include?(flag)
       unless flag_supported?(flag) then
-        Jinx.fail(ArgumentError, "Property #{declarer.name}.#{self} flag not supported: #{flag.qp}")
+        raise ArgumentError.new("Property #{declarer.name}.#{self} flag not supported: #{flag.qp}")
       end
       @flags << flag
       case flag
@@ -379,11 +379,11 @@ module Jinx
     # @raise [MetadataError] if this attribute is dependent or an inverse could not be inferred
     def owner_flag_set
       if dependent? then
-        Jinx.fail(MetadataError, "#{declarer.qp}.#{self} cannot be set as a #{type.qp} owner since it is already defined as a #{type.qp} dependent")
+        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
-        Jinx.fail(MetadataError, "#{@declarer.qp} owner attribute #{self} does not have a #{type.qp} dependent inverse")
+        raise MetadataError.new("#{@declarer.qp} owner attribute #{self} does not have a #{type.qp} dependent inverse")
       end
       logger.debug { "#{declarer.qp}.#{self} inverse is the #{type.qp} dependent attribute #{inv_attr}." }
       self.inverse = inv_attr
@@ -394,7 +394,7 @@ module Jinx
     # @raise [MetadataError] if this is an owner attribute
     def dependent_flag_set
       if owner? then
-        Jinx.fail(MetadataError, "#{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