activefacts-api 0.9.3 → 0.9.4

data/lib/activefacts/api/exceptions.rb

@@ -34,11 +34,26 @@ module ActiveFacts
     end
 
     class DuplicateIdentifyingValueException < ActiveFactsRuntimeException
-      def initialize(desc)
-        super("Illegal attempt to assert #{desc[:class].basename} having identifying value" +
-              " (#{desc[:role].name} is #{desc[:value].verbalise})," +
-              " when #{desc[:value].related_entities.map(&:verbalise).join(", ")} already exists")
+      def initialize(klass, role_name, value)
+        super("Illegal attempt to assert #{klass.basename} having identifying value" +
+              " (#{role_name} is #{value.verbalise})," +
+              " when #{value.related_entities(false).map(&:verbalise).join(", ")} already exists")
       end
     end
+
+    # When an existing object having multiple identification patterns is re-asserted, all the keys must match the existing object
+    class TypeConflictException < ActiveFactsRuntimeException
+      def initialize(klass, supertype, key, existing)
+	super "#{klass} cannot be asserted to have #{supertype} identifier #{key.inspect} because the existing object has #{existing.inspect}"
+      end
+    end
+
+    # When a new entity is asserted, but a supertype identifier matches an existing object of a different type, type migration is implied but unfortunately is impossible in Ruby
+    class TypeMigrationException < ActiveFactsRuntimeException
+      def initialize(klass, supertype, key)
+	super "#{klass} cannot be asserted due to the prior existence of a conflicting #{supertype} identified by #{key.inspect}"
+      end
+    end
+
   end
 end

data/lib/activefacts/api/guid.rb

@@ -1,5 +1,4 @@
 require 'delegate'
-require 'date'
 require 'securerandom'
 
 unless defined? SecureRandom.uuid
@@ -30,6 +29,10 @@ class Guid
     @value == value
   end
 
+  def == value
+    @value == value.to_s
+  end
+
   def inspect
     "\#<Guid #{@value}>"
   end
@@ -42,16 +45,4 @@ class Guid
     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
-#      if args.size == 1
-#        return args[0] if args[0].is_a?(AutoCounter)
-#        return args[0].send(self.basename.snakecase.to_sym) if args[0].respond_to?(self.basename.snakecase.to_sym)
-#      end
-#      return new(*args)
-#    end
-#    super
-#  end
-
 end

data/lib/activefacts/api/instance.rb

@@ -11,12 +11,16 @@ module ActiveFacts
     # Every Instance of a ObjectType (A Value type or an Entity type) includes the methods of this module:
     module Instance
       # What constellation does this Instance belong to (if any):
-      attr_accessor :constellation
+      attr_reader :constellation
 
       def initialize(args = []) #:nodoc:
         unless (self.class.is_entity_type)
           begin
             super(*args)
+	  rescue TypeError => e
+	    if trace(:debug)
+	      p e; puts e.backtrace*"\n\t"; debugger; true
+	    end
           rescue ArgumentError => e
             e.message << " constructing a #{self.class}"
             raise
@@ -24,125 +28,83 @@ module ActiveFacts
         end
       end
 
-      # Detect inconsistencies within constellation if this entity was updated
-      # with the specified role/value pair.
-      def detect_inconsistencies(role, value)
-        if duplicate_identifying_values?(role, value)
-          exception_data = {
-            :value => value,
-            :role  => role,
-            :class => self.class
-          }
-
-          raise DuplicateIdentifyingValueException.new(exception_data)
-        end
+      def is_a? klass
+        super || self.class.supertypes_transitive.include?(klass)
       end
 
-      # Checks if instance have duplicate values within its constellation.
-      #
-      # Only works on identifying roles.
-      def duplicate_identifying_values?(role, value)
-        @constellation && role.is_identifying && !is_unique?(:role => role, :value => value)
-      end
-
-      # Checks if instance would still be unique if it was updated with
-      # args.
-      #
-      # args should be a hash containing the role and value to update
-      # and the name of the identifying value as the key.
-      #
-      # For example, if a Person is identified by name and family_name:
-      # updated_values = { :name => "John" }
-      # Would merge this hash with the one defining the current instance
-      # and verify in our constellation if it exists.
-      #
-      # The uniqueness of the entity will also be checked within its supertypes.
-      #
-      # An Employee -subtype of a Person- identified by its employee_id would
-      # collide with a Person if it has the same name. But `name` may not be
-      # an identifying value for the Employee identification scheme.
-      def is_unique?(args)
-        duplicate = ([self.class] + self.class.supertypes_transitive).detect do |klass|
-          old_identity = identity_by(klass)
-          if klass.identifying_roles.include?(args[:role])
-            new_identity = old_identity.merge(args[:role].getter => args[:value])
-            @constellation.instances[klass].include?(new_identity)
-          else
-            false
-          end
+      # If this instance's role is updated to the new value, does that cause a collision?
+      # We need to check each superclass that has a different identification pattern
+      def check_value_change_legality(role, value)
+        return unless @constellation && role.is_identifying
+
+	klasses = [self.class] + self.class.supertypes_transitive
+	last_identity = nil
+	last_irns = nil
+        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
+	  end
+	  @constellation.instances[klass][last_identity]
         end
 
-        !duplicate
+	raise DuplicateIdentifyingValueException.new(self.class, role.name, value) if duplicate
       end
 
-      # List entities which reference the current one.
-      #
-      # Once an entity is found, it will also search for
-      # related entities of this instance.
-      def related_entities(instances = [])
+      # List entities which have an identifying role played by this object.
+      def related_entities(indirectly = true, instances = [])
+	# Check all roles of this instance
         self.class.roles.each do |role_name, role|
-          instance_index_counterpart(role).each do |irv, instance|
-            if instance.class.is_entity_type && instance.is_identified_by?(self)
-              if !instances.include?(instance)
-                instances << instance
-                instance.related_entities(instances)
-              end
-            end
-          end
+	  # If the counterpart role is not identifying for its object type, skip it
+	  next unless c = role.counterpart and c.is_identifying
+
+	  identified_instances = Array(self.send(role.getter))
+	  instances.concat(identified_instances)
+	  identified_instances.each do |instance|
+	    instance.related_entities(indirectly, instances) if indirectly
+	  end
         end
         instances
       end
 
-      # Determine if entity is an identifying value
-      # of the current instance.
-      def is_identified_by?(entity)
-        self.class.identifying_roles.detect do |role|
-          send(role.getter) == entity
-        end
-      end
-
       def instance_index
         @constellation.send(self.class.basename.to_sym)
       end
 
-      def instance_index_counterpart(role)
-        if @constellation && role.counterpart
-          @constellation.send(role.counterpart.object_type.basename.to_sym)
-        else
-          []
-        end
-      end
-
-      # Verbalise this instance
-      # REVISIT: Should it raise an error if it was not redefined ?
-      def verbalise
-        # REVISIT: Should it raise an error if it was not redefined ?
-        # This method should always be overridden in subclasses
-      end
-
       # De-assign all functional roles and remove from constellation, if any.
       def retract
-        # Delete from the constellation first, while it remembers our identifying role values
-        @constellation.__retract(self) if @constellation
+        # Delete from the constellation first, while we remember our identifying role values
+        @constellation.deindex_instance(self) if @constellation
 
         # Now, for all roles (from this class and all supertypes), assign nil to all functional roles
         # The counterpart roles get cleared automatically.
-        ([self.class]+self.class.supertypes_transitive).each do |klass|
+	klasses = [self.class]+self.class.supertypes_transitive
+	klasses.each do |klass|
           klass.roles.each do |role_name, role|
             next if role.unary?
             counterpart = role.counterpart
-            if role.unique
-              # puts "Nullifying mandatory role #{role.name} of #{role.object_type.name}" if counterpart.mandatory
 
-              send role.setter, nil
+	    # Objects being created do not have to have non-identifying mandatory roles,
+	    # so we allow retracting to the same state.
+            if role.unique
+	      if counterpart.is_identifying && counterpart.mandatory
+		i = send(role.name) and i.retract
+	      else
+		send role.setter, nil
+	      end
             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|
-                if counterpart.is_identifying
-                  v.retract
+	      counterpart_instances = send(role.name)
+	      counterpart_instances.to_a.each do |counterpart_instance|
+		# These actions deconstruct the RoleValues as we go:
+                if counterpart.is_identifying && counterpart.mandatory
+                  counterpart_instance.retract
                 else
-                  v.send(counterpart.setter, nil)
+                  counterpart_instance.send(counterpart.setter, nil)
                 end
               end
             end
@@ -155,7 +117,7 @@ module ActiveFacts
         # Add Instance class methods here
       end
 
-      def Instance.included other #:nodoc:
+      def self.included other #:nodoc:
         other.send :extend, ClassMethods
       end
     end

data/lib/activefacts/api/instance_index.rb

@@ -17,7 +17,7 @@ module ActiveFacts
     class InstanceIndex
       extend Forwardable
       def_delegators :@hash, :size, :empty?, :each, :map,
-                     :detect, :values, :keys, :detect, :delete_if
+                     :detect, :values, :keys, :detect, :delete
 
       def initialize(constellation, klass)
         @constellation = constellation
@@ -29,37 +29,6 @@ module ActiveFacts
         "<InstanceIndex for #{@klass.name} in #{@constellation.inspect}>"
       end
 
-      # Assertion of an entity type or a value type
-      #
-      # When asserting an entity type, multiple entity type or value type
-      # may be created. Every instance (entity or value) created in this
-      # process will be removed if the entity type fail to be asserted.
-      def assert(*args)
-        instance, key = *@klass.assert_instance(@constellation, args)
-        @klass.created_instances = nil if instance.class.is_entity_type
-        instance
-      end
-
-      def include?(*args)
-        if args.size == 1 && args[0].is_a?(@klass)
-          key = args[0].identifying_role_values
-        else
-          begin
-            key = @klass.identifying_role_values(*args)
-          rescue TypeError => e
-            # This happens (and should not) during assert_instance when checking
-            # for new asserts of identifying values that might get rolled back
-            # when the assert fails (for example because of an implied subtyping change)
-            key = nil
-          rescue ActiveFactsRuntimeException => e
-            # This is currently only known to happen during a retract()
-            key = nil
-          end
-        end
-
-        @hash[key]
-      end
-
       def detect &b
         r = @hash.detect &b
         r ? r[1] : nil

data/lib/activefacts/api/numeric.rb

@@ -1,6 +1,6 @@
 #
 #       ActiveFacts Runtime API
-#       Numeric and Date delegates and hacks to handle immediate types.
+#       Numeric delegates and hacks to handle immediate types.
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
@@ -9,7 +9,6 @@
 # Date and DateTime don't have a sensible new() method, so we monkey-patch one here.
 #
 require 'delegate'
-require 'date'
 require 'bigdecimal'
 
 module ActiveFacts
@@ -89,57 +88,50 @@ class Real < SimpleDelegator
   end
 end
 
-# A Date can be constructed from any Date subclass, not just using the normal date constructors.
-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)
-    if (a.size == 1 && a[0].is_a?(Date))
-      a = a[0]
-      civil(a.year, a.month, a.day, a.start)
-    elsif (a.size == 1 && a[0].is_a?(String))
-      parse(a[0])
-    else
-      a = [] if a == [nil]
-      civil(*a, &b)
-    end
-  end
-end
-
-# A DateTime can be constructed from any Date or DateTime subclass
-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)
-    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, 0, 0, 0, a.start)
-      else
-        civil(*a, &b)
-      end
-    else
-      civil(*a, &b)
-    end
-  end
-end
-
 # The AutoCounter class is an integer, but only after the value
 # has been established in the database.
 # Construct it with the value :new to get an uncommitted value.
 # You can use this new instance as a value of any role of this type, including to identify an entity instance.
 # The assigned value will be filled out everywhere it needs to be, upon save.
+module ActiveFacts
+  module AutoCounterClass
+    def identifying_role_values(constellation, args)
+      arg_hash = args[-1].is_a?(Hash) ? args.pop : {}
+      n = 
+	case
+	when args == [:new]	# A new object has no identifying_role_values
+	  :new
+	when args.size == 1 && args[0].is_a?(AutoCounter)
+	  args[0]		# An AutoCounter is its own key
+	else
+	  new(*args)
+	end
+      args.replace([arg_hash])
+      n
+    end
+  end
+end
+
 class AutoCounter
+  attr_reader :place_holder_number
   def initialize(i = :new)
-    raise "AutoCounter #{self.class} may not be #{i.inspect}" unless i == :new or i.is_a?(Integer) or i.is_a?(AutoCounter)
-    @@placeholder ||= 0
-    if i == :new
+    unless i == :new or i.is_a?(Integer) or i.is_a?(AutoCounter)
+      raise "AutoCounter #{self.class} may not be #{i.inspect}"
+    end
+    @@place_holder ||= 0
+    case i
+    when :new
       @value = nil
-      @initially = (@@placeholder+=1)
+      @place_holder_number = (@@place_holder+=1)
+    when AutoCounter
+      if i.defined?
+	@value = i.to_i
+      else
+	@place_holder_number = i.place_holder_number
+	@value = nil
+      end
     else
-      @initially = @value = i.to_i;
+      @place_holder_number = @value = i.to_i;
     end
   end
 
@@ -158,7 +150,7 @@ class AutoCounter
     if self.defined?
       @value.to_s 
     else
-      "new_#{@initially}"
+      "new_#{@place_holder_number}"
     end
   end
 
@@ -169,13 +161,17 @@ class AutoCounter
 
   # An AutoCounter may only be used in numeric expressions after a definite value has been assigned
   def to_i
-    raise ArgumentError, "Illegal attempt to get integer value of an uncommitted AutoCounter" unless @value
+    unless @value
+      raise ArgumentError, "Illegal attempt to get integer value of an uncommitted AutoCounter"
+    end
     @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
+    unless @value
+      raise ArgumentError, "Illegal attempt to use the value of an uncommitted AutoCounter"
+    end
     [ i.to_i, @value ]
   end
 
@@ -187,7 +183,7 @@ class AutoCounter
     if self.defined?
       @value.hash
     else
-      0
+      @place_holder_number
     end
   end
 
@@ -195,14 +191,14 @@ class AutoCounter
     to_s.eql?(o.to_s)
   end
 
+  def identifying_role_values
+    self
+  end
+
+#  extend ActiveFacts::AutoCounterClass
   def self.inherited(other)             #:nodoc:
-    def other.identifying_role_values(*args)
-      return nil if args == [:new]  # A new object has no identifying_role_values
-      if args.size == 1
-        return args[0] if args[0].is_a?(AutoCounter)
-        return args[0].send(self.basename.snakecase.to_sym) if args[0].respond_to?(self.basename.snakecase.to_sym)
-      end
-      return new(*args)
+    other.class_eval do
+      extend ActiveFacts::AutoCounterClass
     end
     super
   end