activefacts-api 1.9.5 → 1.9.6

data/lib/activefacts/api/date.rb

@@ -17,13 +17,13 @@ class ::Date
     elsif (a.size == 1)
       case a[0]
       when DateTime
-	d = civil(a[0].year, a[0].month, a[0].day, a[0].start)
+        d = civil(a[0].year, a[0].month, a[0].day, a[0].start)
       when Date
-	d = civil(a[0].year, a[0].month, a[0].day, a[0].start)
+        d = civil(a[0].year, a[0].month, a[0].day, a[0].start)
       when NilClass
-	d = civil()
+        d = civil()
       else
-	d = civil(*a, &b)
+        d = civil(*a, &b)
       end
     else
       d = civil(*a, &b)
@@ -42,13 +42,13 @@ class ::DateTime
     elsif (a.size == 1)
       case a[0]
       when DateTime
-	dt = civil(a[0].year, a[0].month, a[0].day, a[0].hour, a[0].min, a[0].sec, a[0].start)
+        dt = civil(a[0].year, a[0].month, a[0].day, a[0].hour, a[0].min, a[0].sec, a[0].start)
       when Date
-	dt = civil(a[0].year, a[0].month, a[0].day, 0, 0, 0, a[0].start)
+        dt = civil(a[0].year, a[0].month, a[0].day, 0, 0, 0, a[0].start)
       when NilClass
-	dt = civil()
+        dt = civil()
       else
-	dt = civil(*a, &b)
+        dt = civil(*a, &b)
       end
     else
       dt = civil(*a, &b)

data/lib/activefacts/api/entity.rb

@@ -26,38 +26,38 @@ module ActiveFacts
       # The identifying roles of secondary supertypes must also be assigned
       # here.
       def initialize(arg_hash)
-	raise ArgumentError.new("#{self}.new expects a hash. You should use assert instead anyhow") unless arg_hash.is_a?(Hash)
-        super(arg_hash)	# Initialise the Instance
-	initialize_existential_roles(self.class, arg_hash)
+        raise ArgumentError.new("#{self}.new expects a hash. You should use assert instead anyhow") unless arg_hash.is_a?(Hash)
+        super(arg_hash) # Initialise the Instance
+        initialize_existential_roles(self.class, arg_hash)
       end
 
       def initialize_existential_roles(klass, arg_hash)
-	# If overrides_identification_of, assign those attributes too (recursively)
-	if o = klass.overrides_identification_of
-	  initialize_existential_roles(o, arg_hash)
-	end
-
-	irns = klass.identifying_role_names
-	irns.each do |role_name|
-	  role = klass.all_role(role_name)
-	  key = arg_hash.delete(role_name)
-	  value =
-	    if key == nil
-	      nil
-	    elsif role.unary?
-	      (key && true)	# Preserve nil and false
-	    else
-	      role.counterpart.object_type.assert_instance(constellation, Array(key))
-	    end
-
-	  begin
-	    unless instance_variable_get(role.variable) != nil	# Not if it was set by a superclass identifier
-	      send(role.setter, value, ObjectType::CHECKED_IDENTIFYING_ROLE)
-	    end
-	  rescue NoMethodError => e
-	    raise settable_roles_exception(e, role_name)
-	  end
-	end
+        # If overrides_identification_of, assign those attributes too (recursively)
+        if o = klass.overrides_identification_of
+          initialize_existential_roles(o, arg_hash)
+        end
+
+        irns = klass.identifying_role_names
+        irns.each do |role_name|
+          role = klass.all_role(role_name)
+          key = arg_hash.delete(role_name)
+          value =
+            if key == nil
+              nil
+            elsif role.unary?
+              (key && true)     # Preserve nil and false
+            else
+              role.counterpart.object_type.assert_instance(constellation, Array(key))
+            end
+
+          begin
+            unless instance_variable_get(role.variable) != nil  # Not if it was set by a superclass identifier
+              send(role.setter, value, ObjectType::CHECKED_IDENTIFYING_ROLE)
+            end
+          rescue NoMethodError => e
+            raise settable_roles_exception(e, role_name)
+          end
+        end
       end
 
       # This exception is raised when an entity is instantiated before the
@@ -133,9 +133,9 @@ module ActiveFacts
       def identifying_role_values(klass = self.class)
         klass.identifying_roles.map do |role|
           value = send(role.name)
-	  counterpart_class = role.counterpart && role.counterpart.object_type
-	  value.identifying_role_values(counterpart_class)
-	end
+          counterpart_class = role.counterpart && role.counterpart.object_type
+          value.identifying_role_values(counterpart_class)
+        end
       end
 
       # Identifying role values in a hash form.
@@ -161,48 +161,48 @@ module ActiveFacts
       # class for each such instance.
       # This function is transitive!
       def analyse_impacts role
-	impacts = []
-
-	# Consider the object itself and all its supertypes
-	([self.class]+self.class.supertypes_transitive).map do |supertype|
-	  next unless supertype.identifying_roles.include?(role)
-
-	  old_key = identifying_role_values(supertype)
-	  # puts "Need to reindex #{self.class} as #{supertype} from #{old_key.inspect}"
-	  impacts << [supertype, self, old_key]
-	end
-
-	# Now consider objects whose identifiers include this object.
-	# Find our roles in those identifiers first.
-	impacted_roles = []
-	self.class.all_role_transitive.each do |n, role|
-	  if role.counterpart && role.counterpart.is_identifying
-	    # puts "Changing #{role.inspect} affects #{role.inspect}"
-	    impacted_roles << role
-	  end
-	end
-
-	impacted_roles.each do |role|
-	  affected_instances = Array(instance_variable_get(role.variable))
-	  # puts "considering #{affected_instances.size} #{role.object_type.name} instances that include #{role.inspect}: #{affected_instances.map(&:identifying_role_values).inspect}"
-	  affected_instances.each do |counterpart|
-	    impacts.concat(counterpart.analyse_impacts(role.counterpart))
-	  end
-	end
-	impacts
+        impacts = []
+
+        # Consider the object itself and all its supertypes
+        ([self.class]+self.class.supertypes_transitive).map do |supertype|
+          next unless supertype.identifying_roles.include?(role)
+
+          old_key = identifying_role_values(supertype)
+          # puts "Need to reindex #{self.class} as #{supertype} from #{old_key.inspect}"
+          impacts << [supertype, self, old_key]
+        end
+
+        # Now consider objects whose identifiers include this object.
+        # Find our roles in those identifiers first.
+        impacted_roles = []
+        self.class.all_role_transitive.each do |n, role|
+          if role.counterpart && role.counterpart.is_identifying
+            # puts "Changing #{role.inspect} affects #{role.inspect}"
+            impacted_roles << role
+          end
+        end
+
+        impacted_roles.each do |role|
+          affected_instances = Array(instance_variable_get(role.variable))
+          # puts "considering #{affected_instances.size} #{role.object_type.name} instances that include #{role.inspect}: #{affected_instances.map(&:identifying_role_values).inspect}"
+          affected_instances.each do |counterpart|
+            impacts.concat(counterpart.analyse_impacts(role.counterpart))
+          end
+        end
+        impacts
       end
 
       def apply_impacts impacts
-	impacts.each do |klass, entity, old_key|
-	  instance_index = entity.constellation.instances[klass]
-	  new_key = entity.identifying_role_values(klass)
-	  # puts "Reindexing #{klass} from #{old_key.inspect} to #{new_key.inspect}"
-
-	  if new_key != old_key
-	    instance_index.delete(old_key)
-	    instance_index[new_key] = entity
-	  end
-	end
+        impacts.each do |klass, entity, old_key|
+          instance_index = entity.constellation.instances[klass]
+          new_key = entity.identifying_role_values(klass)
+          # puts "Reindexing #{klass} from #{old_key.inspect} to #{new_key.inspect}"
+
+          if new_key != old_key
+            instance_index.delete(old_key)
+            instance_index[new_key] = entity
+          end
+        end
       end
 
       # If this instance's role is updated to the new value, does that cause a collision?
@@ -210,22 +210,22 @@ module ActiveFacts
       def check_identification_change_legality(role, value)
         return unless @constellation && role.is_identifying
 
-	klasses = [self.class] + self.class.supertypes_transitive
-	last_identity = nil
-	last_irns = nil
-	counterpart_class = role.counterpart ? role.counterpart.object_type : value.class
+        klasses = [self.class] + self.class.supertypes_transitive
+        last_identity = nil
+        last_irns = nil
+        counterpart_class = role.counterpart ? role.counterpart.object_type : value.class
         duplicate = klasses.detect do |klass|
           next false unless klass.identifying_roles.include?(role)
-	  irns = klass.identifying_role_names
-	  if last_irns != irns
-	    last_identity = identifying_role_values(klass)
-	    role_position = irns.index(role.name)
-	    last_identity[role_position] = value.identifying_role_values(counterpart_class)
-	  end
-	  @constellation.instances[klass][last_identity]
+          irns = klass.identifying_role_names
+          if last_irns != irns
+            last_identity = identifying_role_values(klass)
+            role_position = irns.index(role.name)
+            last_identity[role_position] = value.identifying_role_values(counterpart_class)
+          end
+          @constellation.instances[klass][last_identity]
         end
 
-	raise DuplicateIdentifyingValueException.new(self.class, role.name, value) if duplicate
+        raise DuplicateIdentifyingValueException.new(self.class, role.name, value) if duplicate
       end
 
       # All classes that become Entity types receive the methods of this class as class methods:
@@ -249,7 +249,7 @@ module ActiveFacts
           @identifying_roles ||=
             identifying_role_names.map do |role_name|
               role = all_role[role_name] || find_inherited_role(role_name)
-	      raise "Illegal request for identifying_roles of #{self} before they're all defined" if role == false
+              raise "Illegal request for identifying_roles of #{self} before they're all defined" if role == false
               role
             end.freeze
         end
@@ -264,154 +264,154 @@ module ActiveFacts
           end
         end
 
-	def check_supertype_identifiers_match instance, arg_hash
-	  supertypes_transitive.each do |supertype|
-	    supertype.identifying_roles.each do |role|
-	      next unless arg_hash.include?(role.name)	  # No contradiction here
-	      new_value = arg_hash[role.name]
-	      existing_value = instance.send(role.name.to_sym)
-
-	      # Quick check for an exact match:
-	      counterpart_class = role.counterpart && role.counterpart.object_type
-	      next if existing_value == new_value or existing_value.identifying_role_values(counterpart_class) == new_value
-
-	      # Coerce the new value to identifying values for the counterpart role's type:
-	      role = supertype.all_role(role.name)
-	      new_key = role.counterpart.object_type.identifying_role_values(instance.constellation, [new_value])
-	      next if existing_value == new_key	  # This can happen when the counterpart is a value type
-
-	      existing_key = existing_value.identifying_role_values(counterpart_class)
-	      next if existing_key == new_key
-	      raise TypeConflictException.new(basename, supertype, new_key, existing_key)
-	    end
-	  end
-	end
-
-	# all its candidate keys must match those from the arg_hash.
-	def check_no_supertype_instance_exists constellation, arg_hash
-	  supertypes_transitive.each do |supertype|
-	    key = supertype.identifying_role_values(constellation, [arg_hash])
-	    if constellation.instances[supertype][key]
-	      raise TypeMigrationException.new(basename, supertype, key)
-	    end
-	  end
-	end
-
-	# This method receives an array (possibly including a trailing arguments hash)
-	# from which the values of identifying roles must be coerced. Note that when a
-	# value which is not the corrent class is received, we recurse to ask that class
-	# to coerce what we *do* have.
-	# The return value is an array of (and arrays of) raw values, not object instances.
-	#
-	# No new instances may be asserted, nor may any roles of objects in the constellation be changed
-	def identifying_role_values(constellation, args)
+        def check_supertype_identifiers_match instance, arg_hash
+          supertypes_transitive.each do |supertype|
+            supertype.identifying_roles.each do |role|
+              next unless arg_hash.include?(role.name)    # No contradiction here
+              new_value = arg_hash[role.name]
+              existing_value = instance.send(role.name.to_sym)
+
+              # Quick check for an exact match:
+              counterpart_class = role.counterpart && role.counterpart.object_type
+              next if existing_value == new_value or existing_value.identifying_role_values(counterpart_class) == new_value
+
+              # Coerce the new value to identifying values for the counterpart role's type:
+              role = supertype.all_role(role.name)
+              new_key = role.counterpart.object_type.identifying_role_values(instance.constellation, [new_value])
+              next if existing_value == new_key   # This can happen when the counterpart is a value type
+
+              existing_key = existing_value.identifying_role_values(counterpart_class)
+              next if existing_key == new_key
+              raise TypeConflictException.new(basename, supertype, new_key, existing_key)
+            end
+          end
+        end
+
+        # all its candidate keys must match those from the arg_hash.
+        def check_no_supertype_instance_exists constellation, arg_hash
+          supertypes_transitive.each do |supertype|
+            key = supertype.identifying_role_values(constellation, [arg_hash])
+            if constellation.instances[supertype][key]
+              raise TypeMigrationException.new(basename, supertype, key)
+            end
+          end
+        end
+
+        # This method receives an array (possibly including a trailing arguments hash)
+        # from which the values of identifying roles must be coerced. Note that when a
+        # value which is not the corrent class is received, we recurse to ask that class
+        # to coerce what we *do* have.
+        # The return value is an array of (and arrays of) raw values, not object instances.
+        #
+        # No new instances may be asserted, nor may any roles of objects in the constellation be changed
+        def identifying_role_values(constellation, args)
           irns = identifying_role_names
 
-	  # Normalise positional arguments into an arguments hash (this changes the passed parameter)
-	  arg_hash = args[-1].is_a?(Hash) ? args.pop : {}
+          # Normalise positional arguments into an arguments hash (this changes the passed parameter)
+          arg_hash = args[-1].is_a?(Hash) ? args.pop : {}
 
-	  # If the first parameter is an object of type self, its
-	  # identifying roles provide any values missing from the array/hash.
-	  if args[0].is_a?(self)
-	    proto = args.shift
-	  end
+          # If the first parameter is an object of type self, its
+          # identifying roles provide any values missing from the array/hash.
+          if args[0].is_a?(self)
+            proto = args.shift
+          end
 
-	  # Following arguments provide identifying values in sequence; put them into the hash:
-	  irns.each do |role_name|
-	    break if args.size == 0
-	    arg_hash[role_name] = args.shift
-	  end
+          # Following arguments provide identifying values in sequence; put them into the hash:
+          irns.each do |role_name|
+            break if args.size == 0
+            arg_hash[role_name] = args.shift
+          end
 
-	  # Complain if we have left-over arguments
-	  if args.size > 0
+          # Complain if we have left-over arguments
+          if args.size > 0
             raise UnexpectedIdentifyingValueException.new(self, irns, args)
-	  end
-
-	  # The arg_hash will be used to construct a new instance, if necessary
-	  args.push(arg_hash)
-
-	  irns.map do |role_name|
-	    all_role(role_name)
-	  end.map do |role|
-	    if arg_hash.include?(n = role.name)	  # Do it this way to avoid problems where nil or false is provided
-	      value = arg_hash[n]
-	      next (value && true) if (role.unary?)
-	      if value
-		klass = role.counterpart.object_type
-		value = klass.identifying_role_values(constellation, Array(value))
-	      end
-	    elsif proto
-	      value = proto.send(n)
-	      counterpart_class = role.counterpart && role.counterpart.object_type
-	      value = value.identifying_role_values(counterpart_class)
-	      arg_hash[n] = value # Save the value for making a new instance
-	      next value if (role.unary?)
-	    else
-	      value = nil
-	    end
-
-	    raise MissingMandatoryRoleValueException.new(self, role) if value.nil? && role.mandatory
-
-	    value
-	  end
-	end
-
-	def assert_instance(constellation, args)
-	  key = identifying_role_values(constellation, args)
-
-	  # The args is now normalized to an array containing a single Hash element
-	  arg_hash = args[-1]
-
-	  # Find or make an instance of the class:
+          end
+
+          # The arg_hash will be used to construct a new instance, if necessary
+          args.push(arg_hash)
+
+          irns.map do |role_name|
+            all_role(role_name)
+          end.map do |role|
+            if arg_hash.include?(n = role.name)   # Do it this way to avoid problems where nil or false is provided
+              value = arg_hash[n]
+              next (value && true) if (role.unary?)
+              if value
+                klass = role.counterpart.object_type
+                value = klass.identifying_role_values(constellation, Array(value))
+              end
+            elsif proto
+              value = proto.send(n)
+              counterpart_class = role.counterpart && role.counterpart.object_type
+              value = value.identifying_role_values(counterpart_class)
+              arg_hash[n] = value # Save the value for making a new instance
+              next value if (role.unary?)
+            else
+              value = nil
+            end
+
+            raise MissingMandatoryRoleValueException.new(self, role) if value.nil? && role.mandatory
+
+            value
+          end
+        end
+
+        def assert_instance(constellation, args)
+          key = identifying_role_values(constellation, args)
+
+          # The args is now normalized to an array containing a single Hash element
+          arg_hash = args[-1]
+
+          # Find or make an instance of the class:
           instance_index = constellation.instances[self]   # All instances of this class in this constellation
-	  instance = constellation.has_candidate(self, key) || instance_index[key]
-	  if (instance)
-	    # Check that all assertions about supertype keys are non-contradictory
-	    check_supertype_identifiers_match(instance, arg_hash)
-	  else
-	    # Check that no instance of any supertype matches the keys given
-	    check_no_supertype_instance_exists(constellation, arg_hash)
-
-	    instance = new_instance(constellation, arg_hash)
-	    constellation.candidate(instance)
-	  end
-
-	  # Assign any extra roles that may have been passed.
-	  # An exception here leaves the object indexed,
-	  # but without the offending role (re-)assigned.
-	  arg_hash.each do |k, v|
-	    role = instance.class.all_role(k)
-	    unless role.is_identifying && role.object_type == self
-	      value =
-		if v == nil
-		  nil
-		elsif role.unary?
-		  (v && true)	# Preserve nil and false
-		else
-		  role.counterpart.object_type.assert_instance(constellation, Array(v))
-		end
-	      constellation.when_admitted {
-		instance.send(:"#{k}=", value)
-	      }
-	    end
-	  end
-
-	  instance
-	end
+          instance = constellation.has_candidate(self, key) || instance_index[key]
+          if (instance)
+            # Check that all assertions about supertype keys are non-contradictory
+            check_supertype_identifiers_match(instance, arg_hash)
+          else
+            # Check that no instance of any supertype matches the keys given
+            check_no_supertype_instance_exists(constellation, arg_hash)
+
+            instance = new_instance(constellation, arg_hash)
+            constellation.candidate(instance)
+          end
+
+          # Assign any extra roles that may have been passed.
+          # An exception here leaves the object indexed,
+          # but without the offending role (re-)assigned.
+          arg_hash.each do |k, v|
+            role = instance.class.all_role(k)
+            unless role.is_identifying && role.object_type == self
+              value =
+                if v == nil
+                  nil
+                elsif role.unary?
+                  (v && true)   # Preserve nil and false
+                else
+                  role.counterpart.object_type.assert_instance(constellation, Array(v))
+                end
+              constellation.when_admitted {
+                instance.send(:"#{k}=", value)
+              }
+            end
+          end
+
+          instance
+        end
 
         def index_instance(constellation, instance) #:nodoc:
-	  # Index the instance in the constellation's InstanceIndex for this class:
-	  instance_index = constellation.instances[self]
-	  key = instance.identifying_role_values(self)
-	  instance_index[key] = instance
+          # Index the instance in the constellation's InstanceIndex for this class:
+          instance_index = constellation.instances[self]
+          key = instance.identifying_role_values(self)
+          instance_index[key] = instance
 
           # Index the instance for each supertype:
-	  supertypes.each do |supertype|
-	    supertype.index_instance(constellation, instance)
-	  end
+          supertypes.each do |supertype|
+            supertype.index_instance(constellation, instance)
+          end
 
-	  instance
-	end
+          instance
+        end
 
         # A object_type that isn't a ValueType must have an identification scheme,
         # which is a list of roles it plays. The identification scheme may be
@@ -419,7 +419,7 @@ module ActiveFacts
         def identified_by(*args) #:nodoc:
           options = (args[-1].is_a?(Hash) ? args.pop : {})
           options.each do |key, value|
-	    raise UnrecognisedOptionsException.new('EntityType', basename, key) unless respond_to?(key)
+            raise UnrecognisedOptionsException.new('EntityType', basename, key) unless respond_to?(key)
             send(key, value)
           end
 
@@ -444,7 +444,7 @@ module ActiveFacts
         def inherited(other) #:nodoc:
           other.identification_inherited_from = self
           subtypes << other unless subtypes.include? other
-	  TypeInheritanceFactType.new(self, other)
+          TypeInheritanceFactType.new(self, other)
           vocabulary.__add_object_type(other)
         end
 
@@ -457,12 +457,12 @@ module ActiveFacts
       def self.included other #:nodoc:
         other.send :extend, ClassMethods
 
-	def other.new_instance constellation, *args
-	  instance = allocate
-	  instance.instance_variable_set(@@constellation_variable_name ||= "@constellation", constellation)
-	  instance.send(:initialize, *args)
-	  instance
-	end
+        def other.new_instance constellation, *args
+          instance = allocate
+          instance.instance_variable_set(@@constellation_variable_name ||= "@constellation", constellation)
+          instance.send(:initialize, *args)
+          instance
+        end
 
         # Register ourselves with the parent module, which has become a Vocabulary:
         vocabulary = other.modspace