activefacts 0.8.9 → 0.8.10

data/lib/activefacts/persistence/foreignkey.rb

@@ -1,20 +1,20 @@
 #
 #       ActiveFacts Relational mapping and persistence.
-#       A ForeignKey exists for every Reference from a Concept to another Concept that's a table.
+#       A ForeignKey exists for every Reference from a ObjectType to another ObjectType that's a table.
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
 module ActiveFacts
   module Persistence
     class ForeignKey
-      # What table (Concept) is the FK from?
+      # What table (ObjectType) is the FK from?
       def from; @from; end
 
-      # What table (Concept) is the FK to?
+      # What table (ObjectType) is the FK to?
       def to; @to; end
 
       # What reference created the FK?
-      def reference; @reference; end
+      def reference; @fk_ref; end
 
       # What columns in the *from* table form the FK
       def from_columns; @from_columns; end
@@ -30,7 +30,7 @@ module ActiveFacts
   end
 
   module Metamodel    #:nodoc:
-    class Concept
+    class ObjectType
       # When an EntityType is fully absorbed, its foreign keys are too.
       # Return an Array of Reference paths for such absorbed FKs
       def all_absorbed_foreign_key_reference_path
@@ -61,7 +61,7 @@ module ActiveFacts
         fk_ref_paths.map do |fk_ref_path|
           debug :fk, "\nFK: " + fk_ref_path.map{|fk_ref| fk_ref.reading }*" and " do
 
-            from_columns = columns.select{|column|
+            from_columns = (columns||all_columns({})).select{|column|
               column.references[0...fk_ref_path.size] == fk_ref_path
             }
             debug :fk, "from_columns = #{from_columns.map { |column| column.name }*", "}"

data/lib/activefacts/persistence/index.rb

@@ -1,7 +1,7 @@
 #
 #       ActiveFacts Relational mapping and persistence.
-#       An Index on a Concept is used to represent a unique constraint across roles absorbed
-#       into that concept's table.
+#       An Index on a ObjectType is used to represent a unique constraint across roles absorbed
+#       into that object_type's table.
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
@@ -16,7 +16,7 @@ module ActiveFacts
       def on; @on; end
 
       # If a non-mandatory reference was absorbed, only the non-nil instances are unique.
-      # Return the Concept that was absorbed, which might differ from this Index's table.
+      # Return the ObjectType that was absorbed, which might differ from this Index's table.
       def over; @over; end
 
       # Return the array of columns in this index
@@ -78,7 +78,7 @@ module ActiveFacts
   end
 
   module Metamodel    #:nodoc:
-    class Concept
+    class ObjectType
       # An array of each Index for this table
       def indices; @indices; end
 
@@ -181,23 +181,23 @@ module ActiveFacts
 
     class Vocabulary
       def populate_all_indices  #:nodoc:
-        debug :index, "Populating all concept indices" do
-          all_concept.each do |concept|
-            concept.clear_indices
+        debug :index, "Populating all object_type indices" do
+          all_object_type.each do |object_type|
+            object_type.clear_indices
           end
-          all_concept.each do |concept|
-            next unless concept.is_table
-            debug :index, "Populating indices for #{concept.name}" do
-              concept.populate_indices
+          all_object_type.each do |object_type|
+            next unless object_type.is_table
+            debug :index, "Populating indices for #{object_type.name}" do
+              object_type.populate_indices
             end
           end
         end
-        debug :index, "Finished concept indices" do
-          all_concept.each do |concept|
-            next unless concept.is_table
-            next unless concept.indices.size > 0
-            debug :index, "#{concept.name}:" do
-              concept.indices.each do |index|
+        debug :index, "Finished object_type indices" do
+          all_object_type.each do |object_type|
+            next unless object_type.is_table
+            next unless object_type.indices.size > 0
+            debug :index, "#{object_type.name}:" do
+              object_type.indices.each do |index|
                 debug :index, index
               end
             end

data/lib/activefacts/persistence/{concept.rb → object_type.rb}

@@ -2,7 +2,7 @@ require 'activefacts/support'
 
 module ActiveFacts
   module API
-    module Concept
+    module ObjectType
       def table
         @is_table = true
       end
@@ -29,7 +29,7 @@ module ActiveFacts
             end.inject([]) do |columns, role|
               rn = role.name.to_s.split(/_/)
               debug :persistence, "Role #{rn*'.'}" do
-                columns += role.counterpart_concept.__absorb([rn], role.counterpart)
+                columns += role.counterpart_object_type.__absorb([rn], role.counterpart)
               end
             end +
             # And finally all absorbed subtypes:
@@ -65,11 +65,11 @@ module ActiveFacts
             if (role = fully_absorbed) && role != except_role
               # If this non-table is fully absorbed into another table (not our caller!)
               # (another table plays its single identifying role), then absorb that role only.
-              # counterpart_concept = role.counterpart_concept
+              # counterpart_object_type = role.counterpart_object_type
               # This omission matches the one in columns.rb, see EntityType#reference_columns
               # new_prefix = prefix + [role.name.to_s.split(/_/)]
               debug :persistence, "Reference to #{role.name} (absorbed elsewhere)" do
-                role.counterpart_concept.__absorb(prefix, role.counterpart)
+                role.counterpart_object_type.__absorb(prefix, role.counterpart)
               end
             else
               # Not a table -> all roles are absorbed
@@ -125,7 +125,7 @@ module ActiveFacts
           debug :persistence, "truncating transitive identifying role #{n.inspect}"
           owner.size.times { n.shift }
           new_prefix = prefix + [n]
-        elsif (c = role.counterpart_concept).is_entity_type and
+        elsif (c = role.counterpart_object_type).is_entity_type and
             (irn = c.identifying_role_names).size == 1 and
             #irn[0].to_s.split(/_/)[0] == role.owner.basename.downcase
             irn[0] == role.counterpart.name
@@ -139,7 +139,7 @@ module ActiveFacts
         #debug :persistence, "new_prefix is #{new_prefix*"."}"
 
         debug :persistence, "Absorbing role #{role.name} as #{new_prefix[prefix.size..-1]*"."}" do
-          role.counterpart_concept.__absorb(new_prefix, role.counterpart)
+          role.counterpart_object_type.__absorb(new_prefix, role.counterpart)
         end
       end
 
@@ -159,7 +159,7 @@ module ActiveFacts
         def fully_absorbed
           return false unless (ir = identifying_role_names) && ir.size == 1
           role = roles(ir[0])
-          return role if ((cp = role.counterpart_concept).is_table ||
+          return role if ((cp = role.counterpart_object_type).is_table ||
               (cp.is_entity_type && cp.fully_absorbed))
           return superclass if superclass.is_entity_type  # Absorbed subtype
           nil
@@ -168,10 +168,10 @@ module ActiveFacts
     end
 
     # A one-to-one can be absorbed into either table. We decide which by comparing
-    # the names, just as happens in Concept.populate_reference (see reference.rb)
+    # the names, just as happens in ObjectType.populate_reference (see reference.rb)
     class Role
       def counterpart_unary_has_precedence
-        counterpart_concept.is_table_subtype and
+        counterpart_object_type.is_table_subtype and
           counterpart.unique and
           owner.name.downcase < counterpart.owner.name.downcase
       end

data/lib/activefacts/persistence/reference.rb

@@ -1,18 +1,18 @@
 #
 #       ActiveFacts Relational mapping and persistence.
-#       Reference from one Concept to another, used to decide the relational mapping.
+#       Reference from one ObjectType to another, used to decide the relational mapping.
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
-# A Reference from one Concept to another is created for each many-1 or 1-1 relationship
-# (including subtyping), and also for a unary role (implicitly to Boolean concept).
+# A Reference from one ObjectType to another is created for each many-1 or 1-1 relationship
+# (including subtyping), and also for a unary role (implicitly to Boolean object_type).
 # A 1-1 or subtyping reference should be created in only one direction, and may be flipped
 # if needed.
 #
-# A reference to a concept that's a table or is fully absorbed into a table will
-# become a foreign key, otherwise it will absorb all that concept's references.
+# A reference to a object_type that's a table or is fully absorbed into a table will
+# become a foreign key, otherwise it will absorb all that object_type's references.
 #
-# Reference objects update each concept's list of the references *to* and *from* that concept.
+# Reference objects update each object_type's list of the references *to* and *from* that object_type.
 #
 # Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
 #
@@ -22,9 +22,9 @@ module ActiveFacts
 
     # This class contains the core data structure used in composing a relational schema.
     #
-    # A Reference is *from* one Concept *to* another Concept, and relates to the *from_role* and the *to_role*.
-    # When either Concept is an objectified fact type, the corresponding role is nil.
-    # When the Reference from_role is of a unary fact type, there's no to_role or to Concept.
+    # A Reference is *from* one ObjectType *to* another ObjectType, and relates to the *from_role* and the *to_role*.
+    # When either ObjectType is an objectified fact type, the corresponding role is nil.
+    # When the Reference from_role is of a unary fact type, there's no to_role or to ObjectType.
     # The final kind of Reference is a self-reference which is added to a ValueType that becomes a table.
     #
     # When the underlying fact type is a one-to-one (including an inheritance fact type), the Reference may be flipped.
@@ -40,7 +40,7 @@ module ActiveFacts
       attr_reader :from_role, :to_role  # For objectified facts, one role will be nil (a phantom)
       attr_reader :fact_type
 
-      # A Reference is created from a concept in regard to a role it plays
+      # A Reference is created from a object_type in regard to a role it plays
       def initialize(from, role)
         @from = from
         return unless role              # All done if it's a self-value reference for a ValueType
@@ -52,14 +52,14 @@ module ActiveFacts
         elsif (role.fact_type.entity_type == @from)  # role is in "from", an objectified fact type
           @from_role = nil                      # Phantom role
           @to_role = role
-          @to = @to_role.concept
+          @to = @to_role.object_type
         else
           @from_role = role
           @to = role.fact_type.entity_type      # If set, to_role is a phantom
           unless @to
             raise "Illegal reference through >binary fact type" if @fact_type.all_role.size >2
             @to_role = (role.fact_type.all_role-[role])[0]
-            @to = @to_role.concept
+            @to = @to_role.object_type
           end
         end
       end
@@ -98,7 +98,7 @@ module ActiveFacts
         !@to && !@to_role
       end
 
-      # Is the *to* concept fully absorbed through this reference?
+      # Is the *to* object_type fully absorbed through this reference?
       def is_absorbing
         @to && @to.absorbed_via == self
       end
@@ -127,7 +127,28 @@ module ActiveFacts
           @to_role.role_name.camelwords
         else                            # Use the name from the preferred reading
           role_ref = @to_role.preferred_reference
-          [role_ref.leading_adjective, @to_role.concept.name, role_ref.trailing_adjective].compact.map{|w| w.camelwords}.flatten.reject{|s| s == ''}
+          [role_ref.leading_adjective, @to_role.object_type.name, role_ref.trailing_adjective].compact.map{|w| w.camelwords}.flatten.reject{|s| s == ''}
+        end
+      end
+
+      # Return the array of names for the (perhaps implicit) *from_role* of this Reference
+      def from_names
+        case
+        when is_unary
+          if @from && @from.fact_type
+            @from.name.camelwords
+          else
+            @from_role.fact_type.preferred_reading.text.gsub(/\{[0-9]\}/,'').strip.camelwords
+          end
+        when @from && !@from_role           # @from is an objectified fact type so @from_role is a phantom
+          @from.name.camelwords
+        when !@from_role                  # Self-value role of an independent ValueType
+          @from.name.camelwords + ["Value"]
+        when @from_role.role_name         # Named role
+          @from_role.role_name.camelwords
+        else                            # Use the name from the preferred reading
+          role_ref = @from_role.preferred_reference
+          [role_ref.leading_adjective, @from_role.object_type.name, role_ref.trailing_adjective].compact.map{|w| w.camelwords}.flatten.reject{|s| s == ''}
         end
       end
 
@@ -172,7 +193,7 @@ module ActiveFacts
 
       # The reading for the fact type underlying this Reference
       def reading
-        is_self_value ? "#{from.name} has value" : @fact_type.default_reading([], true) # Include role name defn's
+        is_self_value ? "#{from.name} has value" : @fact_type.default_reading
       end
 
       def inspect #:nodoc:
@@ -182,11 +203,11 @@ module ActiveFacts
   end
 
   module Metamodel          #:nodoc:
-    class Concept
+    class ObjectType
       # Say whether the independence of this object is still under consideration
       # This is used in detecting dependency cycles, such as occurs in the Metamodel
       attr_accessor :tentative          #:nodoc:
-      attr_writer :is_table             # The two Concept subclasses provide the attr_reader method
+      attr_writer :is_table             # The two ObjectType subclasses provide the attr_reader method
 
       def show_tabular                  #:nodoc:
         (tentative ? "tentatively " : "") +
@@ -213,17 +234,17 @@ module ActiveFacts
         @tentative = true
       end
 
-      # References from this Concept
+      # References from this ObjectType
       def references_from
         @references_from ||= []
       end
 
-      # References to this Concept
+      # References to this ObjectType
       def references_to
         @references_to ||= []
       end
 
-      # True if this Concept has any References (to or from)
+      # True if this ObjectType has any References (to or from)
       def has_references                #:nodoc:
         @references_from || @references_to
       end
@@ -236,7 +257,11 @@ module ActiveFacts
 
       def populate_references           #:nodoc:
         all_role.each do |role|
-          populate_reference role unless role.fact_type.is_a?(ImplicitFactType)
+          # It's possible that this role is in an implicit or derived fact type. Skip it if so.
+          next if role.fact_type.is_a?(ImplicitFactType) or
+            role.fact_type.preferred_reading.role_sequence.all_role_ref.to_a[0].join_role
+          
+          populate_reference role
         end
       end
 
@@ -321,12 +346,12 @@ module ActiveFacts
             r.tabulate
           end
         else
-          raise "Illegal role type, #{role.fact_type.describe(role)} no uniqueness constraint"
+          raise "Role #{role.object_type.name} in '#{role.fact_type.default_reading}' lacks a uniqueness constraint"
         end
       end
     end
 
-    class EntityType < Concept
+    class EntityType < ObjectType
       def populate_references          #:nodoc:
         if fact_type && fact_type.all_role.size > 1
           # NOT: fact_type.all_role.each do |role|  # Place roles in the preferred order instead:
@@ -340,23 +365,23 @@ module ActiveFacts
 
     class Vocabulary
       def populate_all_references #:nodoc:
-        debug :references, "Populating all concept references" do
-          all_concept.each do |concept|
-            concept.clear_references
-            concept.is_table = nil      # Undecided; force an attempt to decide
-            concept.tentative = true    # Uncertain
+        debug :references, "Populating all object_type references" do
+          all_object_type.each do |object_type|
+            object_type.clear_references
+            object_type.is_table = nil      # Undecided; force an attempt to decide
+            object_type.tentative = true    # Uncertain
           end
-          all_concept.each do |concept|
-            debug :references, "Populating references for #{concept.name}" do
-              concept.populate_references
+          all_object_type.each do |object_type|
+            debug :references, "Populating references for #{object_type.name}" do
+              object_type.populate_references
             end
           end
         end
-        debug :references, "Finished concept references" do
-          all_concept.each do |concept|
-            next unless concept.references_from.size > 0
-            debug :references, "#{concept.name}:" do
-              concept.references_from.each do |ref|
+        debug :references, "Finished object_type references" do
+          all_object_type.each do |object_type|
+            next unless object_type.references_from.size > 0
+            debug :references, "#{object_type.name}:" do
+              object_type.references_from.each do |ref|
                 debug :references, "#{ref}"
               end
             end

data/lib/activefacts/persistence/tables.rb

@@ -1,7 +1,7 @@
 #
 #       ActiveFacts Relational mapping and persistence.
 #       Tables; Calculate the relational composition of a given Vocabulary.
-#       The composition consists of decisions about which Concepts are tables,
+#       The composition consists of decisions about which ObjectTypes are tables,
 #       and what columns (absorbed roled) those tables will have.
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
@@ -17,7 +17,7 @@ require 'activefacts/persistence/reference'
 module ActiveFacts
   module Metamodel
 
-    class ValueType < Concept
+    class ValueType < ObjectType
       def absorbed_via  #:nodoc:
         # ValueTypes aren't absorbed in the way EntityTypes are
         nil
@@ -55,7 +55,7 @@ module ActiveFacts
       end
     end
 
-    class EntityType < Concept
+    class EntityType < ObjectType
       # A Reference from an entity type that fully absorbs this one
       def absorbed_via; @absorbed_via; end
       def absorbed_via=(r) #:nodoc:
@@ -81,13 +81,15 @@ module ActiveFacts
         # Always a table if nowhere else to go, and has no one-to-ones that might flip:
         if references_to.empty? and
             !references_from.detect{|ref| ref.role_type == :one_one }
-          debug :absorption, "EntityType #{name} is independent as it has nowhere to go"
+          debug :absorption, "EntityType #{name} is presumed independent as it has nowhere to go"
           return @is_table = true
         end
 
         # Subtypes are not a table unless partitioned or separate
         # REVISIT: Support partitioned subtypes here
         if (!supertypes.empty?)
+          as_ti = all_supertype_inheritance.detect{|ti| ti.assimilation}
+          debug :absorption, "EntityType #{name} is #{as_ti ? as_ti.assimilation+' from' : 'absorbed into'} supertype #{(as_ti ? as_ti.supertype : supertypes[0]).name}"
           return @is_table = all_supertype_inheritance.detect{|ti| ti.assimilation} != nil
         end
 
@@ -96,8 +98,8 @@ module ActiveFacts
         # to manage the auto-assignment.
         if references_to.size > 1 and
           preferred_identifier.role_sequence.all_role_ref.detect {|rr|
-            next false unless rr.role.concept.is_a? ValueType
-            rr.role.concept.is_auto_assigned
+            next false unless rr.role.object_type.is_a? ValueType
+            rr.role.object_type.is_auto_assigned
           }
           debug :absorption, "#{name} has an auto-assigned counter in its ID, so must be a table"
           @tentative = false
@@ -113,7 +115,7 @@ module ActiveFacts
       def role_type
         # TypeInheritance roles are always 1:1
         if TypeInheritance === fact_type
-          return concept == fact_type.supertype ? :supertype : :subtype
+          return object_type == fact_type.supertype ? :supertype : :subtype
         end
 
         # Always N:1 if unary:
@@ -156,7 +158,7 @@ module ActiveFacts
     end
 
     class Vocabulary
-      # return an Array of Concepts that will have their own tables
+      # return an Array of ObjectTypes that will have their own tables
       def tables
         decide_tables if !@tables
         @tables
@@ -164,9 +166,9 @@ module ActiveFacts
 
       def decide_tables #:nodoc:
         # Strategy:
-        # 1) Populate references for all Concepts
-        # 2) Decide which Concepts must be and must not be tables
-        #  a. Concepts labelled is_independent are tables (See the is_table methods above)
+        # 1) Populate references for all ObjectTypes
+        # 2) Decide which ObjectTypes must be and must not be tables
+        #  a. ObjectTypes labelled is_independent are tables (See the is_table methods above)
         #  b. Entity types having no references to them must be tables
         #  c. subtypes are not tables unless marked with assimilation = separate or partitioned
         #  d. ValueTypes are never tables unless they can have references (to other ValueTypes)
@@ -181,18 +183,18 @@ module ActiveFacts
         populate_all_references
 
         debug :absorption, "Calculating relational composition" do
-          # Evaluate the possible independence of each concept, building an array of concepts of indeterminate status:
+          # Evaluate the possible independence of each object_type, building an array of object_types of indeterminate status:
           undecided =
-            all_concept.select do |concept|
-              concept.is_table          # Ask it whether it thinks it should be a table
-              concept.tentative         # Selection criterion
+            all_object_type.select do |object_type|
+              object_type.is_table          # Ask it whether it thinks it should be a table
+              object_type.tentative         # Selection criterion
             end
 
-          if debug :absorption, "Generating tables, #{undecided.size} undecided"
-            (all_concept-undecided).each {|concept|
-              next if ValueType === concept && !concept.is_table  # Skip unremarkable cases
+          if debug :absorption, "Generating tables, #{undecided.size} undecided, already decided ones are"
+            (all_object_type-undecided).each {|object_type|
+              next if ValueType === object_type && !object_type.is_table  # Skip unremarkable cases
               debug :absorption do
-                debug :absorption, "#{concept.name} is #{concept.is_table ? "" : "not "}a table#{concept.tentative ? ", tentatively" : ""}"
+                debug :absorption, "#{object_type.name} is #{object_type.is_table ? "" : "not "}a table#{object_type.tentative ? ", tentatively" : ""}"
               end
             }
           end
@@ -203,50 +205,50 @@ module ActiveFacts
             debug :absorption, "Starting composition pass #{pass} with #{undecided.size} undecided tables"
             possible_flips = {}         # A hash by table containing an array of references that can be flipped
             finalised =                 # Make an array of things we finalised during this pass
-              undecided.select do |concept|
-                debug :absorption, "Considering #{concept.name}:" do
-                  debug :absorption, "refs to #{concept.name} are from #{concept.references_to.map{|ref| ref.from.name}*", "}" if concept.references_to.size > 0
-                  debug :absorption, "refs from #{concept.name} are to #{concept.references_from.map{|ref| ref.to.name rescue ref.fact_type.default_reading}*", "}" if concept.references_from.size > 0
+              undecided.select do |object_type|
+                debug :absorption, "Considering #{object_type.name}:" do
+                  debug :absorption, "refs to #{object_type.name} are from #{object_type.references_to.map{|ref| ref.from.name}*", "}" if object_type.references_to.size > 0
+                  debug :absorption, "refs from #{object_type.name} are to #{object_type.references_from.map{|ref| ref.to.name rescue ref.fact_type.default_reading}*", "}" if object_type.references_from.size > 0
 
                   # Always absorb an objectified unary into its role player:
-                  if concept.fact_type && concept.fact_type.all_role.size == 1
-                    debug :absorption, "Absorb objectified unary #{concept.name} into #{concept.fact_type.entity_type.name}"
-                    concept.definitely_not_table
-                    next concept
+                  if object_type.fact_type && object_type.fact_type.all_role.size == 1
+                    debug :absorption, "Absorb objectified unary #{object_type.name} into #{object_type.fact_type.entity_type.name}"
+                    object_type.definitely_not_table
+                    next object_type
                   end
 
                   # If the PI contains one role only, played by an entity type that can absorb us, do that.
-                  pi_roles = concept.preferred_identifier.role_sequence.all_role_ref.map(&:role)
-                  debug :absorption, "pi_roles are played by #{pi_roles.map{|role| role.concept.name}*", "}"
+                  pi_roles = object_type.preferred_identifier.role_sequence.all_role_ref.map(&:role)
+                  debug :absorption, "pi_roles are played by #{pi_roles.map{|role| role.object_type.name}*", "}"
                   first_pi_role = pi_roles[0]
                   pi_ref = nil
                   if pi_roles.size == 1 and
-                    concept.references_to.detect{|ref| pi_ref = ref if ref.from_role == first_pi_role && ref.from.is_a?(EntityType)}
+                    object_type.references_to.detect{|ref| pi_ref = ref if ref.from_role == first_pi_role && ref.from.is_a?(EntityType)}
 
-                    debug :absorption, "#{concept.name} is fully absorbed along its sole reference path into entity type #{pi_ref.from.name}"
-                    concept.definitely_not_table
-                    next concept
+                    debug :absorption, "#{object_type.name} is fully absorbed along its sole reference path into entity type #{pi_ref.from.name}"
+                    object_type.definitely_not_table
+                    next object_type
                   end
 
                   # If there's more than one absorption path and any functional dependencies that can't absorb us, it's a table
                   non_identifying_refs_from =
-                    concept.references_from.reject{|ref|
+                    object_type.references_from.reject{|ref|
                       pi_roles.include?(ref.to_role)
                     }
-                  debug :absorption, "#{concept.name} has #{non_identifying_refs_from.size} non-identifying functional roles"
+                  debug :absorption, "#{object_type.name} has #{non_identifying_refs_from.size} non-identifying functional roles"
 
-                  if concept.references_to.size > 1 and
+                  if object_type.references_to.size > 1 and
                       non_identifying_refs_from.size > 0
-                    debug :absorption, "#{concept.name} has non-identifying functional dependencies so 3NF requires it be a table"
-                    concept.definitely_table
-                    next concept
+                    debug :absorption, "#{object_type.name} has non-identifying functional dependencies so 3NF requires it be a table"
+                    object_type.definitely_table
+                    next object_type
                   end
 
                   absorption_paths =
                     (
                       non_identifying_refs_from.reject do |ref|
                         !ref.to or ref.to.absorbed_via == ref
-                      end+concept.references_to
+                      end+object_type.references_to
                     ).reject do |ref|
                       next true if !ref.to.is_table or
                         ![:one_one, :supertype, :subtype].include?(ref.role_type)
@@ -255,29 +257,29 @@ module ActiveFacts
                       from_is_mandatory = !!ref.is_mandatory
                       to_is_mandatory = !ref.to_role || !!ref.to_role.is_mandatory
 
-                      bad = !(ref.from == concept ? from_is_mandatory : to_is_mandatory)
-                      debug :absorption, "Not absorbing #{concept.name} through non-mandatory #{ref}" if bad
+                      bad = !(ref.from == object_type ? from_is_mandatory : to_is_mandatory)
+                      debug :absorption, "Not absorbing #{object_type.name} through non-mandatory #{ref}" if bad
                       bad
                     end
 
                   # If this object can be fully absorbed, do that (might require flipping some references)
                   if absorption_paths.size > 0
-                    debug :absorption, "#{concept.name} is fully absorbed through #{absorption_paths.inspect}"
+                    debug :absorption, "#{object_type.name} is fully absorbed through #{absorption_paths.inspect}"
                     absorption_paths.each do |ref|
-                      debug :absorption, "flip #{ref} so #{concept.name} can be absorbed"
-                      ref.flip if concept == ref.from
+                      debug :absorption, "flip #{ref} so #{object_type.name} can be absorbed"
+                      ref.flip if object_type == ref.from
                     end
-                    concept.definitely_not_table
-                    next concept
+                    object_type.definitely_not_table
+                    next object_type
                   end
 
                   if non_identifying_refs_from.size == 0
-#                    and (!concept.is_a?(EntityType) ||
+#                    and (!object_type.is_a?(EntityType) ||
 #                      # REVISIT: The roles may be collectively but not individually mandatory.
-#                      concept.references_to.detect { |ref| !ref.from_role || ref.from_role.is_mandatory })
-                    debug :absorption, "#{concept.name} is fully absorbed in #{concept.references_to.size} places: #{concept.references_to.map{|ref| ref.from.name}*", "}"
-                    concept.definitely_not_table
-                    next concept
+#                      object_type.references_to.detect { |ref| !ref.from_role || ref.from_role.is_mandatory })
+                    debug :absorption, "#{object_type.name} is fully absorbed in #{object_type.references_to.size} places: #{object_type.references_to.map{|ref| ref.from.name}*", "}"
+                    object_type.definitely_not_table
+                    next object_type
                   end
 
                   false   # Failed to decide about this entity_type this time around
@@ -290,18 +292,18 @@ module ActiveFacts
 
           # A ValueType that isn't explicitly a table and isn't needed anywhere doesn't matter,
           # unless it should absorb something else (another ValueType is all it could be):
-          all_concept.each do |concept|
-            if (!concept.is_table and concept.references_to.size == 0 and concept.references_from.size > 0)
-              debug :absorption, "Making #{concept.name} a table; it has nowhere else to go and needs to absorb things"
-              concept.probably_table
+          all_object_type.each do |object_type|
+            if (!object_type.is_table and object_type.references_to.size == 0 and object_type.references_from.size > 0)
+              debug :absorption, "Making #{object_type.name} a table; it has nowhere else to go and needs to absorb things"
+              object_type.probably_table
             end
           end
 
           # Now, evaluate all possibilities of the tentative assignments
           # Incomplete. Apparently unnecessary as well... so far. We'll see.
           if debug :absorption
-            undecided.each do |concept|
-              debug :absorption, "Unable to decide independence of #{concept.name}, going with #{concept.show_tabular}"
+            undecided.each do |object_type|
+              debug :absorption, "Unable to decide independence of #{object_type.name}, going with #{object_type.show_tabular}"
             end
           end
         end
@@ -310,7 +312,7 @@ module ActiveFacts
         populate_all_indices
 
         @tables =
-          all_concept.
+          all_object_type.
           select { |f| f.is_table }.
           sort_by { |table| table.name }
       end