activefacts-api 0.9.3 → 0.9.4

data/lib/activefacts/api/object_type.rb

@@ -18,8 +18,8 @@ module ActiveFacts
 
       # Each ObjectType maintains a list of the Roles it plays:
       def roles(role_name = nil)
-        unless instance_variable_defined? "@roles"
-          @roles = RoleCollection.new     # Initialize and extend without warnings.
+        unless instance_variable_defined? "@roles"  # Avoid "instance variable not defined" warning from ||=
+          @roles = RoleCollection.new
         end
         case role_name
         when nil
@@ -65,7 +65,7 @@ module ActiveFacts
       # * :restrict - a list of values or ranges which this role may take. Not used yet.
       def has_one(role_name, options = {})
         role_name, related, mandatory, related_role_name = extract_binary_params(false, role_name, options)
-        detect_fact_type_collision(:type => :has_one, :role => role_name, :related => related)
+        check_identifying_role_has_valid_cardinality(:has_one, role_name)
         define_binary_fact_type(false, role_name, related, mandatory, related_role_name)
       end
 
@@ -82,20 +82,20 @@ module ActiveFacts
       def one_to_one(role_name, options = {})
         role_name, related, mandatory, related_role_name =
           extract_binary_params(true, role_name, options)
-        detect_fact_type_collision(:type => :one_to_one, :role => role_name, :related => related)
+        check_identifying_role_has_valid_cardinality(:one_to_one, role_name)
         define_binary_fact_type(true, role_name, related, mandatory, related_role_name)
       end
 
-      def detect_fact_type_collision(fact)
-        if respond_to?(:identifying_role_names) && identifying_role_names.include?(fact[:role])
-          case fact[:type]
+      def check_identifying_role_has_valid_cardinality(type, role)
+        if is_entity_type && identifying_role_names.include?(role)
+          case type
           when :has_one
             if identifying_role_names.size == 1
-              raise "Entity type #{self} cannot be identified by a single role '#{fact[:role]}' unless that role is one_to_one"
+              raise "Entity type #{self} cannot be identified by a single role '#{role}' unless that role is one_to_one"
             end
           when :one_to_one
             if identifying_role_names.size > 1
-              raise "Entity type #{self} cannot be identified by a single role '#{fact[:role]}' unless that role is has_one"
+              raise "Entity type #{self} cannot be identified by a single role '#{role}' unless that role is has_one"
             end
           end
         end
@@ -108,51 +108,47 @@ module ActiveFacts
       # 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
-            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
-            realise_supertypes(object_type, all_supertypes)
-          end
-          [(superclass.respond_to?(:vocabulary) ? superclass : nil), *@supertypes].compact
-        end
+	@supertypes ||= []
+	all_supertypes = supertypes_transitive
+	object_types.each do |object_type|
+	  next if all_supertypes.include? object_type
+	  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
+	  realise_supertypes(object_type, all_supertypes)
+	end
+	[(superclass.respond_to?(:vocabulary) ? superclass : nil), *@supertypes].compact
       end
 
       # Return the array of all ObjectType supertypes, transitively.
       def supertypes_transitive
-        class_eval do
-          supertypes = []
-          v = superclass.respond_to?(:vocabulary) ? superclass.vocabulary : nil
-          supertypes << superclass if v.kind_of?(Module)
-          supertypes += (@supertypes ||= [])
-          sts = supertypes.inject([]) do |a, t|
-            next if a.include?(t)
-            a += [t] + t.supertypes_transitive
-          end.uniq
-          sts # The local variable unconfuses rcov
-        end
+	supertypes = []
+	v = superclass.respond_to?(:vocabulary) ? superclass.vocabulary : nil
+	supertypes << superclass if v.kind_of?(Module)
+	supertypes += (@supertypes ||= [])
+	sts = supertypes.inject([]) do |a, t|
+	  next if a.include?(t)
+	  a += [t] + t.supertypes_transitive
+	end.uniq
+	sts # The local variable unconfuses rcov
       end
 
       def subtypes
@@ -175,10 +171,6 @@ module ActiveFacts
         end
       end
 
-      def is_a? klass
-        super || supertypes_transitive.include?(klass)
-      end
-
       private
 
       def realise_supertypes(object_type, all_supertypes = nil)
@@ -220,118 +212,130 @@ module ActiveFacts
       end
 
       def define_unary_role_accessor(role)
-        class_eval do
-          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_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
         define_single_role_getter(role)
       end
 
       def define_single_role_getter(role)
-        class_eval do
-          define_method role.getter do |*a|
-            raise "Parameters passed to #{self.class.name}\##{role.name}" if a.size > 0
-            instance_variable_get(role.variable)
-          end
-        end
+	define_method role.getter do |*a|
+	  raise "Parameters passed to #{self.class.name}\##{role.name}" if a.size > 0
+	  instance_variable_get(role.variable)
+	end
       end
 
       def define_one_to_one_accessor(role)
         define_single_role_getter(role)
 
-        class_eval do
-          define_method role.setter do |value|
-
-            old = instance_variable_get(role.variable)
-            return true if old.equal?(value)         # Occurs when another instance having the same value is assigned
-
-            value = role.adapt(@constellation, value) if value
-            return true if old.equal?(value)         # Occurs when same value but not same instance is assigned
-
-            detect_inconsistencies(role, value)
-
-            if @constellation && old
-              keys = old.related_entities.map do |entity|
-                [entity.identifying_role_values, entity]
-              end
-            end
-
-            instance_variable_set(role.variable, value)
-
-            # 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
-
-            if keys
-              keys.each do |key, entity|
-                entity.instance_index.refresh_key(key)
-              end
-            end
-
-            value
-          end
-        end
+	define_method role.setter do |value|
+	  old = instance_variable_get(role.variable)
+
+	  # When exactly the same value instance is assigned, we're done:
+	  return true if old == value
+
+	  if value and o = role.counterpart.object_type and (!value.is_a?(o) || value.constellation != @constellation)
+	    value = @constellation.assert(o, *Array(value))
+	    # return true if old.equal?(value)         # Occurs when same value but not same instance is assigned
+	    return true if old == value
+	  end
+
+	  dependent_entities = nil
+	  if (role.is_identifying)
+	    check_value_change_legality(role, value)
+
+	    # We're changing this object's key.
+	    # Find all object which are identified by this object, and save their old keys
+	    if @constellation && old
+	      dependent_entities = old.related_entities.map do |entity|
+		[entity.identifying_role_values, entity]
+	      end
+	    end
+	  end
+
+	  instance_variable_set(role.variable, value)
+
+	  # Remove self from the old counterpart:
+	  old.send(role.counterpart.setter, nil) if old
+
+	  @constellation.when_admitted do
+	    # Assign self to the new counterpart
+	    value.send(role.counterpart.setter, self) if value
+
+	    # Propagate dependent key changes
+	    if dependent_entities
+	      dependent_entities.each do |old_key, entity|
+		entity.instance_index.refresh_key(old_key)
+	      end
+	    end
+	  end
+
+	  value
+	end
       end
 
       def define_one_to_many_accessor(role)
         define_single_role_getter(role)
 
-        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)
-            return value if old.equal?(value)         # Occurs during one_to_one assignment, for example
-
-            value = role.adapt(constellation, value) if value
-            return value if old.equal?(value)         # Occurs when another instance having the same value is assigned
-
-            detect_inconsistencies(role, value) if value
-
-            if old && old.constellation
-              keys = old.related_entities.map do |entity|
-                [entity.identifying_role_values, entity]
-              end
-            end
-
-            instance_variable_set(role_var, value)
-
-            # Remove "self" from the old counterpart:
-            old.send(getter = role.counterpart.getter).update(self, nil) if old
-
-            # Add "self" into the counterpart
-            value.send(getter ||= role.counterpart.getter).update(old, self) if value
-
-            if keys
-              keys.each do |key, entity|
-                entity.instance_index.refresh_key(key)
-              end
-            end
-
-            value
-          end
-        end
+	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)
+	  return value if old.equal?(value)         # Occurs during one_to_one assignment, for example
+
+	  # assert a new instance for the role value if necessary
+	  if value and o = role.counterpart.object_type and (!value.is_a?(o) || value.constellation != @constellation)
+	    value = @constellation.assert(o, *Array(value))
+	    return value if old.equal?(value)         # Occurs when another instance having the same value is assigned
+	  end
+
+	  dependent_entities = nil
+	  if (role.is_identifying)
+	    check_value_change_legality(role, value) if value
+
+	    if old && old.constellation
+	      # If our identity has changed and we identify others, prepare to reindex them
+	      dependent_entities = old.related_entities.map do |entity|
+		[entity.identifying_role_values, entity]
+	      end
+	    end
+	  end
+
+	  instance_variable_set(role_var, value)
+
+	  # Remove "self" from the old counterpart:
+	  old.send(getter = role.counterpart.getter).update(self, nil) if old
+
+	  @constellation.when_admitted do
+	    # REVISIT: Delay co-referencing here if the object is still a candidate
+	    # Add "self" into the counterpart
+	    value.send(getter ||= role.counterpart.getter).update(old, self) if value
+
+	    if dependent_entities
+	      dependent_entities.each do |key, entity|
+		entity.instance_index.refresh_key(key)
+	      end
+	    end
+	  end
+
+	  value
+	end
       end
 
       def define_many_to_one_accessor(role)
-        class_eval do
-          define_method role.getter do
-            role_var = role.variable
-            instance_variable_get(role_var) or
-              instance_variable_set(role_var, RoleValues.new)
-          end
+	define_method role.getter do
+	  role_var = role.variable
+	  instance_variable_get(role_var) or
+	    instance_variable_set(role_var, RoleValues.new)
         end
       end
 
@@ -375,7 +379,7 @@ module ActiveFacts
         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)
+        specified_class = related_name = options.delete(:class)
         case related_name
         when nil
           related = role_name # No :class provided, assume it matches the role_name
@@ -412,7 +416,7 @@ module ActiveFacts
 
         # Avoid a confusing mismatch:
         # Note that if you have a role "supervisor" and a sub-class "Supervisor", this'll bitch.
-        if (Class === related && (indicated = vocabulary.object_type(role_name)) && indicated != related)
+        if (!specified_class && Class === related && (indicated = vocabulary.object_type(role_name)) && indicated != related)
           raise "Role name #{role_name} indicates a different counterpart object_type #{indicated} than specified"
         end
 

data/lib/activefacts/api/role.rb

@@ -55,42 +55,13 @@ module ActiveFacts
         counterpart == nil
       end
 
-      def is_inherited?(klass)
-        klass.supertypes_transitive.include?(@object_type)
-      end
-
-      def counterpart_object_type
-        # This method is sometimes used when unaries are used in an entity's identifier.
-        @is_unary ? TrueClass : (counterpart ? counterpart.object_type : nil)
-      end
-
       def inspect
         "<Role #{object_type.name}.#{name}>"
       end
 
-      def adapt(constellation, value) #:nodoc:
-        # If the value is a compatible class, use it (if in another constellation, clone it),
-        # else create a compatible object using the value as constructor parameters.
-        if value.is_a?(counterpart.object_type)
-          # Check that the value is in a compatible constellation, clone if not:
-          if constellation && (vc = value.constellation) && vc != constellation
-            # Cross-constellation assignment!
-            # Just take the identifying_role_values to make a new object
-            value = constellation.send(value.class.basename, value.identifying_role_values)
-          end
-          value.constellation = constellation if constellation
-        else
-          value = [value] unless Array === value
-          raise "No parameters were provided to identify an #{counterpart.object_type.basename} instance" if value == []
-          if constellation
-            value = constellation.send(counterpart.object_type.basename.to_sym, *value)
-          else
-            #trace :assert, "Constructing new #{counterpart.object_type} with #{value.inspect}" do
-              value = counterpart.object_type.new(*value)
-            #end
-          end
-        end
-        value
+      def verbalise
+	"Role #{name} of #{object_type}, " +
+	  (@is_unary ? 'unary' : (counterpart ? 'played by' + counterpart.object_type : 'undefined'))
       end
 
     private

data/lib/activefacts/api/standard_types.rb

@@ -7,8 +7,8 @@
 # These extensions add ActiveFacts ObjectType and Instance behaviour into base Ruby value classes,
 # and allow any Class to become an Entity.
 #
-require 'date'
 require 'activefacts/api/numeric'
+require 'activefacts/api/date'
 require 'activefacts/api/guid'
 
 module ActiveFacts
@@ -16,6 +16,7 @@ module ActiveFacts
     # Adapter module to add value_type to all potential value classes
     module ValueClass #:nodoc:
       def value_type *args, &block #:nodoc:
+	# The inclusion of instance methods triggers ClassMethods to be included in the class too
         include ActiveFacts::API::Value
         value_type(*args, &block)
       end
@@ -29,22 +30,23 @@ ValueClasses.each{|c|
     c.send :extend, ActiveFacts::API::ValueClass
   }
 
+# Cannot subclass or delegate True, False or nil, so inject the required behaviour
 class TrueClass #:nodoc:
   def verbalise(role_name = nil); role_name ? "#{role_name}: true" : "true"; end
   def identifying_role_values; self; end
-  def self.identifying_role_values(*a); true; end
+  def self.identifying_role_values(*a); a.replace([{}]); true end
 end
 
 class FalseClass #:nodoc:
   def verbalise(role_name = nil); role_name ? "#{role_name}: false" : "false"; end
   def identifying_role_values; self; end
-  def self.identifying_role_values(*a); false; end
+  def self.identifying_role_values(*a); a.replace([{}]); false end
 end
 
 class NilClass #:nodoc:
   def verbalise; "nil"; end
   def identifying_role_values; self; end
-  def self.identifying_role_values(*a); nil; end
+  def self.identifying_role_values(*a); a.replace([{}]); nil end
 end
 
 class Class
@@ -52,6 +54,8 @@ class Class
   # The parameters are the names (Symbols) of the identifying roles.
   def identified_by *args, &b
     raise "#{basename} is not an entity type" if respond_to? :value_type  # Don't make a ValueType into an EntityType
+
+    # The inclusion of instance methods triggers ClassMethods to be included in the class too
     include ActiveFacts::API::Entity
     identified_by(*args, &b)
   end