activefacts-api 0.8.12 → 0.9.1

data/lib/activefacts/api/instance_index.rb

@@ -4,6 +4,9 @@
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
+
+require 'forwardable'
+
 module ActiveFacts
   module API
     #
@@ -12,6 +15,10 @@ module ActiveFacts
     # arguments (where ObjectType is the object_type name you're interested in)
     #
     class InstanceIndex
+      extend Forwardable
+      def_delegators :@hash, :size, :empty?, :each, :map,
+                     :detect, :values, :keys, :detect, :delete_if
+
       def initialize(constellation, klass)
         @constellation = constellation
         @klass = klass
@@ -22,44 +29,25 @@ 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)
-        #trace :assert, "Asserting #{@klass} with #{args.inspect}" do
-          instance, key = *@klass.assert_instance(@constellation, args)
-          instance
-        #end
+        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
-          key = @klass.identifying_role_values(*args)
+          key = @klass.identifying_role_values(*args) rescue nil
         end
-        return @hash[key]
-      end
-
-      def []=(key, value)   #:nodoc:
-        @hash[key] = value
-      end
-
-      def [](*args)
-        @hash[*args]
-      end
-
-      def size
-        @hash.size
-      end
-
-      def empty?
-        @hash.size == 0
-      end
-
-      def each &b
-        @hash.each &b
-      end
 
-      def map &b
-        @hash.map &b
+        @hash[key]
       end
 
       def detect &b
@@ -67,18 +55,28 @@ module ActiveFacts
         r ? r[1] : nil
       end
 
-      # Return an array of all the instances of this object_type
-      def values
-        @hash.values
+      def []=(key, value)   #:nodoc:
+        @hash[flatten_key(key)] = value
+      end
+
+      def [](key)
+        @hash[flatten_key(key)]
       end
 
-      # Return an array of the identifying role values arrays for all the instances of this object_type
-      def keys
-        @hash.keys
+      def refresh_key(key)
+        value = @hash.delete(key)
+        @hash[value.identifying_role_values] = value if value
       end
 
-      def delete_if(&b)   #:nodoc:
-        @hash.delete_if &b
+      private
+      def flatten_key(key)
+        if key.is_a?(Array)
+          key.map { |identifier| flatten_key(identifier) }
+        elsif key.respond_to?(:identifying_role_values)
+          key.identifying_role_values
+        else
+          key
+        end
       end
     end
   end

data/lib/activefacts/api/numeric.rb

@@ -10,79 +10,82 @@
 #
 require 'delegate'
 require 'date'
+require 'bigdecimal'
+
+module ActiveFacts
+  module API
+    # Fixes behavior of core functions over multiple platform
+    module SimpleDelegation
+      def initialize(v)
+        __setobj__(delegate_new(v))
+      end
 
-# It's not possible to subclass Integer, so instead we delegate to it.
-class Int < SimpleDelegator
-  def initialize(i = nil)               #:nodoc:
-    __setobj__(Integer(i))
-  end
+      def eql?(v)
+        # 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?(delegate_new(v))
+      end
 
-  def to_s                              #:nodoc:
-    __getobj__.to_s
-  end
+      def ==(o)                             #:nodoc:
+        __getobj__.==(o)
+      end
 
-  def to_json c = {}                    #:nodoc
-    __getobj__.to_json
-  end
+      def to_s *a                            #:nodoc:
+        __getobj__.to_s *a
+      end
 
-  def hash                              #:nodoc:
-    __getobj__.hash
-  end
+      def to_json(*a)                       #:nodoc:
+        __getobj__.to_s
+      end
 
-  def eql?(o)                           #:nodoc:
-    # 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 hash                              #:nodoc:
+        __getobj__.hash
+      end
 
-  def ==(o)                             #:nodoc:
-    __getobj__.==(o)
-  end
+      def is_a?(k)
+        __getobj__.is_a?(k) || super
+      end
 
-  def is_a?(k)
-    __getobj__.is_a?(k) || super
-  end
+      def kind_of?(k)
+        is_a?(k)
+      end
 
-  def inspect
-    "#{self.class.basename}:#{__getobj__.inspect}"
+      def inspect
+        "#{self.class.basename}:#{__getobj__.inspect}"
+      end
+    end
   end
 end
 
-# It's not possible to subclass Float, so instead we delegate to it.
-class Real < SimpleDelegator
-  def initialize(r = nil)                               #:nodoc:
-    __setobj__(Float(r))
-  end
+class Decimal < SimpleDelegator #:nodoc:
+  include ActiveFacts::API::SimpleDelegation
 
-  def hash                              #:nodoc:
-    __getobj__.hash
-  end
-
-  def to_s                              #:nodoc:
-    __getobj__.to_s
-  end
-
-  def to_json c = {}                    #:nodoc
-    __getobj__.to_json
+  def delegate_new(v)
+    if v.is_a?(BigDecimal) || v.is_a?(Bignum)
+      BigDecimal.new(v.to_s)
+    else
+      BigDecimal.new(v)
+    end
   end
+end
 
-  def eql?(o)                           #:nodoc:
-    # Note: See the note above on Int#eql?
-    __getobj__.eql?(Float(o))
-  end
+# It's not possible to subclass Integer, so instead we delegate to it.
+class Int < SimpleDelegator
+  include ActiveFacts::API::SimpleDelegation
 
-  def ==(o)                             #:nodoc:
-    __getobj__.==(o)
+  def delegate_new(i = nil)               #:nodoc:
+    Integer(i)
   end
+end
 
-  def is_a?(k)
-    __getobj__.is_a?(k) || super
-  end
+# It's not possible to subclass Float, so instead we delegate to it.
+class Real < SimpleDelegator
+  include ActiveFacts::API::SimpleDelegation
 
-  def inspect                           #:nodoc:
-    "#{self.class.basename}:#{__getobj__.inspect}"
+  def delegate_new(r = nil)               #:nodoc:
+    Float(r)
   end
 end
 
@@ -189,7 +192,10 @@ class AutoCounter
   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)
+      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

data/lib/activefacts/api/object_type.rb

@@ -46,7 +46,7 @@ module ActiveFacts
       #
       # Example: maybe :is_ceo
       def maybe(role_name)
-        realise_role(roles[role_name] = Role.new(self, nil, role_name))
+        realise_role(roles[role_name] = Role.new(self, TrueClass, role_name))
       end
 
       # Define a binary fact type relating this object_type to another,
@@ -61,6 +61,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)
         define_binary_fact_type(false, role_name, related, mandatory, related_role_name)
       end
 
@@ -77,9 +78,25 @@ 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)
         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]
+          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"
+            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"
+            end
+          end
+        end
+      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).
@@ -140,7 +157,7 @@ module ActiveFacts
 
       # Every new role added or inherited comes through here:
       def realise_role(role) #:nodoc:
-        if (!role.counterpart)
+        if (role.is_unary)
           # Unary role
           define_unary_role_accessor(role)
         elsif (role.unique)
@@ -229,22 +246,22 @@ module ActiveFacts
 
         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 value if old.equal?(value)         # Occurs when another instance having the same value is assigned
+            old = instance_variable_get(role.variable) rescue nil
+            return true if old.equal?(value)         # Occurs when another instance having the same value is assigned
 
-            value = role.adapt(constellation, value) if value
-            return value if old.equal?(value)         # Occurs when same value but not same instance 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
 
-            # 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
+            detect_inconsistencies(role, value)
 
-            instance_variable_set(role_var, 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
@@ -252,6 +269,12 @@ module ActiveFacts
             # 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
@@ -271,16 +294,13 @@ module ActiveFacts
             value = role.adapt(constellation, value) if value
             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.
+            detect_inconsistencies(role, value) if value
 
-            # This allows setting and clearing identifying roles, but not changing them.
-#            if role.is_identifying
-#              raise "#{self.class.basename}: illegal attempt to modify identifying role #{role.name}" if value != nil && old != nil
-#            end
+            if old && old.constellation
+              keys = old.related_entities.map do |entity|
+                [entity.identifying_role_values, entity]
+              end
+            end
 
             instance_variable_set(role_var, value)
 
@@ -290,6 +310,12 @@ module ActiveFacts
             # 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

data/lib/activefacts/api/role.rb

@@ -15,6 +15,7 @@ module ActiveFacts
     # Each ObjectType class maintains a RoleCollection hash of the roles it plays.
     class Role
       attr_reader   :object_type      # The ObjectType to which this role belongs
+      attr_reader   :is_unary
       attr_reader   :name             # The name of the role (a Symbol)
       attr_accessor :counterpart      # All roles except unaries have a counterpart Role
       attr_reader   :unique           # Is this role played by at most one instance, or more?
@@ -24,7 +25,8 @@ module ActiveFacts
 
       def initialize(object_type, counterpart, name, mandatory = false, unique = true)
         @object_type = object_type
-        @counterpart = counterpart
+        @is_unary = counterpart == TrueClass
+        @counterpart = @is_unary ? nil : counterpart
         @name = name
         @mandatory = mandatory
         @unique = unique
@@ -53,9 +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.
-        counterpart == nil ? TrueClass : counterpart.object_type
+        @is_unary ? TrueClass : (counterpart ? counterpart.object_type : nil)
       end
 
       def inspect

data/lib/activefacts/api/role_values.rb

@@ -4,44 +4,27 @@
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
-# There are two implementations here, one using an array and one using a hash.
-# The hash one has problems with keys being changed during object deletion, so
-# cannot be used yet; a fix is upcoming and will improve performance of large sets.
-#
+require 'forwardable'
+
 module ActiveFacts
   module API
 
     class RoleValues  #:nodoc:
       include Enumerable
+      extend Forwardable
+
+      def_delegators :@a, :each, :size, :empty?, :-
 
       def initialize
         @a = []
       end
 
-      def each &b
-        # REVISIT: Provide a configuration variable to enable this heckling during testing:
-        #@a.sort_by{rand}.each &b
-        @a.each &b
-      end
-
-      def size
-        @a.size
-      end
-
-      def empty?
-        @a.size == 0
-      end
-
       def +(a)
-        @a.+(a.is_a?(RoleValues) ? Array(a) : a)
-      end
-
-      def -(a)
-        @a - a
+        @a.+(a.is_a?(RoleValues) ? [a] : a)
       end
 
       def single
-        @a.size > 1 ? nil : @a[0]
+        size > 1 ? nil : @a[0]
       end
 
       def update(old, value)
@@ -50,9 +33,8 @@ module ActiveFacts
       end
 
       def verbalise
-        "["+@a.to_a.map{|e| e.verbalise}*", "+"]"
+        "[#{@a.map(&:verbalise).join(", ")}]"
       end
-
     end
 
   end