activefacts-api 1.9.5 → 1.9.6

data/lib/activefacts/api/exceptions.rb

@@ -23,31 +23,31 @@ module ActiveFacts
 
     class InvalidEntityException < SchemaException
       def initialize klass
-	super "#{klass.basename} may not be an entity type"
+        super "#{klass.basename} may not be an entity type"
       end
     end
 
     class InvalidIdentificationException < SchemaException
       def initialize object_type, role, is_single
-	msg =
-	  if is_single
-	    "#{object_type} has a single identifying role '#{role}' which is has_one, but must be one_to_one"
-	  else
-	    "#{object_type} has an identifying role '#{role}' which is one_to_one, but must be has_one"
-	  end
-	super msg
+        msg =
+          if is_single
+            "#{object_type} has a single identifying role '#{role}' which is has_one, but must be one_to_one"
+          else
+            "#{object_type} has an identifying role '#{role}' which is one_to_one, but must be has_one"
+          end
+        super msg
       end
     end
 
     class MissingIdentificationException < SchemaException
       def initialize klass
-	super "You must list the roles which will identify #{klass.basename}"
+        super "You must list the roles which will identify #{klass.basename}"
       end
     end
 
     class InvalidObjectType < SchemaException
       def initialize vocabulary, klass, reason
-	super "A constellation over #{vocabulary.name} cannot index instances of #{klass} because it #{reason}"
+        super "A constellation over #{vocabulary.name} cannot index instances of #{klass} because it #{reason}"
       end
     end
 
@@ -71,7 +71,7 @@ module ActiveFacts
 
     class UnexpectedIdentifyingValueException < RuntimeException
       def initialize object_type, identifying_role_names, extra_args
-	super "#{object_type.basename} expects only (#{identifying_role_names*', '}) for its identifier, but you provided additional values #{extra_args.inspect}"
+        super "#{object_type.basename} expects only (#{identifying_role_names*', '}) for its identifier, but you provided additional values #{extra_args.inspect}"
       end
     end
 
@@ -92,14 +92,14 @@ module ActiveFacts
     # When an existing object having multiple identification patterns is re-asserted, all the keys must match the existing object
     class TypeConflictException < RuntimeException
       def initialize(klass, supertype, key, existing)
-	super "#{klass} cannot be asserted to have #{supertype} identifier #{key.inspect} because the existing object has #{existing.inspect}"
+        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 < RuntimeException
       def initialize(klass, supertype, key)
-	super "#{klass} cannot be asserted due to the prior existence of a conflicting #{supertype} identified by #{key.inspect}"
+        super "#{klass} cannot be asserted due to the prior existence of a conflicting #{supertype} identified by #{key.inspect}"
       end
     end
 

data/lib/activefacts/api/fact_type.rb

@@ -13,7 +13,7 @@ module ActiveFacts
       # invariant { self.all_role.each {|role| self.is_a?(ObjectifiedFactType) ? role.counterpart.object_type == self.objectified_as : role.fact_type == self } }
 
       def initialize
-	@all_role ||= []
+        @all_role ||= []
       end
     end
 
@@ -30,11 +30,11 @@ module ActiveFacts
       attr_reader :supertype_role, :subtype_role
     
       def initialize(supertype, subtype)
-	super()
+        super()
 
-	# The supertype role is not mandatory, but the subtype role is. Both are unique.
-	@supertype_role = Role.new(self, supertype, subtype.name.gsub(/.*::/,'').to_sym, false, true)
-	@subtype_role = Role.new(self, subtype, supertype.name.gsub(/.*::/,'').to_sym, true, true)
+        # The supertype role is not mandatory, but the subtype role is. Both are unique.
+        @supertype_role = Role.new(self, supertype, subtype.name.gsub(/.*::/,'').to_sym, false, true)
+        @subtype_role = Role.new(self, subtype, supertype.name.gsub(/.*::/,'').to_sym, true, true)
       end
     end
   end

data/lib/activefacts/api/guid.rb

@@ -24,17 +24,17 @@ class Guid
     if i == :new
       case @@sequence
       when 'fixed'
-	@@counter ||= 0
-	@value = SecureRandom.format_uuid('%032x' % (@@counter += 1))
+        @@counter ||= 0
+        @value = SecureRandom.format_uuid('%032x' % (@@counter += 1))
       when 'record'
-	@@sequence_file ||= File.open(SEQ_FILE_NAME, 'w')
-	@value = SecureRandom.uuid.freeze
-	@@sequence_file.puts(@value)
+        @@sequence_file ||= File.open(SEQ_FILE_NAME, 'w')
+        @value = SecureRandom.uuid.freeze
+        @@sequence_file.puts(@value)
       when 'replay'
-	@@sequence_file ||= File.open(SEQ_FILE_NAME, 'r')
-	@value = @@sequence_file.gets.chomp
+        @@sequence_file ||= File.open(SEQ_FILE_NAME, 'r')
+        @value = @@sequence_file.gets.chomp
       else
-	@value = SecureRandom.uuid.freeze
+        @value = SecureRandom.uuid.freeze
       end
     elsif (v = i.to_s).length == 36 and !(v !~ /[^0-9a-f]/i)
       @value = v.clone.freeze
@@ -68,7 +68,7 @@ class Guid
     to_s.eql?(o.to_s)
   end
 
-  def <=>(o)				#:nodoc:
+  def <=>(o)                            #:nodoc:
     to_s.<=>(o.to_s)
   end
 

data/lib/activefacts/api/instance.rb

@@ -15,10 +15,10 @@ module ActiveFacts
         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 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
@@ -32,16 +32,16 @@ module ActiveFacts
 
       # List entities which have an identifying role played by this object.
       def related_entities(indirectly = true, instances = [])
-	# Check all roles of this instance
+        # Check all roles of this instance
         self.class.all_role.each do |role_name, role|
-	  # 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
+          # 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
@@ -52,101 +52,106 @@ module ActiveFacts
 
       # De-assign all functional roles and remove from constellation, if any.
       def retract
-	return unless constellation = @constellation
-
-	unless constellation.loggers.empty?
-	  # An object may have multiple identifiers, with potentially overlapping role sets
-	  # Get one copy of each role to use in asserting the instance
-	  if self.class.is_entity_type
-	    identifying_role_values = {}
-	    ([self.class]+self.class.supertypes_transitive).each do |klass|
-	      klass.identifying_role_names.zip(identifying_role_values(klass)).each do |name, value|
-		identifying_role_values[name] = value
-	      end
-	    end
-	  else
-	    identifying_role_values = self
-	  end
-	end
+        return unless constellation = @constellation
+
+        unless constellation.loggers.empty?
+          # An object may have multiple identifiers, with potentially overlapping role sets
+          # Get one copy of each role to use in asserting the instance
+          if self.class.is_entity_type
+            identifying_role_values = {}
+            ([self.class]+self.class.supertypes_transitive).each do |klass|
+              klass.identifying_role_names.zip(identifying_role_values(klass)).each do |name, value|
+                identifying_role_values[name] = value
+              end
+            end
+          else
+            identifying_role_values = self
+          end
+        end
 
         # Delete from the constellation first, while we remember our identifying role values
         constellation.deindex_instance(self)
-	instance_variable_set(@@constellation_variable_name ||= "@constellation", nil)
+        instance_variable_set(@@constellation_variable_name ||= "@constellation", nil)
 
         # Now, for all roles (from this class and all supertypes), assign nil to all functional roles
         # The counterpart roles get cleared automatically.
-	klasses = [self.class]+self.class.supertypes_transitive
-
-	irvrvs = {}  # identifying_role_values by RoleValues
-	self.class.all_role_transitive.each do |_, role|
-	  next unless role.counterpart and
-	    role.unique and
-	    !role.counterpart.unique and
-	    counterpart = send(role.getter)
-	  role_values = counterpart.send(role.counterpart.getter)
-	  irvrvs[role_values] = role_values.index_values(self)
-	end
-
-	# Nullify the counterpart role of objects we identify first, before damaging our identifying_role_values:
-	klasses.each do |klass|
+        klasses = [self.class]+self.class.supertypes_transitive
+
+        irvrvs = {}  # identifying_role_values by RoleValues
+        self.class.all_role_transitive.each do |_, role|
+          next unless role.counterpart and
+            role.unique and
+            !role.counterpart.unique and
+            counterpart = send(role.getter)
+          role_values = counterpart.send(role.counterpart.getter)
+          irvrvs[role_values] = role_values.index_values(self)
+        end
+
+        # Nullify the counterpart role of objects we identify first, before damaging our identifying_role_values:
+        klasses.each do |klass|
           klass.all_role.each do |role_name, role|
-	    next if role.unary?
-	    next if !(counterpart = role.counterpart).is_identifying
-	    next if role.fact_type.is_a?(TypeInheritanceFactType)
-
-	    counterpart_instances = send(role.getter)
-	    counterpart_instances.to_a.each do |counterpart_instance|
-	      # Allow nullifying non-mandatory roles, as long as they're not identifying.
-	      if counterpart.mandatory
-		counterpart_instance.retract
-	      else
-		counterpart_instance.send(counterpart.setter, nil, false)
-	      end
-	    end
-	  end
-	end
-
-	# Now deal with other roles:
-	klasses.each do |klass|
+            next if role.unary?
+            next if !(counterpart = role.counterpart).is_identifying
+            next if role.fact_type.is_a?(TypeInheritanceFactType)
+
+            counterpart_instances = send(role.getter)
+            counterpart_instances.to_a.each do |counterpart_instance|
+              # Allow nullifying non-mandatory roles, as long as they're not identifying.
+              if counterpart.mandatory
+                counterpart_instance.retract
+              else
+                counterpart_instance.send(counterpart.setter, nil, false)
+              end
+            end
+          end
+        end
+
+        # Now deal with other roles:
+        klasses.each do |klass|
           klass.all_role.each do |role_name, role|
             next if role.unary?
             counterpart = role.counterpart
 
-	    # Objects being created do not have to have non-identifying mandatory roles,
-	    # so we allow retracting to the same state.
+            # Objects being created do not have to have non-identifying mandatory roles,
+            # so we allow retracting to the same state.
             if role.unique
-	      next if role.fact_type.is_a?(TypeInheritanceFactType)
-	      i = send(role.getter)
-	      next unless i
-
-	      if (counterpart.unique)
-		# REVISIT: This will incorrectly fail to propagate a key change for a non-mandatory role
-		i.send(counterpart.setter, nil, false)
-	      else
-		rv = i.send(role.counterpart.getter)
-		rv.delete_instance(self, irvrvs[rv])
-
-		if (rv.empty? && !i.class.is_entity_type)
-		  i.retract if i.plays_no_role
-		end
-
-	      end
-	      instance_variable_set(role.variable, nil)
+              next if role.fact_type.is_a?(TypeInheritanceFactType)
+              counterpart_instance = send(role.getter)
+              next unless counterpart_instance && counterpart_instance.constellation
+
+              if (counterpart.unique)
+                # REVISIT: This will incorrectly fail to propagate a key change for a non-mandatory role
+                counterpart_instance.send(counterpart.setter, nil, false)
+              else
+                rv = counterpart_instance.send(role.counterpart.getter)
+                rv.delete_instance(self, irvrvs[rv])
+
+                if (rv.empty? && !counterpart_instance.class.is_entity_type)
+                  counterpart_instance.retract if counterpart_instance.plays_no_role
+                end
+
+              end
+              instance_variable_set(role.variable, 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:
-	      next if role.fact_type.is_a?(TypeInheritanceFactType)
-	      counterpart_instances = send(role.getter)
-	      counterpart_instances.to_a.each do |counterpart_instance|
-		# This action deconstructs our RoleValues as we go:
-		counterpart_instance.send(counterpart.setter, nil, false)
+              next if role.fact_type.is_a?(TypeInheritanceFactType)
+              counterpart_instances = send(role.getter)
+              counterpart_instances.to_a.each do |counterpart_instance|
+                next unless counterpart_instance.constellation
+                # This action deconstructs our RoleValues as we go:
+                if counterpart.mandatory
+                  counterpart_instance.retract
+                else
+                  counterpart_instance.send(counterpart.setter, nil, false)
+                end
               end
-	      instance_variable_set(role.variable, nil)
+              instance_variable_set(role.variable, nil)
             end
           end
         end
 
-	constellation.loggers.each{|l| l.call(:retract, self.class, identifying_role_values) }
+        constellation.loggers.each{|l| l.call(:retract, self.class, identifying_role_values) }
 
       end
 

data/lib/activefacts/api/instance_index.rb

@@ -10,48 +10,48 @@ module ActiveFacts
   module API
     class KeyArray < Array
       def initialize(a)
-	super(
-	  a.map do |e|
-	    if e.is_a?(Array) && e.class != self.class
-	      KeyArray.new(e)
-	    elsif e.eql?(nil)
-	      []
-	    else
-	      e
-	    end
-	  end
-	)
+        super(
+          a.map do |e|
+            if e.is_a?(Array) && e.class != self.class
+              KeyArray.new(e)
+            elsif e.eql?(nil)
+              []
+            else
+              e
+            end
+          end
+        )
       end
 
       def inspect
-	"KeyArray"+super
+        "KeyArray"+super
       end
 
       # This is used by RBTree for searching, and we need it to use eql? semantics to be like a Hash
       def ==(other)
-	self.eql? other
+        self.eql? other
       end
 
       def <=>(other)
-	unless other.is_a?(Array)	# Any kind of Array, not just KeyArray
-	  return 1
-	end
-
-	0.upto(size-1) do |i|
-	  diff = ((s = self[i]) <=> (o = other[i]) rescue nil)
-	  case diff
-	  when 0	# Same value, whether exactly the same class or not
-	    next
-	  when nil	# Non-comparable values
-	    return -1 if s == nil	# Ensure that nil values come before other values
-	    return 1 if o == nil
-	    diff = s.class.name <=> o.class.name  # Otherwise just ensure stable sorting
-	    return diff if diff != 0
-	  else
-	    return diff
-	  end
-	end
-	0
+        unless other.is_a?(Array)       # Any kind of Array, not just KeyArray
+          return 1
+        end
+
+        0.upto(size-1) do |i|
+          diff = ((s = self[i]) <=> (o = other[i]) rescue nil)
+          case diff
+          when 0        # Same value, whether exactly the same class or not
+            next
+          when nil      # Non-comparable values
+            return -1 if s == nil       # Ensure that nil values come before other values
+            return 1 if o == nil
+            diff = s.class.name <=> o.class.name  # Otherwise just ensure stable sorting
+            return diff if diff != 0
+          else
+            return diff
+          end
+        end
+        0
       end
     end
 
@@ -65,15 +65,15 @@ module ActiveFacts
 
       # Should be in module ForwardableWithArityChecking
       def self.def_single_delegator(accessor, method, *expected_arities)
-	str = %{
-	  def #{method}(*args, &block)
-	    if #{expected_arities.size == 0 ? "block" : "!block || !#{expected_arities.inspect}.include?(block.arity)" }
-	      raise ArgumentError.new("Arity mismatch on #{name}\##{method}, got \#{block ? block.arity : 'none'} want #{expected_arities.inspect} at \#{caller*"\n\t"})")
-	    end
-	    #{accessor}.__send__(:#{method}, *args, &block)
-	  end
-	}
-	eval(str)
+        str = %{
+          def #{method}(*args, &block)
+            if #{expected_arities.size == 0 ? "block" : "!block || !#{expected_arities.inspect}.include?(block.arity)" }
+              raise ArgumentError.new("Arity mismatch on #{name}\##{method}, got \#{block ? block.arity : 'none'} want #{expected_arities.inspect} at \#{caller*"\n\t"})")
+            end
+            #{accessor}.__send__(:#{method}, *args, &block)
+          end
+        }
+        eval(str)
       end
 
       def_single_delegator :@hash, :size
@@ -87,7 +87,7 @@ module ActiveFacts
       def initialize(constellation, klass, sort)
         @constellation = constellation
         @klass = klass
-	@sort = sort
+        @sort = sort
         @hash = sort ? RBTree.new : {}
       end
 
@@ -96,7 +96,7 @@ module ActiveFacts
       end
 
       def delete(k)
-	@hash.delete(@sort ? form_key(k) : k)
+        @hash.delete(@sort ? form_key(k) : k)
       end
 
       def detect &b
@@ -109,7 +109,7 @@ module ActiveFacts
       end
 
       def [](key)
-	@hash[@sort ? form_key(key) : key]
+        @hash[@sort ? form_key(key) : key]
       end
 
       def refresh_key(old_key)
@@ -119,14 +119,14 @@ module ActiveFacts
       end
 
       def form_key key
-	case key
-	when Array
-	  KeyArray.new(key)
-	when nil
-	  []
-	else
-	  key
-	end
+        case key
+        when Array
+          KeyArray.new(key)
+        when nil
+          []
+        else
+          key
+        end
       end
     end
   end