activefacts-api 0.8.9 → 0.8.10

data/lib/activefacts/api/instance.rb

@@ -15,21 +15,23 @@ module ActiveFacts
 
       def initialize(args = []) #:nodoc:
         unless (self.class.is_entity_type)
-        #if (self.class.superclass != Object)
-          # puts "constructing #{self.class.superclass} with #{args.inspect}"
-          super(*args)
+          begin
+            super(*args)
+          rescue ArgumentError => e
+            e.message << " constructing a #{self.class}"
+            raise
+          end
         end
       end
 
       # Verbalise this instance
       def verbalise
         # This method should always be overridden in subclasses
-        raise "#{self.class} Instance verbalisation needed"
       end
 
       # De-assign all functional roles and remove from constellation, if any.
       def retract
-        # Delete from the constellation first, so it can remember our identifying role values
+        # Delete from the constellation first, while it remembers our identifying role values
         @constellation.__retract(self) if @constellation
 
         # Now, for all roles (from this class and all supertypes), assign nil to all functional roles
@@ -37,12 +39,18 @@ module ActiveFacts
         ([self.class]+self.class.supertypes_transitive).each do |klass|
           klass.roles.each do |role_name, role|
             next if role.unary?
-            next if !role.unique
-
             counterpart = role.counterpart
-            puts "Nullifying mandatory role #{role.name} of #{role.owner.name}" if counterpart.mandatory
+            if role.unique
+              # puts "Nullifying mandatory role #{role.name} of #{role.object_type.name}" if counterpart.mandatory
 
-            send "#{role.name}=", nil
+              send role.setter, nil
+            else
+              # puts "Not removing role #{role_name} from counterpart RoleValues #{counterpart.name}"
+              # Duplicate the array using to_a, as the RoleValues here will be modified as we traverse it:
+              send(role.name).to_a.each do |v|
+                v.send(counterpart.setter, nil)
+              end
+            end
           end
         end
       end

data/lib/activefacts/api/instance_index.rb

@@ -12,72 +12,73 @@ module ActiveFacts
     # arguments (where ObjectType is the object_type name you're interested in)
     #
     class InstanceIndex
+      def initialize(constellation, klass)
+        @constellation = constellation
+        @klass = klass
+        @hash = {}
+      end
+
+      def inspect
+        "<InstanceIndex for #{@klass.name} in #{@constellation.inspect}>"
+      end
+
+      def assert(*args)
+        #trace :assert, "Asserting #{@klass} with #{args.inspect}" do
+          instance, key = *@klass.assert_instance(@constellation, args)
+          instance
+        #end
+      end
+
+      def include?(*args)
+        if args.size == 1 && args[0].is_a?(@klass)
+          key = args[0].identifying_role_values
+        else
+          key = @klass.identifying_role_values(*args)
+        end
+        return @hash[key]
+      end
+
       def []=(key, value)   #:nodoc:
-        raise "Adding RoleProxy to InstanceIndex" if value && RoleProxy === value
-        h[key] = value
+        @hash[key] = value
       end
 
       def [](*args)
-        a = args
-        #a = naked(args)
-#        p "vvvv",
-#          args,
-#          a,
-#          keys.map{|k| v=super(k); (RoleProxy === k ? "*" : "")+k.to_s+"=>"+(RoleProxy === v ? "*" : "")+v.to_s}*",",
-#          "^^^^"
-        h[*a]
-        #super(*a)
+        @hash[*args]
       end
 
       def size
-        h.size
+        @hash.size
       end
 
       def empty?
-        h.size == 0
+        @hash.size == 0
       end
 
       def each &b
-        h.each &b
+        @hash.each &b
       end
 
       def map &b
-        h.map &b
+        @hash.map &b
       end
 
       def detect &b
-        r = h.detect &b
+        r = @hash.detect &b
         r ? r[1] : nil
       end
 
       # Return an array of all the instances of this object_type
       def values
-        h.values
+        @hash.values
       end
 
       # Return an array of the identifying role values arrays for all the instances of this object_type
       def keys
-        h.keys
+        @hash.keys
       end
 
       def delete_if(&b)   #:nodoc:
-        h.delete_if &b
-      end
-
-    private
-      def h
-        @hash ||= {}
-      end
-
-      def naked(o)
-        case o
-        when Array
-          o.map{|e| naked(e) }
-        when RoleProxy
-          o.__getobj__
-        else
-          o
-        end
+        @hash.delete_if &b
       end
     end
   end

data/lib/activefacts/api/numeric.rb

@@ -22,11 +22,15 @@ class Int < SimpleDelegator
   end
 
   def hash                              #:nodoc:
-    __getobj__.hash ^ self.class.hash
+    __getobj__.hash
   end
 
   def eql?(o)                           #:nodoc:
-    self.class == o.class and __getobj__.eql?(Integer(o))
+    # Note: This and #hash do not work the way you'd expect,
+    # and differently in each Ruby interpreter. If you store
+    # an Int or Real in a hash, you cannot reliably retrieve
+    # them with the corresponding Integer or Real.
+    __getobj__.eql?(Integer(o))
   end
 
   def ==(o)                             #:nodoc:
@@ -34,7 +38,7 @@ class Int < SimpleDelegator
   end
 
   def is_a?(k)
-    __getobj__.is_a?(k)
+    __getobj__.is_a?(k) || super
   end
 
   def inspect
@@ -49,7 +53,7 @@ class Real < SimpleDelegator
   end
 
   def hash                              #:nodoc:
-    __getobj__.hash ^ self.class.hash
+    __getobj__.hash
   end
 
   def to_s                              #:nodoc:
@@ -57,7 +61,8 @@ class Real < SimpleDelegator
   end
 
   def eql?(o)                           #:nodoc:
-    self.class == o.class and __getobj__.eql?(Float(o))
+    # Note: See the note above on Int#eql?
+    __getobj__.eql?(Float(o))
   end
 
   def ==(o)                             #:nodoc:
@@ -65,7 +70,7 @@ class Real < SimpleDelegator
   end
 
   def is_a?(k)
-    __getobj__.is_a?(k)
+    __getobj__.is_a?(k) || super
   end
 
   def inspect                           #:nodoc:
@@ -78,7 +83,6 @@ class ::Date
   class << self; alias_method :old_new, :new end
   # Date.new cannot normally be called passing a Date as the parameter. This allows that.
   def self.new(*a, &b)
-    #puts "Constructing date with #{a.inspect} from #{caller*"\n\t"}"
     if (a.size == 1 && a[0].is_a?(Date))
       a = a[0]
       civil(a.year, a.month, a.day, a.start)
@@ -95,13 +99,12 @@ class ::DateTime
   class << self; alias_method :old_new, :new end
   # DateTime.new cannot normally be called passing a Date or DateTime as the parameter. This allows that.
   def self.new(*a, &b)
-    #puts "Constructing DateTime with #{a.inspect} from #{caller*"\n\t"}"
     if (a.size == 1)
       a = a[0]
       if (DateTime === a)
         civil(a.year, a.month, a.day, a.hour, a.min, a.sec, a.start)
       elsif (Date === a)
-        civil(a.year, a.month, a.day, a.start)
+        civil(a.year, a.month, a.day, 0, 0, 0, a.start)
       else
         civil(*a, &b)
       end
@@ -118,14 +121,13 @@ end
 # The assigned value will be filled out everywhere it needs to be, upon save.
 class AutoCounter
   def initialize(i = :new)
-    raise "AutoCounter #{self.class} may not be #{i.inspect}" unless i == :new or i.is_a?(Integer)
-    # puts "new AutoCounter #{self.class} from\n\t#{caller.select{|s| s !~ %r{rspec}}*"\n\t"}"
-    @value = i == :new ? nil : i
+    raise "AutoCounter #{self.class} may not be #{i.inspect}" unless i == :new or i.is_a?(Integer) or i.is_a?(AutoCounter)
+    @value = i == :new ? nil : i.to_i
   end
 
   # Assign a definite value to an AutoCounter; this may only be done once
   def assign(i)
-    raise ArgumentError if @value
+    raise ArgumentError, "Illegal attempt to assign integer value of a committed AutoCounter" if @value
     @value = i.to_i
   end
 
@@ -143,8 +145,14 @@ class AutoCounter
   end
 
   # An AutoCounter may only be used in numeric expressions after a definite value has been assigned
-  def self.coerce(i)
-    raise ArgumentError unless @value
+  def to_i
+    raise ArgumentError, "Illegal attempt to get integer value of an uncommitted AutoCounter" unless @value
+    @value
+  end
+
+  # Coerce "i" to be of the same type as self
+  def coerce(i)
+    raise ArgumentError, "Illegal attempt to use the value of an uncommitted AutoCounter" unless @value
     [ i.to_i, @value ]
   end
 
@@ -153,22 +161,26 @@ class AutoCounter
   end
 
   def hash                              #:nodoc:
-    to_s.hash ^ self.class.hash
+    if self.defined?
+      @value.hash
+    else
+      0
+    end
   end
 
   def eql?(o)                           #:nodoc:
-    self.class == o.class and to_s.eql?(o.to_s)
+    to_s.eql?(o.to_s)
   end
 
   def self.inherited(other)             #:nodoc:
     def other.identifying_role_values(*args)
       return nil if args == [:new]  # A new object has no identifying_role_values
+      return args[0] if args.size == 1 and args[0].is_a?(AutoCounter)
       return new(*args)
     end
     super
   end
 
-private
   def clone
     raise "Not allowed to clone AutoCounters"
   end

data/lib/activefacts/api/object_type.rb

@@ -17,27 +17,25 @@ module ActiveFacts
       end
 
       # Each ObjectType maintains a list of the Roles it plays:
-      def roles(name = nil)
+      def roles(role_name = nil)
         unless instance_variable_defined? "@roles"
           @roles = RoleCollection.new     # Initialize and extend without warnings.
         end
-        case name
+        case role_name
         when nil
           @roles
         when Symbol, String
           # Search this class then all supertypes:
-          unless role = @roles[name.to_sym]
+          unless role = @roles[role_name.to_sym]
             role = nil
             supertypes.each do |supertype|
-                r = supertype.roles(name) rescue nil
+                r = supertype.roles(role_name) rescue nil
                 next unless r
                 role = r
                 break
               end
           end
-          raise "Role #{basename}.#{name} is not defined" unless role
-          # Bind the role if possible, but don't require it:
-          role.resolve_counterpart(vocabulary) rescue nil unless role.counterpart_object_type.is_a?(Class)
+          raise "Role #{basename}.#{role_name} is not defined" unless role
           role
         else
           nil
@@ -48,7 +46,7 @@ module ActiveFacts
       #
       # Example: maybe :is_ceo
       def maybe(role_name)
-        realise_role(roles[role_name] = Role.new(self, TrueClass, nil, role_name))
+        realise_role(roles[role_name] = Role.new(self, nil, role_name))
       end
 
       # Define a binary fact type relating this object_type to another,
@@ -83,28 +81,38 @@ module ActiveFacts
       end
 
       # Access supertypes or add new supertypes; multiple inheritance.
-      # With parameters (Class objects), it adds new supertypes to this class. Instances of this class will then have role methods for any new superclasses (transitively). Superclasses must be Ruby classes which are existing ObjectTypes.
-      # Without parameters, it returns the array of ObjectType supertypes (one by Ruby inheritance, any others as defined using this method)
+      # With parameters (Class objects), it adds new supertypes to this class.
+      # Instances of this class will then have role methods for any new superclasses (transitively).
+      # Superclasses must be Ruby classes which are existing ObjectTypes.
+      # Without parameters, it returns the array of ObjectType supertypes
+      # (one by Ruby inheritance, any others as defined using this method)
       def supertypes(*object_types)
         class_eval do
           @supertypes ||= []
           all_supertypes = supertypes_transitive
           object_types.each do |object_type|
             next if all_supertypes.include? object_type
-            case object_type
-            when Class
-              @supertypes << object_type
-            when Symbol
-              # No late binding here:
-              @supertypes << (object_type = vocabulary.const_get(object_type.to_s.camelcase))
-            else
-              raise "Illegal supertype #{object_type.inspect} for #{self.class.basename}"
+            supertype =
+              case object_type
+              when Class
+                object_type
+              when Symbol
+                # No late binding here:
+                (object_type = vocabulary.const_get(object_type.to_s.camelcase))
+              else
+                raise "Illegal supertype #{object_type.inspect} for #{self.class.basename}"
+              end
+            raise "#{supertype.name} must be an object type in #{vocabulary.name}" unless supertype.respond_to?(:vocabulary) and supertype.vocabulary == self.vocabulary
+
+            if is_entity_type != supertype.is_entity_type
+              raise "#{self} < #{supertype}: A value type may not be a supertype of an entity type, and vice versa"
             end
 
+            @supertypes << supertype
+
             # Realise the roles (create accessors) of this supertype.
             # REVISIT: The existing accessors at the other end will need to allow this class as role counterpart
             # REVISIT: Need to check all superclass roles recursively, unless we hit a common supertype
-            #puts "Realising object_type #{object_type.name} in #{basename}"
             realise_supertypes(object_type, all_supertypes)
           end
           [(superclass.vocabulary && superclass rescue nil), *@supertypes].compact
@@ -117,11 +125,12 @@ module ActiveFacts
           supertypes = []
           supertypes << superclass if Module === (superclass.vocabulary rescue nil)
           supertypes += (@supertypes ||= [])
-          supertypes.inject([]) {|a, t|
-              next if a.include?(t)
-              a += [t]
-              a += t.supertypes_transitive rescue []
-            }.uniq
+          sts = supertypes.inject([]) do |a, t|
+            next if a.include?(t)
+            a += [t]
+            a += t.supertypes_transitive rescue []
+          end.uniq
+          sts # The local variable unconfuses rcov
         end
       end
 
@@ -131,20 +140,20 @@ module ActiveFacts
 
       # Every new role added or inherited comes through here:
       def realise_role(role) #:nodoc:
-        #puts "Realising role #{role.counterpart_object_type.basename rescue role.counterpart_object_type}.#{role.name} in #{basename}"
-
         if (!role.counterpart)
           # Unary role
           define_unary_role_accessor(role)
         elsif (role.unique)
-          define_single_role_accessor(role, role.counterpart.unique)
+          if role.counterpart.unique
+            define_one_to_one_accessor(role)
+          else
+            define_one_to_many_accessor(role)
+          end
         else
-          define_array_role_accessor(role)
+          define_many_to_one_accessor(role)
         end
       end
 
-      # REVISIT: Use method_missing to catch all_some_role_as_other_role_and_third_role, to sort_by those roles?
-
       def is_a? klass
         super || supertypes_transitive.include?(klass)
       end
@@ -154,14 +163,12 @@ module ActiveFacts
       def realise_supertypes(object_type, all_supertypes = nil)
         all_supertypes ||= supertypes_transitive
         s = object_type.supertypes
-        #puts "realising #{object_type.basename} supertypes #{s.inspect} of #{basename}"
-        s.each {|t|
-            next if all_supertypes.include? t
-            realise_supertypes(t, all_supertypes)
-            t.subtypes << self
-            all_supertypes << t
-          }
-        #puts "Realising roles of #{object_type.basename} in #{basename}"
+        s.each do |t|
+          next if all_supertypes.include? t
+          realise_supertypes(t, all_supertypes)
+          t.subtypes << self unless t.subtypes.include?(self)
+          all_supertypes << t
+        end
         realise_roles(object_type)
       end
 
@@ -174,34 +181,35 @@ module ActiveFacts
 
       # Shared code for both kinds of binary fact type (has_one and one_to_one)
       def define_binary_fact_type(one_to_one, role_name, related, mandatory, related_role_name)
-        # puts "#{self}.#{role_name} is to #{related.inspect}, #{mandatory ? :mandatory : :optional}, related role is #{related_role_name}"
-
+        # REVISIT: What if the role exists on a supertype? This won't prevent that:
         raise "#{name} cannot have more than one role named #{role_name}" if roles[role_name]
-        roles[role_name] = role = Role.new(self, related, nil, role_name, mandatory)
+        roles[role_name] = role = Role.new(self, nil, role_name, mandatory)
 
         # There may be a forward reference here where role_name is a Symbol,
         # and the block runs later when that Symbol is bound to the object_type.
         when_bound(related, self, role_name, related_role_name) do |target, definer, role_name, related_role_name|
           if (one_to_one)
-            target.roles[related_role_name] = role.counterpart = Role.new(target, definer, role, related_role_name, false)
+            target.roles[related_role_name] = role.counterpart = Role.new(target, role, related_role_name, false)
           else
-            target.roles[related_role_name] = role.counterpart = Role.new(target, definer, role, related_role_name, false, false)
+            target.roles[related_role_name] = role.counterpart = Role.new(target, role, related_role_name, false, false)
           end
-          role.counterpart_object_type = target
-          #puts "Realising role pair #{definer.basename}.#{role_name} <-> #{target.basename}.#{related_role_name}"
           realise_role(role)
           target.realise_role(role.counterpart)
         end
       end
 
       def define_unary_role_accessor(role)
-        # puts "Defining #{basename}.#{role_name} as unary"
         class_eval do
-          define_method "#{role.name}=" do |value|
-            #puts "Setting #{self.class.name} #{object_id}.@#{role.name} to #{(value ? true : nil).inspect}"
-            instance_variable_set("@#{role.name}", value ? true : nil)
+          define_method role.setter do |value|
+            assigned = case value
+              when nil; nil
+              when false; false
+              else true
+              end
+            instance_variable_set(role.variable, assigned)
             # REVISIT: Provide a way to find all instances playing/not playing this role
             # Analogous to true.all_thing_as_role_name...
+            assigned
           end
         end
         define_single_role_getter(role)
@@ -209,86 +217,90 @@ module ActiveFacts
 
       def define_single_role_getter(role)
         class_eval do
-          define_method role.name do |*a|
+          define_method role.getter do |*a|
             raise "Parameters passed to #{self.class.name}\##{role.name}" if a.size > 0
-            i = instance_variable_get("@#{role.name}") rescue nil
-            i ? RoleProxy.new(role, i) : i
-            i
+            instance_variable_get(role.variable) rescue nil
           end
         end
       end
 
-      # REVISIT: Add __add_to(constellation) and __remove(constellation) here?
-      def define_single_role_accessor(role, one_to_one)
-        # puts "Defining #{basename}.#{role.name} to #{role.counterpart_object_type.basename} (#{one_to_one ? "assigning" : "populating"} #{role.counterpart.name})"
+      def define_one_to_one_accessor(role)
         define_single_role_getter(role)
 
-        if (one_to_one)
-          # This gets called to assign nil to the related role in the old correspondent:
-          # value is included here so we can check that the correct value is being nullified, if necessary
-          nullify_reference = lambda{|from, role_name, value| from.send("#{role_name}=".to_sym, nil) }
+        class_eval do
+          define_method role.setter do |value|
+            role_var = role.variable
 
-          # This gets called to replace an old single value for a new one in the related role of a new correspondent
-          assign_reference = lambda{|from, role_name, old_value, value| from.send("#{role_name}=".to_sym, value) }
+            # Get old value, and jump out early if it's unchanged:
+            old = instance_variable_get(role_var) rescue nil
+            return value if old.equal?(value)         # Occurs when another instance having the same value is assigned
 
-          define_single_role_setter(role, nullify_reference, assign_reference)
-        else
-          # This gets called to delete this object from the role value array in the old correspondent
-          delete_reference = lambda{|from, role_name, value| from.send(role_name).update(value, nil) }
+            value = role.adapt(constellation, value) if value
+            return value if old.equal?(value)         # Occurs when same value but not same instance is assigned
+
+            # REVISIT: A frozen-key solution could be used to allow changing identifying roles.
+            # If this object plays an identifying role in other objects, they also need re-indexing
+#            if role.is_identifying
+#              raise "#{self.class.basename}: illegal attempt to modify identifying role #{role.name}" if value != nil && old != nil
+#            end
 
-          # This gets called to replace an old value by a new one in the related role value array of a new correspondent
-          replace_reference = lambda{|from, role_name, old_value, value| 
-              from.send(role_name).update(old_value, value)
-            }
+            instance_variable_set(role_var, value)
 
-          define_single_role_setter(role, delete_reference, replace_reference)
+            # Remove self from the old counterpart:
+            old.send(role.counterpart.setter, nil) if old
+
+            # Assign self to the new counterpart
+            value.send(role.counterpart.setter, self) if value
+
+            value
+          end
         end
       end
 
-      def define_single_role_setter(role, deassign_old, assign_new)
-        class_eval do
-          define_method "#{role.name}=" do |value|
-            role_var = "@#{role.name}"
+      def define_one_to_many_accessor(role)
+        define_single_role_getter(role)
 
-            # If role.counterpart_object_type isn't bound to a class yet, bind it.
-            role.resolve_counterpart(self.class.vocabulary) unless role.counterpart_object_type.is_a?(Class)
+        class_eval do
+          define_method role.setter do |value|
+            role_var = role.variable
 
             # Get old value, and jump out early if it's unchanged:
             old = instance_variable_get(role_var) rescue nil
-            return if old == value        # Occurs during one_to_one assignment, for example
+            return value if old.equal?(value)         # Occurs during one_to_one assignment, for example
 
             value = role.adapt(constellation, value) if value
-            return if old == value        # Occurs when same value is assigned
-
-            # DEBUG: puts "assign #{self.class.basename}.#{role.name} <-> #{value.inspect}.#{role.counterpart.name}#{old ? " (was #{old.inspect})" : ""}"
+            return value if old.equal?(value)         # Occurs when another instance having the same value is assigned
 
             # REVISIT: A frozen-key solution could be used to allow changing identifying roles.
+            # If this object plays an identifying role in other objects, they need re-indexing
             # The key would be frozen, allowing indices and counterparts to de-assign,
             # but delay re-assignment until defrosted.
             # That would also allow caching the identifying_role_values, a performance win.
 
             # This allows setting and clearing identifying roles, but not changing them.
-            raise "#{self.class.basename}: illegal attempt to modify identifying role #{role.name}" if role.is_identifying && value != nil && old != nil
+#            if role.is_identifying
+#              raise "#{self.class.basename}: illegal attempt to modify identifying role #{role.name}" if value != nil && old != nil
+#            end
 
-            # puts "Setting binary #{role_var} to #{value.verbalise}"
             instance_variable_set(role_var, value)
 
-            # De-assign/remove "self" at the old other end too:
-            deassign_old.call(old, role.counterpart.name, self) if old
+            # Remove "self" from the old counterpart:
+            old.send(getter = role.counterpart.getter).update(self, nil) if old
 
-            # Assign/add "self" at the other end too:
-            assign_new.call(value, role.counterpart.name, old, self) if value
+            # Add "self" into the counterpart
+            value.send(getter ||= role.counterpart.getter).update(old, self) if value
+
+            value
           end
         end
       end
 
-      def define_array_role_accessor(role)
+      def define_many_to_one_accessor(role)
         class_eval do
-          define_method "#{role.name}" do
-            unless (r = instance_variable_get(role_var = "@#{role.name}") rescue nil)
+          define_method role.getter do
+            unless (r = instance_variable_get(role_var = role.variable) rescue nil)
               r = instance_variable_set(role_var, RoleValues.new)
             end
-            # puts "fetching #{self.class.basename}.#{role.name} array, got #{r.class}, first is #{r[0] ? r[0].verbalise : "nil"}"
             r
           end
         end
@@ -319,12 +331,11 @@ module ActiveFacts
       #   Role Name
       # else:
       #   Leading Adjective
-      #   Role counterpart_object_type name (not role name)
+      #   Role counterpart object_type name (not role name)
       #   Trailing Adjective
-      # "_as_<other_role_name>" if other_role_name != this role counterpart_object_type's name, and not other_player_this_player
+      # "_as_<other_role_name>" if other_role_name != this role's counterpart' object_type name, and not other_player_this_player
       def extract_binary_params(one_to_one, role_name, options)
         # Options:
-        #   other counterpart_object_type (Symbol or Class)
         #   mandatory (:mandatory)
         #   other end role name if any (Symbol),
         related = nil
@@ -332,8 +343,7 @@ module ActiveFacts
         related_role_name = nil
         role_player = self.basename.snakecase
 
-        role_name = a.name.snakecase.to_sym if Class === role_name
-        role_name = role_name.to_sym
+        role_name = (Class === role_name ? a.name.snakecase : role_name).to_sym
 
         # The related class might be forward-referenced, so handle a Symbol/String instead of a Class.
         related_name = options.delete(:class)
@@ -353,9 +363,10 @@ module ActiveFacts
 
         # resolve the Symbol to a Class now if possible:
         resolved = vocabulary.object_type(related) rescue nil
-        #puts "#{related} resolves to #{resolved}"
         related = resolved if resolved
-        # puts "related = #{related.inspect}"
+        if related.is_a?(Class)
+          raise "#{related} must be an object type in #{vocabulary.name}" unless related.respond_to?(:vocabulary) and related.vocabulary == self.vocabulary
+        end
 
         if options.delete(:mandatory) == true
           mandatory = true
@@ -385,7 +396,6 @@ module ActiveFacts
             (!related_role_name || related_role_name == role_player)
           other_role_method += "_as_#{role_name}"
         end
-        #puts "On #{basename}: have related_role_name=#{related_role_name.inspect}, role_player=#{role_player}, role_name=#{role_name}, related_name=#{related_name.inspect} -> #{related_name}.#{other_role_method}"
 
         [ role_name,
           related,
@@ -402,8 +412,6 @@ module ActiveFacts
           vocabulary.__delay(object_type.to_s.camelcase, args, &block)
         when String     # Arrange for this to happen later
           vocabulary.__delay(object_type, args, &block)
-        else
-          raise "Delayed binding not possible for #{object_type.class.name} #{object_type.inspect}"
         end
       end
     end