activefacts 1.0.2 → 1.1.0

data/lib/activefacts/persistence/columns.rb

@@ -78,7 +78,7 @@ module ActiveFacts
                 ref.to.is_a?(ActiveFacts::Metamodel::EntityType) and
                 (role_ref = ref.to.preferred_identifier.role_sequence.all_role_ref.single) and
                 role_ref.role == ref.from_role
-              debug :columns, "Skipping #{ref}, identifies non-initial object"
+              trace :columns, "Skipping #{ref}, identifies non-initial object"
               next a
             end
 
@@ -87,19 +87,19 @@ module ActiveFacts
             # When traversing type inheritances, keep the subtype name, not the supertype names as well:
             if a.size > 0 && ref.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
               if ref.to != ref.fact_type.subtype  # Did we already have the subtype?
-                debug :columns, "Skipping supertype #{ref}"
+                trace :columns, "Skipping supertype #{ref}"
                 next a
               end
-              debug :columns, "Eliding supertype in #{ref}"
+              trace :columns, "Eliding supertype in #{ref}"
               last_names.size.times { a.pop }   # Remove the last names added
             elsif last_names.last && last_names.last == names[0][0...last_names.last.size] 
               # When Xyz is followed by XyzID, truncate that to just ID
-              debug :columns, "truncating repeated #{last_names.last} in #{names[0]}"
+              trace :columns, "truncating repeated #{last_names.last} in #{names[0]}"
               names[0] = names[0][last_names.last.size..-1]
               names.shift if names[0] == ''
             elsif last_names.last == names[0]
               # Same, but where an underscore split up the words
-              debug :columns, "truncating repeated name in #{names.inspect}"
+              trace :columns, "truncating repeated name in #{names.inspect}"
               names.shift
             end
 
@@ -113,7 +113,7 @@ module ActiveFacts
                 role_ref.role == ref.to_role and
                 names[0][0...et.name.size].downcase == et.name.downcase
 
-              debug :columns, "truncating transitive identifying role #{names.inspect}"
+              trace :columns, "truncating transitive identifying role #{names.inspect}"
               names[0] = names[0][et.name.size..-1]
               names.shift if names[0] == ""
             end
@@ -177,10 +177,18 @@ module ActiveFacts
       # The comment is the readings from the References expressed as a series of steps (not a full verbalisation)
       def comment
         @references.map do |ref|
-          (ref.is_mandatory ? "" : "maybe ") +
-          (ref.fact_type && ref.fact_type.entity_type ? ref.fact_type.entity_type.name+" is where " : "") +
-          ref.reading
-        end * " and "
+	  # REVISIT: Some contraction would be nice here
+          objectification = ref.fact_type && ref.fact_type.entity_type
+	  involves = ''
+	  if objectification && ref == @references.last
+	    objectification = nil if ref.fact_type.all_role.size == 1	# Disregard the objectification of a trailing unary
+	    involves = ref.to_role.link_fact_type.default_reading[ref.fact_type.entity_type.name.size..-1]
+	  end
+	  (objectification ? objectification.name + ' (in which ' : '') +
+          (ref.is_mandatory || ref.is_unary ? '' : 'maybe ') +
+          ref.reading +
+	  (objectification ? ')'+involves : '')
+        end.compact * " and "
       end
 
       def to_s  #:nodoc:
@@ -194,8 +202,34 @@ module ActiveFacts
         cols = 
           if is_unary
             kind = "unary "
-            [Column.new()] +
-              ((@to && @to.fact_type) ?  @to.all_columns(excluded_supertypes) : [])
+	    objectified_unary_columns =
+	      ((@to && @to.fact_type) ?  @to.all_columns(excluded_supertypes) : [])
+
+=begin
+	    # This code omits the unary if it's objectified and that plays a mandatory role
+	    first_mandatory_column = nil
+	    if (@to && @to.fact_type)
+	      trace :unary_col, "Deciding whether to skip unary column for #{inspect}" do
+		first_mandatory_column =
+		  objectified_unary_columns.detect do |col|	# Detect a mandatory column for the unary
+		    trace :unary_col, "checking column #{col.name}" do
+		      !col.references.detect do |ref|
+			trace :unary_col, "#{ref} is mandatory=#{ref.is_mandatory.inspect}"
+			!ref.is_mandatory
+		      end
+		    end
+		  end
+		if is_from_objectified_fact && first_mandatory_column
+		  trace :unary_col, "Skipping unary column for #{inspect} because #{first_mandatory_column.name} is mandatory"
+		end
+	      end
+	    end
+
+            (is_from_objectified_fact && first_mandatory_column ? [] : [Column.new()]) +	  # The unary itself, unless its objectified
+=end
+
+            [Column.new()] +	  # The unary itself
+	      objectified_unary_columns
           elsif is_self_value
             kind = "self-role "
             [Column.new()]
@@ -210,9 +244,9 @@ module ActiveFacts
           c.prepend self
         end
 
-        debug :columns, "Columns from #{kind}#{self}" do
+        trace :columns, "Columns from #{kind}#{self}" do
           cols.each {|c|
-            debug :columns, "#{c}"
+            trace :columns, "#{c}"
           }
         end
       end
@@ -239,7 +273,7 @@ module ActiveFacts
     class ValueType < DomainObjectType
       # The identifier_columns for a ValueType can only ever be the self-value role that was injected
       def identifier_columns
-        debug :columns, "Identifier Columns for #{name}" do
+        trace :columns, "Identifier Columns for #{name}" do
           raise "Illegal call to identifier_columns for absorbed ValueType #{name}" unless is_table
           if isr = injected_surrogate_role
             columns.select{|column| column.references[0].from_role == isr }
@@ -252,7 +286,7 @@ module ActiveFacts
       # When creating a foreign key to this ValueType, what columns must we include?
       # This must be a fresh copy, because the columns will have References prepended
       def reference_columns(excluded_supertypes)  #:nodoc:
-        debug :columns, "Reference Columns for #{name}" do
+        trace :columns, "Reference Columns for #{name}" do
           if is_table
             if isr = injected_surrogate_role
               ref_from = references_from.detect{|ref| ref.from_role == isr}
@@ -270,14 +304,14 @@ module ActiveFacts
       # This must be a fresh copy, because the columns will have References prepended.
       def all_columns(excluded_supertypes)    #:nodoc:
         columns = []
-        debug :columns, "All Columns for #{name}" do
+        trace :columns, "All Columns for #{name}" do
           if is_table
             self_value_reference
           else
             columns << ActiveFacts::Persistence::Column.new
           end
           references_from.each do |ref|
-            debug :columns, "Columns absorbed via #{ref}" do
+            trace :columns, "Columns absorbed via #{ref}" do
               columns += ref.columns({})
             end
           end
@@ -297,7 +331,7 @@ module ActiveFacts
     class EntityType < DomainObjectType
       # The identifier_columns for an EntityType are the columns that result from the identifying roles
       def identifier_columns
-        debug :columns, "Identifier Columns for #{name}" do
+        trace :columns, "Identifier Columns for #{name}" do
           if absorbed_via and
             # If this is a subtype that has its own identification, use that.
             (all_type_inheritance_as_subtype.size == 0 ||
@@ -316,16 +350,17 @@ module ActiveFacts
       # When creating a foreign key to this EntityType, what columns must we include (the identifier columns)?
       # This must be a fresh copy, because the columns will have References prepended
       def reference_columns(excluded_supertypes)    #:nodoc:
-        debug :columns, "Reference Columns for #{name}" do
+        trace :columns, "Reference Columns for #{name}" do
 
           if absorbed_via and
             # If this is not a subtype, or is a subtype that has its own identification, use the id.
             (all_type_inheritance_as_subtype.size == 0 ||
               all_type_inheritance_as_subtype.detect{|ti| ti.provides_identification })
             rc = absorbed_via.from.reference_columns(excluded_supertypes)
-            # The absorbed_via reference gets skipped here, ans also in object_type.rb
-            debug :columns, "Skipping #{absorbed_via}"
-            #rc.each{|col| col.prepend(absorbed_via)}
+            # The absorbed_via reference gets skipped here, and also in object_type.rb
+            trace :columns, "Skipping #{absorbed_via}"
+            absorbed_mirror ||= absorbed_via.reversed
+            rc.each{|col| col.prepend(absorbed_mirror)}
             return rc
           end
 
@@ -344,7 +379,7 @@ module ActiveFacts
       # When absorbing this EntityType, what columns must be absorbed?
       # This must be a fresh copy, because the columns will have References prepended.
       def all_columns(excluded_supertypes)    #:nodoc:
-        debug :columns, "All Columns for #{name}" do
+        trace :columns, "All Columns for #{name}" do
           columns = []
           sups = supertypes
           pi_roles = preferred_identifier.role_sequence.all_role_ref.map{|rr| rr.role}
@@ -357,10 +392,10 @@ module ActiveFacts
             end
             [3, ref.to_names]
           end.each do |ref|
-            debug :columns, "Columns absorbed via #{ref}" do
+            trace :columns, "Columns absorbed via #{ref}" do
               if (ref.role_type == :supertype)
                 if excluded_supertypes[ref.to]
-                  debug :columns, "Exclude #{ref.to.name}, we already inherited it"
+                  trace :columns, "Exclude #{ref.to.name}, we already inherited it"
                   next
                 end
 
@@ -392,20 +427,20 @@ module ActiveFacts
         # REVISIT: Is now a good time to apply schema transforms or should this be more explicit?
         finish_schema
 
-        debug :columns, "Populating all columns" do
+        trace :columns, "Populating all columns" do
           all_object_type.each do |object_type|
             next if !object_type.is_table
-            debug :columns, "Populating columns for table #{object_type.name}" do
+            trace :columns, "Populating columns for table #{object_type.name}" do
               object_type.populate_columns
             end
           end
         end
-        debug :columns, "Finished columns" do
+        trace :columns, "Finished columns" do
           all_object_type.each do |object_type|
             next if !object_type.is_table
-            debug :columns, "Finished columns for table #{object_type.name}" do
+            trace :columns, "Finished columns for table #{object_type.name}" do
               object_type.columns.each do |column|
-                debug :columns, "#{column}"
+                trace :columns, "#{column}"
               end
             end
           end

data/lib/activefacts/persistence/foreignkey.rb

@@ -107,7 +107,7 @@ module ActiveFacts
 	    ref.fk_jump = true
             array << [ref]
           elsif ref.is_absorbing or (ref.to && !ref.to.is_table)
-	    debug :fk, "getting fks absorbed into #{name} via #{ref}" do
+	    trace :fk, "getting fks absorbed into #{name} via #{ref}" do
 	      ref.to.all_absorbed_foreign_key_reference_path.each do |aref|
 		array << aref.insert(0, ref)
 	      end
@@ -129,24 +129,24 @@ module ActiveFacts
 	  begin
 	    fk_ref_paths = all_absorbed_foreign_key_reference_path
 	    fk_ref_paths.map do |fk_ref_path|
-	      debug :fk, "\nFK: " + fk_ref_path.map{|fk_ref| fk_ref.reading }*" and " do
+	      trace :fk, "\nFK: " + fk_ref_path.map{|fk_ref| fk_ref.reading }*" and " do
 
 		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 }*", "}"
+		trace :fk, "from_columns = #{from_columns.map { |column| column.name }*", "}"
 
 		# Figure out absorption on the target end:
 		to = fk_ref_path.last.to
 		if to.absorbed_via
-		  debug :fk, "Reference target #{fk_ref_path.last.to.name} is absorbed via:" do
+		  trace :fk, "Reference target #{fk_ref_path.last.to.name} is absorbed via:" do
 		    while (r = to.absorbed_via)
 		      m = r.reversed
-		      debug :fk, "#{m.reading}"
+		      trace :fk, "#{m.reading}"
 		      fk_ref_path << m
 		      to = m.from == to ? m.to : m.from
 		    end
-		    debug :fk, "Absorption ends at #{to.name}"
+		    trace :fk, "Absorption ends at #{to.name}"
 		  end
 		end
 

data/lib/activefacts/persistence/index.rb

@@ -124,13 +124,13 @@ module ActiveFacts
         # Note also that this produces columns ordered for each refpath the same as the
         # order of the columns, not the same as the columns in the PK for which they might be an FK.
         all_column_by_ref_path =
-          debug :index2, "Indexing columns by ref_path" do
+          trace :index2, "Indexing columns by ref_path" do
             columns.inject({}) do |hash, column|
-              debug :index2, "References in column #{name}.#{column.name}" do
+              trace :index2, "References in column #{name}.#{column.name}" do
                 ref_path = column.absorption_references
                 raise "No absorption_references for #{column.name} from #{column.references.map(&:to_s)*" and "}" if !ref_path || ref_path.empty?
                 (hash[ref_path] ||= []) << column
-                debug :index2, "#{column.name} involves #{ref_path.map(&:to_s)*" and "}"
+                trace :index2, "#{column.name} involves #{ref_path.map(&:to_s)*" and "}"
               end
               hash
             end
@@ -143,7 +143,7 @@ module ActiveFacts
             inject({}) do |hash, ref_path|
               ref_path.each do |ref|
                 next unless ref.to_role
-                # debug :index2, "Considering #{ref_path.map(&:to_s)*" and "} yielding columns #{all_column_by_ref_path[ref_path].map{|c| c.name('.')}*", "}"
+                # trace :index2, "Considering #{ref_path.map(&:to_s)*" and "} yielding columns #{all_column_by_ref_path[ref_path].map{|c| c.name('.')}*", "}"
                 ref.to_role.all_role_ref.each do |role_ref|
                   all_pcs = role_ref.role_sequence.all_presence_constraint
 		  # puts "pcs over #{ref_path.map{|r| r.to_names}.flatten*'.'}: #{role_ref.role_sequence.all_presence_constraint.map(&:describe)*"; "}" if all_pcs.size > 0
@@ -171,9 +171,9 @@ module ActiveFacts
               hash
             end
 
-        debug :index, "All Indices in #{name}:" do
+        trace :index, "All Indices in #{name}:" do
           @indices = columns_by_unique_constraint.map do |uc, columns_with_ordinal|
-            debug :index, "Index due to uc #{uc.concept.guid} on #{name} over (#{columns_with_ordinal.sort_by{|onc|onc[0]}.map{|ca| ca[2].name}.inspect})"
+            trace :index, "Index due to uc #{uc.concept.guid} on #{name} over (#{columns_with_ordinal.sort_by{|onc|onc[0]}.map{|ca| ca[2].name}.inspect})"
             columns = columns_with_ordinal.sort_by{|ca| [ca[0,2], ca[2].name]}.map{|ca| ca[2]}
             absorption_level = columns.map(&:absorption_level).min
             over = columns[0].references[absorption_level].from
@@ -193,7 +193,7 @@ module ActiveFacts
               columns,
               uc.is_preferred_identifier
             )
-            debug :index, index
+            trace :index, index
             index
           end.
           compact.
@@ -211,24 +211,24 @@ module ActiveFacts
 
     class Vocabulary
       def populate_all_indices  #:nodoc:
-        debug :index, "Populating all object_type indices" do
+        trace :index, "Populating all object_type indices" do
           all_object_type.each do |object_type|
             object_type.clear_indices
           end
           all_object_type.each do |object_type|
             next unless object_type.is_table
-            debug :index, "Populating indices for #{object_type.name}" do
+            trace :index, "Populating indices for #{object_type.name}" do
               object_type.populate_indices
             end
           end
         end
-        debug :index, "Finished object_type indices" do
+        trace :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
+            trace :index, "#{object_type.name}:" do
               object_type.indices.each do |index|
-                debug :index, index
+                trace :index, index
               end
             end
           end

data/lib/activefacts/persistence/object_type.rb

@@ -12,12 +12,14 @@ module ActiveFacts
       end
 
       def columns
+raise "This method is no longer in use"
+=begin
         return @columns if @columns
-        debug :persistence, "Calculating columns for #{basename}" do
+        trace :persistence, "Calculating columns for #{basename}" do
           @columns = (
             if superclass.is_entity_type
               # REVISIT: Need keys to secondary supertypes as well, but no duplicates.
-              debug :persistence, "Separate subtype has a foreign key to its supertype" do
+              trace :persistence, "Separate subtype has a foreign key to its supertype" do
                 superclass.__absorb([[superclass.basename]], self)
               end
             else
@@ -28,7 +30,7 @@ module ActiveFacts
               role.unique && !role.counterpart_unary_has_precedence
             end.inject([]) do |columns, role|
               rn = role.name.to_s.split(/_/)
-              debug :persistence, "Role #{rn*'.'}" do
+              trace :persistence, "Role #{rn*'.'}" do
                 columns += role.counterpart_object_type.__absorb([rn], role.counterpart)
               end
             end +
@@ -38,7 +40,7 @@ module ActiveFacts
               inject([]) do |columns, subtype|
                 # Pass self as 2nd param here, not a role, standing for the supertype role
                 subtype_name = subtype.basename
-                debug :persistence, "Absorbing subtype #{subtype_name}" do
+                trace :persistence, "Absorbing subtype #{subtype_name}" do
                   columns += subtype.__absorb([[subtype_name]], self)
                 end
               end
@@ -55,6 +57,7 @@ module ActiveFacts
               end*"."
             end
         end
+=end
       end
 
       # Return an array of the absorbed columns, using prefix for name truncation
@@ -68,7 +71,7 @@ module ActiveFacts
               # 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
+              trace :persistence, "Reference to #{role.name} (absorbed elsewhere)" do
                 role.counterpart_object_type.__absorb(prefix, role.counterpart)
               end
             else
@@ -86,7 +89,7 @@ module ActiveFacts
                 inject([]) do |columns, subtype|
                   # Pass self as 2nd param here, not a role, standing for the supertype role
                   new_prefix = prefix[0..-2] + [[subtype.basename]]
-                  debug :persistence, "Absorbed subtype #{subtype.basename}" do
+                  trace :persistence, "Absorbed subtype #{subtype.basename}" do
                     columns += subtype.__absorb(new_prefix, self)
                   end
                 end
@@ -98,7 +101,7 @@ module ActiveFacts
           # Create a foreign key to the table
           if is_entity_type
             ir = identifying_role_names.map{|role_name| roles(role_name) }
-            debug :persistence, "Reference to #{basename} with #{prefix.inspect}" do
+            trace :persistence, "Reference to #{basename} with #{prefix.inspect}" do
               ic = identifying_role_names.map{|role_name| role_name.to_s.split(/_/)}
               ir.inject([]) do |columns, role|
                 columns += __absorb_role(prefix, role)
@@ -107,7 +110,7 @@ module ActiveFacts
           else
             # Reference to value type which is a table
             col = prefix.clone
-            debug :persistence, "Self-value #{col[-1]}.Value"
+            trace :persistence, "Self-value #{col[-1]}.Value"
             col[-1] += ["Value"]
             col
           end
@@ -122,23 +125,23 @@ module ActiveFacts
             (n = irn[0].to_s.split(/_/)).size > 1 and
             (owner = role.owner.basename.snakecase.split(/_/)) and
             n[0...owner.size] == owner
-          debug :persistence, "truncating transitive identifying role #{n.inspect}"
+          trace :persistence, "truncating transitive identifying role #{n.inspect}"
           owner.size.times { n.shift }
           new_prefix = prefix + [n]
         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
-          #debug :persistence, "=== #{irn[0].to_s.split(/_/)[0]} elided ==="
+          #trace :persistence, "=== #{irn[0].to_s.split(/_/)[0]} elided ==="
           new_prefix = prefix
         elsif (fa_role = fully_absorbed) && fa_role == role
           new_prefix = prefix
         else
           new_prefix = prefix + [role.name.to_s.split(/_/)]
         end
-        #debug :persistence, "new_prefix is #{new_prefix*"."}"
+        #trace :persistence, "new_prefix is #{new_prefix*"."}"
 
-        debug :persistence, "Absorbing role #{role.name} as #{new_prefix[prefix.size..-1]*"."}" do
+        trace :persistence, "Absorbing role #{role.name} as #{new_prefix[prefix.size..-1]*"."}" do
           role.counterpart_object_type.__absorb(new_prefix, role.counterpart)
         end
       end

data/lib/activefacts/persistence/reference.rb

@@ -74,8 +74,9 @@ module ActiveFacts
 
       # Is this Reference covered by a mandatory constraint (implicitly or explicitly)
       def is_mandatory
-        !@from_role ||        # All phantom roles of fact types are mandatory
-        @from_role.is_mandatory
+	!is_unary &&
+	  (!@from_role ||        # All phantom roles of fact types are mandatory
+	    @from_role.is_mandatory)
       end
 
       # Is this Reference from a unary Role?
@@ -188,7 +189,7 @@ module ActiveFacts
         @from.references_from << self
         @to.references_to << self if @to        # Guard against self-values
 
-        debug :references, "Adding #{to_s}"
+        trace :references, "Adding #{to_s}"
         self
       end
 
@@ -196,7 +197,7 @@ module ActiveFacts
         # Remove from @to and @from's reference lists if present
         return unless @from.references_from.delete(self)
         @to.references_to.delete self if @to    # Guard against self-values
-        debug :references, "Dropping #{to_s}"
+        trace :references, "Dropping #{to_s}"
         self
       end
 
@@ -207,7 +208,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
+        is_self_value ? "#{from.name} has value" : @fact_type.reading_preferably_starting_with_role(@from_role).expand
       end
 
       def inspect #:nodoc:
@@ -284,7 +285,7 @@ module ActiveFacts
 
       def populate_reference role       #:nodoc:
         role_type = role.role_type
-        debug :references, "#{name} has #{role_type} role in '#{role.fact_type.describe}'"
+        trace :references, "#{name} has #{role_type} role in '#{role.fact_type.describe}'"
         case role_type
         when :many_one
           ActiveFacts::Persistence::Reference.new(self, role).tabulate      # A simple reference
@@ -294,7 +295,7 @@ module ActiveFacts
             ActiveFacts::Persistence::Reference.new(self, role).tabulate    # A simple reference; check that
           else
             # Can't absorb many of these into one of those
-            #debug :references, "Ignoring #{role_type} reference from #{name} to #{Reference.new(self, role).to.name}"
+            #trace :references, "Ignoring #{role_type} reference from #{name} to #{Reference.new(self, role).to.name}"
           end
 
         when :unary
@@ -304,11 +305,11 @@ module ActiveFacts
           # REVISIT: Or when partitioned
           raise hell unless role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
           if role.fact_type.assimilation  # assimilation == 'separate' or assimilation == 'partitioned'
-            debug :references, "supertype #{name} doesn't absorb a reference to separate subtype #{role.fact_type.subtype.name}"
+            trace :references, "supertype #{name} doesn't absorb a reference to separate subtype #{role.fact_type.subtype.name}"
           else
             r = ActiveFacts::Persistence::Reference.new(self, role)
             r.to.absorbed_via = r
-            debug :references, "supertype #{name} absorbs subtype #{r.to.name}"
+            trace :references, "supertype #{name} absorbs subtype #{r.to.name}"
             r.tabulate
           end
 
@@ -317,7 +318,7 @@ module ActiveFacts
             ActiveFacts::Persistence::Reference.new(self, role).tabulate
             # If partitioned, the supertype is absorbed into *each* subtype; a reference to the supertype needs to know which
           else
-            # debug :references, "subtype #{name} is absorbed into #{role.fact_type.supertype.name}"
+            # trace :references, "subtype #{name} is absorbed into #{role.fact_type.supertype.name}"
           end
 
         when :one_one
@@ -340,11 +341,11 @@ module ActiveFacts
 
             # Force the decision if one EntityType identifies another:
             if preferred_identifier.role_sequence.all_role_ref.detect{|rr| rr.role == r.to_role}
-              debug :references, "EntityType #{name} is identified by EntityType #{r.to.name}, so gets absorbed elsewhere"
+              trace :references, "EntityType #{name} is identified by EntityType #{r.to.name}, so gets absorbed elsewhere"
               return
             end
             if r.to.preferred_identifier.role_sequence.all_role_ref.detect{|rr| rr.role == role}
-              debug :references, "EntityType #{name} identifies EntityType #{r.to.name}, so absorbs it"
+              trace :references, "EntityType #{name} identifies EntityType #{r.to.name}, so absorbs it"
               r.to.absorbed_via = r
               # We can't be absorbed into our supertype!
               # REVISIT: We might need to flip all one-to-ones as well
@@ -362,6 +363,7 @@ module ActiveFacts
             r.tabulate
           end
         else
+	  # REVISIT: Should we implicitly objectify this fact type here and add a spanning UC?
           raise "Role #{role.object_type.name} in '#{role.fact_type.default_reading}' lacks a uniqueness constraint"
         end
       end
@@ -381,9 +383,9 @@ module ActiveFacts
 
     class Vocabulary
       def populate_all_references #:nodoc:
-        debug :references, "Populating all object_type references" do
+        trace :references, "Populating all object_type references" do
           all_object_type.each do |object_type|
-            debug :references, "Populating references for #{object_type.name}" do
+            trace :references, "Populating references for #{object_type.name}" do
               object_type.populate_references
             end
           end
@@ -392,13 +394,13 @@ module ActiveFacts
       end
 
       def show_all_references
-        if debug :references
-          debug :references, "Finished object_type references" do
+        if trace :references
+          trace :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
+              trace :references, "#{object_type.name}:" do
                 object_type.references_from.each do |ref|
-                  debug :references, "#{ref}"
+                  trace :references, "#{ref}"
                 end
               end
             end