activefacts 1.5.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f4c7be7ca9e116d36232a6e9c0bcf28f0f4a63eb
-  data.tar.gz: a3c13e8e437aa028760eff29cd05df07b0017a91
+  metadata.gz: 887391f1fb780fae6998c9ea40bc158d1b68638d
+  data.tar.gz: ca958351f21cf0b5bf81116982fa9604735b2a42
 SHA512:
-  metadata.gz: 49878c205424a5534e811af19bf09ebe0e3c8aefbd3127a1ee0695d3a5c77eec2beb74715455ff32d7bde613e8a1eff8241dc35ba77a79915770e1ee68c60ba0
-  data.tar.gz: 4396ee06e34a48236e858274010356123f66847686a04763b4b4992283ae30f8dd6b0d96e7086803339a97f9ffbc2c158d2563a8840a288c330623f11680de8b
+  metadata.gz: d708a24d6ebc6db435c50a2f5aa3a3f7f3dcf416fe7a1104dc9deec10bfb0128853a39ea0e31688bcb49914acd45a3df7298409d7410f8ea36888b019cf09672
+  data.tar.gz: aa44870543b7485a003e2a1ffe3bf12aa73e5f1c3516825a62819dd9c2eed2ddc47bffdf56b01e8af8a0847520ce68da66e6340bd83db628f80e7a8fa89e7611

data/examples/CQL/Metamodel.cql

@@ -6,6 +6,7 @@ vocabulary Metamodel;
 Adjective is written as String(64);
 Agent Name is written as String;
 Aggregate Code is written as String(32);
+Annotation is written as String;
 Assimilation is written as String restricted to {'absorbed', 'partitioned', 'separate'};
 Context Note Kind is written as String restricted to {'as_opposed_to', 'because', 'so_that', 'to_avoid'};
 Date is written as Date;
@@ -31,7 +32,6 @@ Rotation Setting is written as String restricted to {'left', 'right'};
 Scale is written as Unsigned Integer(32);
 Subscript is written as Unsigned Integer(16);
 Text is written as String(256);
-Topic Name is written as Name;
 Transaction Phase is written as String restricted to {'assert', 'commit'};
 X is written as Signed Integer(32);
 Y is written as Signed Integer(32);
@@ -56,6 +56,8 @@ Coefficient is identified by Numerator and Denominator and Coefficient is precis
 Concept is identified by Guid where
 	Concept has one Guid,
 	Guid is of at most one Concept;
+Concept has mapping-Annotation,
+	Annotation applies to at most one Concept;
 
 Constraint is identified by Concept where
 	Constraint is an instance of one Concept;
@@ -124,6 +126,8 @@ Role is identified by Fact Type and Ordinal where
 	Fact Type contains Role,
 	Role fills one Ordinal,
 	Ordinal applies to Role;
+Link Fact Type has one implying-Role,
+	implying-Role implies at most one Link Fact Type;
 Ring Constraint has at most one other-Role,
 	other-Role is of Ring Constraint;
 Role is an instance of one Concept;
@@ -133,12 +137,6 @@ Role is of Ring Constraint,
 Role has at most one role-Name,
 	role-Name is name of at least one Role;
 
-Role Proxy is a kind of Role;
-Link Fact Type has one Role Proxy,
-	Role Proxy is of at most one Link Fact Type;
-Role Proxy is for at most one Role,
-	Role has at most one Role Proxy;
-
 Role Sequence is identified by Guid where
 	Role Sequence has one Guid,
 	Guid is of at most one Role Sequence;
@@ -162,11 +160,23 @@ Shape is identified by Guid where
 Shape is at at most one Location;
 Shape is expanded;
 
+Step is identified by Guid where
+	Step has one Guid,
+	Guid is of at most one Step;
+Step falls under at most one Alternative Set,
+	Alternative Set covers at least one Step;
+Step specifies one Fact Type,
+	Fact Type directs Step;
+Step is disallowed;
+Step is optional;
+
 Subset Constraint is a kind of Set Constraint;
 Subset Constraint covers one subset-Role Sequence;
 Subset Constraint covers one superset-Role Sequence;
 
-Topic is identified by its Name;
+Topic is identified by topic-Name where
+	Topic has one topic-Name,
+	topic-Name is of at most one Topic;
 Concept belongs to at most one Topic,
 	Topic contains Concept;
 
@@ -202,6 +212,8 @@ Variable is identified by Query and Ordinal where
 	Variable has one Ordinal position;
 Variable projects at most one Role (as Projection),
 	Projection is projected from at most one Variable;
+Variable (as Objectification Variable) matches nesting over at most one Step,
+	Step nests as at most one Objectification Variable;
 Variable has at most one Subscript,
 	Subscript is of Variable;
 Variable is bound to at most one Value;
@@ -287,8 +299,9 @@ Objectified Fact Type Name Shape is for one Fact Type Shape,
 	Fact Type Shape has at most one Objectified Fact Type Name Shape;
 
 Play is where
-	Variable is restricted by Role,
-	Role controls Variable;
+	Variable is restricted by Role of Step,
+	Step contains Role restricting one Variable;
+Play is input;
 
 Population is identified by Vocabulary and Name where
 	Vocabulary includes Population,
@@ -325,7 +338,8 @@ Role Ref is where
 	Role is in Role Sequence in one Ordinal place,
 	Role Sequence includes Role in Ordinal place,
 	Role has Ordinal place in Role Sequence;
-Play projects at most one Role Ref;
+Play projects at most one Role Ref,
+	Role Ref is projected from at most one Play;
 Role Ref has at most one leading-Adjective;
 Role Ref has at most one trailing-Adjective;
 
@@ -342,18 +356,6 @@ Set Equality Constraint is a kind of Set Comparison Constraint;
 Set Exclusion Constraint is a kind of Set Comparison Constraint;
 Set Exclusion Constraint is mandatory;
 
-Step is identified by input-Play and output-Play where
-	Step has one input-Play,
-	Step has at most one output-Play;
-Step falls under at most one Alternative Set,
-	Alternative Set covers at least one Step;
-Step specifies one Fact Type,
-	Fact Type directs Step;
-Step involves incidental-Play,
-	Play is incidentally involved in at most one Step;
-Step is disallowed;
-Step is optional;
-
 Value Constraint Shape is a kind of Constraint Shape;
 Role Display has at most one Value Constraint Shape,
 	Value Constraint Shape is for at most one Role Display;
@@ -394,15 +396,15 @@ Value Type has at most one Value Constraint,
 Value Type is subtype of at most one super-Value Type (as Supertype) [acyclic, transitive],
 	Supertype is supertype of Value Type;
 
-Facet is where
+Value Type Parameter is where
 	Value Type has facet called Name,
 	Name is a facet of Value Type;
-Facet requires value of one facet-Value Type;
+Value Type Parameter requires value of one facet-Value Type;
 
-Facet Restriction is where
-	Value Type applies Facet,
-	Facet applies to Value Type;
-Facet Restriction has one Value;
+Value Type Parameter Restriction is where
+	Value Type receives Value Type Parameter,
+	Value Type Parameter applies to Value Type;
+Value Type Parameter Restriction has one Value;
 
 Implicit Boolean Value Type is a kind of Value Type;
 
@@ -441,27 +443,24 @@ either Value Constraint constrains Value Type or Value Constraint applies to Rol
 for each Instance at most one of these holds:
 	Instance has Value,
 	Instance objectifies Fact;
-for each Play at most one of these holds:
-	Step (1) has input-Play,
-	Play is incidentally involved in Step;
-for each Play at most one of these holds:
-	Step (1) has output-Play,
-	Play is incidentally involved in Step;
 Role Value is of Instance that is of Object Type
 	if and only if
 	Role Value is of Role that is played by Object Type;
 Role Value fulfils Fact that is of Fact Type
 	if and only if
 	Role Value is of Role that belongs to Fact Type;
+Step specifies Fact Type that contains Role
+	if and only if
+	Step contains Role restricting Variable;
 Variable is for Object Type that plays Role
 	if and only if
-	Variable is restricted by Role;
+	Variable is restricted by Role of Step;
 Presence Constraint is preferred identifier
 	only if Presence Constraint has max Frequency;
-Step involves incidental Play
-	only if Step has output Play;
 Value Type has Scale
 	only if Value Type has Length;
+Variable matches nesting over Step
+	only if Variable is for Object Type and Step specifies Fact Type;
 either Agreement was reached by Agent or Agreement was on Date;
 each Concept occurs at most one time in
 	Object Type is an instance of Concept;
@@ -479,8 +478,6 @@ each Presence Constraint occurs at least one time in
 	Presence Constraint has min Frequency(2),
 	Presence Constraint has max Frequency(1),
 	Presence Constraint is mandatory;
-each Role Ref occurs at most one time in
-	Play projects Role Ref;
 each Role Sequence occurs at least one time in
 	Role Sequence in Ordinal position includes Role;
 each Set Comparison Constraint occurs at least 2 times in

data/lib/activefacts/cql/ObjectTypes.treetop

@@ -174,10 +174,20 @@ module ActiveFacts
       end
 
       rule mapping_pragma
-        (independent / separate / partitioned / personal / feminine / masculine /
-	  was s names:(id s)+ { def text_value; [ was.text_value, names.elements.map{|n|n.text_value} ]; end }
-	)
-          { def value; text_value; end }
+	was s names:(id s)+
+	{   # Old or previous name of an object type:
+	  def value
+	    [ was.text_value, names.elements.map{|n|n.text_value} ]
+	  end
+	}
+	/
+	head:id tail:(s id)*
+	{   # A sequence of one or more words denoting a pragma:
+	  def value
+	    ([head]+tail.elements.map(&:id)).
+	      map(&:text_value)*' '
+	  end
+	}
       end
 
       rule entity_clauses

data/lib/activefacts/cql/compiler/entity_type.rb

@@ -31,13 +31,16 @@ module ActiveFacts
         def compile
           @entity_type = @vocabulary.valid_entity_type_name(@name) ||
 	    @constellation.EntityType(@vocabulary, @name, :concept => :new)
-          @entity_type.is_independent = true if (@pragmas.include? 'independent')
+          @entity_type.is_independent = true if @pragmas.delete('independent')
 
           # REVISIT: CQL needs a way to indicate whether subtype migration can occur.
           # For example by saying "Xyz is a role of Abc".
           @supertypes.each_with_index do |supertype_name, i|
             add_supertype(supertype_name, @identification || i > 0)
           end
+	  @pragmas.each do |p|
+	    @constellation.Annotation(p, :concept => @entity_type.concept)
+	  end if @pragmas
 
           context = CompilationContext.new(@vocabulary)
 
@@ -237,7 +240,9 @@ module ActiveFacts
 
             inheritance_fact = @constellation.TypeInheritance(@entity_type, supertype, :concept => :new)
 
-            assimilations = @pragmas.select { |p| ['absorbed', 'separate', 'partitioned'].include? p}
+	    assimilation_pragmas = ['absorbed', 'separate', 'partitioned']
+            assimilations = @pragmas.select { |p| assimilation_pragmas.include? p}
+	    @pragmas -= assimilation_pragmas
             raise "Conflicting assimilation pragmas #{assimilations*', '}" if assimilations.size > 1
             inheritance_fact.assimilation = assimilations[0]
 

data/lib/activefacts/cql/compiler/fact_type.rb

@@ -169,10 +169,10 @@ module ActiveFacts
             if @pragmas
               @entity_type.is_independent = true if @pragmas.delete('independent')
             end
-            if @pragmas && @pragmas.size > 0
-              $stderr.puts "Mapping pragmas #{@pragmas.inspect} are ignored for objectified fact type #{@name}"
-            end
           end
+	  @pragmas.each do |p|
+	    @constellation.Annotation(p, :concept => @fact_type.concept)
+	  end if @pragmas
 
           @clauses.each do |clause|
             next unless clause.context_note

data/lib/activefacts/cql/compiler/value_type.rb

@@ -113,7 +113,10 @@ module ActiveFacts
           # Create and initialise the ValueType:
 	  vt = @vocabulary.valid_value_type_name(@name) ||
 	    @constellation.ValueType(@vocabulary, @name, :concept => :new)
-          vt.is_independent = true if (@pragmas.include? 'independent')
+          vt.is_independent = true if @pragmas.delete('independent')
+	  @pragmas.each do |p|
+	    @constellation.Annotation(p, :concept => vt.concept)
+	  end if @pragmas
           vt.supertype = base_type if base_type
           vt.length = length if length
           vt.scale = scale if scale

data/lib/activefacts/generate/sql/server.rb

@@ -165,7 +165,8 @@ module ActiveFacts
                   "(" + length.to_s + (scale ? ", #{scale}" : "") + ")"
                 end
                 }"
-              identity = column == identity_column ? " IDENTITY" : ""
+	      # Emit IDENTITY for auto-assigned columns, unless it's assigned at assert:
+              identity = column == identity_column && column.references[-1].to.transaction_phase != 'assert' ? " IDENTITY" : ""
               null = (column.is_mandatory ? "NOT " : "") + "NULL"
               check = check_clause(name, constraints)
               comment = column.comment

data/lib/activefacts/generate/transform/surrogate.rb

@@ -12,167 +12,167 @@ module ActiveFacts
     class ObjectType
 
       def add_surrogate type_name = 'Auto Counter', suffix = 'ID'
-	# Find or assert the surrogate value type
-	auto_counter = vocabulary.valid_value_type_name(type_name) ||
-	  constellation.ValueType(:vocabulary => vocabulary, :name => type_name, :concept => :new)
-
-	# Create a subtype to identify this entity type:
-	vt_name = self.name + ' '+suffix
-	my_id = @vocabulary.valid_value_type_name(vt_name) ||
-	  constellation.ValueType(:vocabulary => vocabulary, :name => vt_name, :concept => :new, :supertype => auto_counter)
-
-	# Create a fact type
-	identifying_fact_type = constellation.FactType(:concept => :new)
-	my_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 0, :object_type => self)
-	@injected_surrogate_role = my_role
-	id_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 1, :object_type => my_id)
-
-	# Create a reading (which needs a RoleSequence)
-	reading = constellation.Reading(
-	  :fact_type => identifying_fact_type,
-	  :ordinal => 0,
-	  :role_sequence => [:new],
-	  :text => "{0} has {1}"
-	)
-	constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 0, :role => my_role)
-	constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 1, :role => id_role)
-
-	# Create two uniqueness constraints for the one-to-one. Each needs a RoleSequence (two RoleRefs)
-	one_id = constellation.PresenceConstraint(
-	    :concept => :new,
-	    :vocabulary => vocabulary,
-	    :name => self.name+'HasOne'+suffix,
-	    :role_sequence => [:new],
-	    :is_mandatory => true,
-	    :min_frequency => 1,
-	    :max_frequency => 1,
-	    :is_preferred_identifier => false
-	  )
-	@constellation.RoleRef(:role_sequence => one_id.role_sequence, :ordinal => 0, :role => my_role)
-
-	one_me = constellation.PresenceConstraint(
-	    :concept => :new,
-	    :vocabulary => vocabulary,
-	    :name => self.name+suffix+'IsOfOne'+self.name,
-	    :role_sequence => [:new],
-	    :is_mandatory => false,
-	    :min_frequency => 0,
-	    :max_frequency => 1,
-	    :is_preferred_identifier => true
-	  )
-	@constellation.RoleRef(:role_sequence => one_me.role_sequence, :ordinal => 0, :role => id_role)
+        # Find or assert the surrogate value type
+        auto_counter = vocabulary.valid_value_type_name(type_name) ||
+          constellation.ValueType(:vocabulary => vocabulary, :name => type_name, :concept => :new)
+
+        # Create a subtype to identify this entity type:
+        vt_name = self.name + ' '+suffix
+        my_id = @vocabulary.valid_value_type_name(vt_name) ||
+          constellation.ValueType(:vocabulary => vocabulary, :name => vt_name, :concept => :new, :supertype => auto_counter)
+
+        # Create a fact type
+        identifying_fact_type = constellation.FactType(:concept => :new)
+        my_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 0, :object_type => self)
+        @injected_surrogate_role = my_role
+        id_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 1, :object_type => my_id)
+
+        # Create a reading (which needs a RoleSequence)
+        reading = constellation.Reading(
+          :fact_type => identifying_fact_type,
+          :ordinal => 0,
+          :role_sequence => [:new],
+          :text => "{0} has {1}"
+        )
+        constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 0, :role => my_role)
+        constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 1, :role => id_role)
+
+        # Create two uniqueness constraints for the one-to-one. Each needs a RoleSequence (two RoleRefs)
+        one_id = constellation.PresenceConstraint(
+            :concept => :new,
+            :vocabulary => vocabulary,
+            :name => self.name+'HasOne'+suffix,
+            :role_sequence => [:new],
+            :is_mandatory => true,
+            :min_frequency => 1,
+            :max_frequency => 1,
+            :is_preferred_identifier => false
+          )
+        @constellation.RoleRef(:role_sequence => one_id.role_sequence, :ordinal => 0, :role => my_role)
+
+        one_me = constellation.PresenceConstraint(
+            :concept => :new,
+            :vocabulary => vocabulary,
+            :name => self.name+suffix+'IsOfOne'+self.name,
+            :role_sequence => [:new],
+            :is_mandatory => false,
+            :min_frequency => 0,
+            :max_frequency => 1,
+            :is_preferred_identifier => true
+          )
+        @constellation.RoleRef(:role_sequence => one_me.role_sequence, :ordinal => 0, :role => id_role)
       end
     end
 
     class ValueType
       def needs_surrogate
-	!is_auto_assigned
+        !is_auto_assigned
       end
 
       def inject_surrogate
-	trace :transform_surrogate, "Adding surrogate ID to Value Type #{name}"
-	add_surrogate('Auto Counter', 'ID')
+        trace :transform_surrogate, "Adding surrogate ID to Value Type #{name}"
+        add_surrogate('Auto Counter', 'ID')
       end
     end
 
     class EntityType
       def identifying_refs_from
-	pi = preferred_identifier
-	rrs = pi.role_sequence.all_role_ref
-
-#	REVISIT: This is actually a ref to us, not from
-#	if absorbed_via
-#	  return [absorbed_via]
-#	end
-
-	rrs.map do |rr|
-	  r = references_from.detect{|ref| rr.role == ref.to_role }
-	  raise "failed to find #{name} identifying reference for #{rr.role.object_type.name} in #{references_from.inspect}" unless r
-	  r
-	end
+        pi = preferred_identifier
+        rrs = pi.role_sequence.all_role_ref
+
+#       REVISIT: This is actually a ref to us, not from
+#       if absorbed_via
+#         return [absorbed_via]
+#       end
+
+        rrs.map do |rr|
+          r = references_from.detect{|ref| rr.role == ref.to_role }
+          raise "failed to find #{name} identifying reference for #{rr.role.object_type.name} in #{references_from.inspect}" unless r
+          r
+        end
       end
 
       def needs_surrogate
 
-	# A recursive proc to replace any reference to an Entity Type by its identifying references:
-	trace :transform_surrogate_expansion, "Expanding key for #{name}"
-	substitute_identifying_refs = proc do |object|
-	  if ref = object.absorbed_via
-	    # This shouldn't be necessary, but see the absorbed_via comment above.
-	    absorbed_into = ref.from
-	    trace :transform_surrogate_expansion, "recursing to handle absorption of #{object.name} into #{absorbed_into.name}"
-	    [substitute_identifying_refs.call(absorbed_into)]
-	  else
-	    irf = object.identifying_refs_from
-	    trace :transform_surrogate_expansion, "Iterating for #{object.name} over #{irf.inspect}" do
-	      irf.each_with_index do |ref, i|
-		next if ref.is_unary
-		next if ref.to_role.object_type.kind_of?(ActiveFacts::Metamodel::ValueType)
-		recurse_to = ref.to_role.object_type
-
-		trace :transform_surrogate_expansion, "#{i}: recursing to expand #{recurse_to.name} key in #{ref}" do
-		  irf[i] = substitute_identifying_refs.call(recurse_to)
-		end
-	      end
-	    end
-	    irf
-	  end
-	end
-	irf = substitute_identifying_refs.call(self)
-
-	trace :transform_surrogate, "Does #{name} need a surrogate? it's identified by #{irf.inspect}" do
-
-	  pk_fks = identifying_refs_from.map do |ref|
-	    ref.to && ref.to.is_table ? ref.to : nil
-	  end
-
-	  irf.flatten!
-
-	  # Multi-part identifiers are only allowed if:
-	  # * each part is a foreign key (i.e. it's a join table),
-	  # * there are no other columns (that might require updating) and
-	  # * the object is not the target of a foreign key:
-	  if irf.size >= 2
-	    if pk_fks.include?(nil)
-	      trace :transform_surrogate, "#{self.name} needs a surrogate because its multi-part key contains a non-table"
-	      return true
-	    elsif references_to.size != 0
-	      trace :transform_surrogate, "#{self.name} is a join table between #{pk_fks.map(&:name).inspect} but is also an FK target"
-	      return true
-	    elsif (references_from-identifying_refs_from).size > 0
-	      # There are other attributes to worry about
-	      return true
-	    else
-	      trace :transform_surrogate, "#{self.name} is a join table between #{pk_fks.map(&:name).inspect}"
-	      return false
-	    end
-	    return true
-	  end
-
-	  # Single-part key. It must be an Auto Counter, or we will add a surrogate
-
-	  identifying_type = irf[0].to
-	  if identifying_type.needs_surrogate
-	    trace :transform_surrogate, "#{self.name} needs a surrogate because #{irf[0].to.name} is not an AutoCounter, but #{identifying_type.supertypes_transitive.map(&:name).inspect}"
-	    return true
-	  end
-
-	  false
-	end
+        # A recursive proc to replace any reference to an Entity Type by its identifying references:
+        trace :transform_surrogate_expansion, "Expanding key for #{name}"
+        substitute_identifying_refs = proc do |object|
+          if ref = object.absorbed_via
+            # This shouldn't be necessary, but see the absorbed_via comment above.
+            absorbed_into = ref.from
+            trace :transform_surrogate_expansion, "recursing to handle absorption of #{object.name} into #{absorbed_into.name}"
+            [substitute_identifying_refs.call(absorbed_into)]
+          else
+            irf = object.identifying_refs_from
+            trace :transform_surrogate_expansion, "Iterating for #{object.name} over #{irf.inspect}" do
+              irf.each_with_index do |ref, i|
+                next if ref.is_unary
+                next if ref.to_role.object_type.kind_of?(ActiveFacts::Metamodel::ValueType)
+                recurse_to = ref.to_role.object_type
+
+                trace :transform_surrogate_expansion, "#{i}: recursing to expand #{recurse_to.name} key in #{ref}" do
+                  irf[i] = substitute_identifying_refs.call(recurse_to)
+                end
+              end
+            end
+            irf
+          end
+        end
+        irf = substitute_identifying_refs.call(self)
+
+        trace :transform_surrogate, "Does #{name} need a surrogate? it's identified by #{irf.inspect}" do
+
+          pk_fks = identifying_refs_from.map do |ref|
+            ref.to && ref.to.is_table ? ref.to : nil
+          end
+
+          irf.flatten!
+
+          # Multi-part identifiers are only allowed if:
+          # * each part is a foreign key (i.e. it's a join table),
+          # * there are no other columns (that might require updating) and
+          # * the object is not the target of a foreign key:
+          if irf.size >= 2
+            if pk_fks.include?(nil)
+              trace :transform_surrogate, "#{self.name} needs a surrogate because its multi-part key contains a non-table"
+              return true
+            elsif references_to.size != 0
+              trace :transform_surrogate, "#{self.name} is a join table between #{pk_fks.map(&:name).inspect} but is also an FK target"
+              return true
+            elsif (references_from-identifying_refs_from).size > 0
+              # There are other attributes to worry about
+              return true
+            else
+              trace :transform_surrogate, "#{self.name} is a join table between #{pk_fks.map(&:name).inspect}"
+              return false
+            end
+            return true
+          end
+
+          # Single-part key. It must be an Auto Counter, or we will add a surrogate
+
+          identifying_type = irf[0].to
+          if identifying_type.needs_surrogate
+            trace :transform_surrogate, "#{self.name} needs a surrogate because #{irf[0].to.name} is not an AutoCounter, but #{identifying_type.supertypes_transitive.map(&:name).inspect}"
+            return true
+          end
+
+          false
+        end
       end
 
       def inject_surrogate
-	trace :transform_surrogate, "Injecting a surrogate key into #{self.name}"
+        trace :transform_surrogate, "Injecting a surrogate key into #{self.name}"
 
-	# Disable the preferred identifier:
-	pi = preferred_identifier
-	trace :transform_surrogate, "pi for #{name} was '#{pi.describe}'"
-	pi.is_preferred_identifier = false
-	@preferred_identifier = nil   # Kill the cache
+        # Disable the preferred identifier:
+        pi = preferred_identifier
+        trace :transform_surrogate, "pi for #{name} was '#{pi.describe}'"
+        pi.is_preferred_identifier = false
+        @preferred_identifier = nil   # Kill the cache
 
-	add_surrogate
+        add_surrogate
 
-	trace :transform_surrogate, "pi for #{name} is now '#{preferred_identifier.describe}'"
+        trace :transform_surrogate, "pi for #{name} is now '#{preferred_identifier.describe}'"
       end
 
     end
@@ -181,8 +181,8 @@ module ActiveFacts
   module Persistence
     class Column
       def is_injected_surrogate
-	references.size == 1 and
-	  references[0].from_role == references[0].from.injected_surrogate_role
+        references.size == 1 and
+          references[0].from_role == references[0].from.injected_surrogate_role
       end
     end
   end
@@ -190,22 +190,22 @@ module ActiveFacts
   module Generate #:nodoc:
     module Transform #:nodoc:
       class Surrogate
-	def initialize(vocabulary, *options)
-	  @vocabulary = vocabulary
-	end
-
-	def generate(out = $stdout)
-	  @out = out
-	  injections = 
-	    @vocabulary.tables.select do |table|
-	      table.needs_surrogate
-	    end
-	  injections.each do |table|
-	    table.inject_surrogate
-	  end
-
-	  @vocabulary.decide_tables
-	end
+        def initialize(vocabulary, *options)
+          @vocabulary = vocabulary
+        end
+
+        def generate(out = $stdout)
+          @out = out
+          injections = 
+            @vocabulary.tables.select do |table|
+              table.needs_surrogate
+            end
+          injections.each do |table|
+            table.inject_surrogate
+          end
+
+          @vocabulary.decide_tables
+        end
       end
     end
   end