activefacts 1.0.2 → 1.1.0

data/lib/activefacts/vocabulary/extensions.rb

@@ -10,7 +10,7 @@ module ActiveFacts
       def finalise
         constellation.FactType.values.each do |fact_type|
           if c = fact_type.check_and_add_spanning_uniqueness_constraint
-            debug :constraint, "Checking for existence of at least one uniqueness constraint over the roles of #{fact_type.default_reading.inspect}"
+            trace :constraint, "Checking for existence of at least one uniqueness constraint over the roles of #{fact_type.default_reading.inspect}"
             fact_type.check_and_add_spanning_uniqueness_constraint = nil
             c.call
           end
@@ -166,7 +166,6 @@ module ActiveFacts
       end
 
       def is_mandatory
-        link_fact_type ||
         all_role_ref.detect{|rr|
           rs = rr.role_sequence
           rs.all_role_ref.size == 1 and
@@ -185,12 +184,16 @@ module ActiveFacts
       def is_functional
         fact_type.entity_type or
         fact_type.all_role.size != 2 or
-          all_role_ref.detect do |rr|
-            rr.role_sequence.all_role_ref.size == 1 and
-              rr.role_sequence.all_presence_constraint.detect do |pc|
-                pc.max_frequency == 1 and !pc.enforcement   # Alethic uniqueness constraint
-              end
-          end
+	is_unique
+      end
+
+      def is_unique
+	all_role_ref.detect do |rr|
+	  rr.role_sequence.all_role_ref.size == 1 and
+	    rr.role_sequence.all_presence_constraint.detect do |pc|
+	      pc.max_frequency == 1 and !pc.enforcement   # Alethic uniqueness constraint
+	    end
+	end
       end
 
     end
@@ -289,7 +292,7 @@ module ActiveFacts
 
           # For a nested fact type, the PI is a unique constraint over N or N-1 roles
           fact_roles = Array(fact_type.all_role)
-          debug :pi, "Looking for PI on nested fact type #{name}" do
+          trace :pi, "Looking for PI on nested fact type #{name}" do
             pi = catch :pi do
                 fact_roles[0,2].each{|r|                  # Try the first two roles of the fact type, that's enough
                     r.all_role_ref.map{|rr|               # All role sequences that reference this role
@@ -323,18 +326,18 @@ module ActiveFacts
                   }
                 throw :pi, nil
               end
-            debug :pi, "Got PI #{pi.name||pi.object_id} for nested #{name}" if pi
-            debug :pi, "Looking for PI on entity that nests this fact" unless pi
+            trace :pi, "Got PI #{pi.name||pi.object_id} for nested #{name}" if pi
+            trace :pi, "Looking for PI on entity that nests this fact" unless pi
             raise "Oops, pi for nested fact is #{pi.class}" unless !pi || pi.is_a?(ActiveFacts::Metamodel::PresenceConstraint)
             return @preferred_identifier = pi if pi
           end
         end
 
-        debug :pi, "Looking for PI for ordinary entity #{name} with #{all_role.size} roles:" do
-          debug :pi, "Roles are in fact types #{all_role.map{|r| r.fact_type.describe(r)}*", "}"
+        trace :pi, "Looking for PI for ordinary entity #{name} with #{all_role.size} roles:" do
+          trace :pi, "Roles are in fact types #{all_role.map{|r| r.fact_type.describe(r)}*", "}"
           pi = catch :pi do
               all_supertypes = supertypes_transitive
-              debug :pi, "PI roles must be played by one of #{all_supertypes.map(&:name)*", "}" if all_supertypes.size > 1
+              trace :pi, "PI roles must be played by one of #{all_supertypes.map(&:name)*", "}" if all_supertypes.size > 1
               all_role.each{|role|
                   next unless role.unique || fact_type
                   ftroles = Array(role.fact_type.all_role)
@@ -342,41 +345,41 @@ module ActiveFacts
                   # Skip roles in ternary and higher fact types, they're objectified, and in unaries, they can't identify us.
                   next if ftroles.size != 2
 
-                  debug :pi, "Considering role in #{role.fact_type.describe(role)}"
+                  trace :pi, "Considering role in #{role.fact_type.describe(role)}"
 
                   # Find the related role which must be included in any PI:
                   # Note this works with unary fact types:
                   pi_role = ftroles[ftroles[0] != role ? 0 : -1]
 
                   next if ftroles.size == 2 && pi_role.object_type == self
-                  debug :pi, "  Considering #{pi_role.object_type.name} as a PI role"
+                  trace :pi, "  Considering #{pi_role.object_type.name} as a PI role"
 
                   # If this is an identifying role, the PI is a PC whose role_sequence spans the role.
                   # Walk through all role_sequences that span this role, and test each:
                   pi_role.all_role_ref.each{|rr|
                       role_sequence = rr.role_sequence  # A role sequence that includes a possible role
 
-                      debug :pi, "    Considering role sequence #{role_sequence.describe}"
+                      trace :pi, "    Considering role sequence #{role_sequence.describe}"
 
                       # All roles in this role_sequence must be in fact types which
                       # (apart from that role) only have roles played by the original
                       # entity type or a supertype.
-                      #debug :pi, "      All supertypes #{all_supertypes.map{|st| "#{st.object_id}=>#{st.name}"}*", "}"
+                      #trace :pi, "      All supertypes #{all_supertypes.map{|st| "#{st.object_id}=>#{st.name}"}*", "}"
                       if role_sequence.all_role_ref.detect{|rsr|
                           fact_type = rsr.role.fact_type
-                          debug :pi, "      Role Sequence touches #{fact_type.describe(pi_role)}"
+                          trace :pi, "      Role Sequence touches #{fact_type.describe(pi_role)}"
 
                           fact_type_roles = fact_type.all_role
-                          debug :pi, "      residual is #{fact_type_roles.map{|r| r.object_type.name}.inspect} minus #{rsr.role.object_type.name}"
+                          trace :pi, "      residual is #{fact_type_roles.map{|r| r.object_type.name}.inspect} minus #{rsr.role.object_type.name}"
                           residual_roles = fact_type_roles-[rsr.role]
                           residual_roles.detect{|rfr|
-                              debug :pi, "        Checking residual role #{rfr.object_type.object_id}=>#{rfr.object_type.name}"
+                              trace :pi, "        Checking residual role #{rfr.object_type.object_id}=>#{rfr.object_type.name}"
 # This next line looks right, but breaks things. Find out what and why:
 #                              !rfr.unique or
                                 !all_supertypes.include?(rfr.object_type)
                             }
                         }
-                        debug :pi, "      Discounting this role_sequence because it includes alien roles"
+                        trace :pi, "      Discounting this role_sequence because it includes alien roles"
                         next
                       end
 
@@ -384,7 +387,7 @@ module ActiveFacts
                       rr.role_sequence.all_presence_constraint.detect{|pc|
                           # Found it!
                           if pc.is_preferred_identifier
-                            debug :pi, "found PI #{pc.name||pc.object_id}, is_preferred_identifier=#{pc.is_preferred_identifier.inspect} over #{pc.role_sequence.describe}"
+                            trace :pi, "found PI #{pc.name||pc.object_id}, is_preferred_identifier=#{pc.is_preferred_identifier.inspect} over #{pc.role_sequence.describe}"
                             throw :pi, pc
                           end
                         }
@@ -393,13 +396,13 @@ module ActiveFacts
               throw :pi, nil
             end
           raise "Oops, pi for entity is #{pi.class}" if pi && !pi.is_a?(ActiveFacts::Metamodel::PresenceConstraint)
-          debug :pi, "Got PI #{pi.name||pi.object_id} for #{name}" if pi
+          trace :pi, "Got PI #{pi.name||pi.object_id} for #{name}" if pi
 
           if !pi
             if (supertype = identifying_supertype)
               # This shouldn't happen now, as an identifying supertype is connected by a fact type
               # that has a uniqueness constraint marked as the preferred identifier.
-              #debug :pi, "PI not found for #{name}, looking in supertype #{supertype.name}"
+              #trace :pi, "PI not found for #{name}, looking in supertype #{supertype.name}"
               #pi = supertype.preferred_identifier
               #return nil
             elsif fact_type
@@ -420,11 +423,11 @@ module ActiveFacts
                 break if pi
               }
 	      if !pi && possible_pi
-		debug :pi, "Using existing PC as PI for #{name}"
+		trace :pi, "Using existing PC as PI for #{name}"
 		pi = possible_pi
 	      end
             else
-              debug :pi, "No PI found for #{name}"
+              trace :pi, "No PI found for #{name}"
             end
           end
           raise "No PI found for #{name}" unless pi
@@ -464,14 +467,14 @@ module ActiveFacts
 
       # A subtype does not have a identifying_supertype if it defines its own identifier
       def identifying_supertype
-        debug "Looking for identifying_supertype of #{name}"
+        trace "Looking for identifying_supertype of #{name}"
         all_type_inheritance_as_subtype.detect{|ti|
-            debug "considering supertype #{ti.supertype.name}"
+            trace "considering supertype #{ti.supertype.name}"
             next unless ti.provides_identification
-            debug "found identifying supertype of #{name}, it's #{ti.supertype.name}"
+            trace "found identifying supertype of #{name}, it's #{ti.supertype.name}"
             return ti.supertype
           }
-        debug "Failed to find identifying supertype of #{name}"
+        trace "Failed to find identifying supertype of #{name}"
         return nil
       end
 
@@ -551,7 +554,7 @@ module ActiveFacts
             end
         }
         expanded.gsub!(/ ?- ?/, '-')        # Remove single spaces around adjectives
-        #debug "Expanded '#{expanded}' using #{frequency_constraints.inspect}"
+        #trace "Expanded '#{expanded}' using #{frequency_constraints.inspect}"
         expanded
       end
 
@@ -621,7 +624,7 @@ module ActiveFacts
       def to_s
         if all_allowed_range.size > 1
         "[" +
-          all_allowed_range.sorted.map { |ar| ar.to_s(true) }*", " +
+          all_allowed_range_sorted.map { |ar| ar.to_s(true) }*", " +
         "]"
         else
           all_allowed_range.single.to_s
@@ -777,17 +780,17 @@ module ActiveFacts
     class Query
       def show
         steps_shown = {}
-        debug :query, "Displaying full contents of Query #{concept.guid}" do
+        trace :query, "Displaying full contents of Query #{concept.guid}" do
           all_variable.sort_by{|jn| jn.ordinal}.each do |variable|
-            debug :query, "#{variable.describe}" do
+            trace :query, "#{variable.describe}" do
               variable.all_step.
                 each do |step|
                   next if steps_shown[step]
                   steps_shown[step] = true
-                  debug :query, "#{step.describe}"
+                  trace :query, "#{step.describe}"
                 end
               variable.all_play.each do |play|
-                debug :query, "role of #{play.describe} in '#{play.role.fact_type.default_reading}'"
+                trace :query, "role of #{play.describe} in '#{play.role.fact_type.default_reading}'"
               end
             end
           end
@@ -979,9 +982,9 @@ module ActiveFacts
       # Discount a subtype step over an object type that's not a player here,
       # if we can use an objectification step to an object type that is:
       if counterpart_sups.size > 0 && obj_sups.size > 0 && counterpart_sups[0] != obj_sups[0]
-        debug :query, "ambiguous query, could be over #{counterpart_sups[0].name} or #{obj_sups[0].name}"
+        trace :query, "ambiguous query, could be over #{counterpart_sups[0].name} or #{obj_sups[0].name}"
         if !roles.detect{|r| r.object_type == counterpart_sups[0]} and roles.detect{|r| r.object_type == obj_sups[0]}
-          debug :query, "discounting #{counterpart_sups[0].name} in favour of direct objectification"
+          trace :query, "discounting #{counterpart_sups[0].name} in favour of direct objectification"
           counterpart_sups = []
         end
       end

data/lib/activefacts/vocabulary/metamodel.rb

@@ -9,10 +9,12 @@ module ActiveFacts
 
     class AgentName < String
       value_type 
+      one_to_one :agent                           # See Agent.agent_name
     end
 
     class AggregateCode < String
       value_type :length => 32
+      one_to_one :aggregate                       # See Aggregate.aggregate_code
     end
 
     class Assimilation < String
@@ -60,10 +62,15 @@ module ActiveFacts
 
     class Guid < ::Guid
       value_type 
+      one_to_one :alternative_set                 # See AlternativeSet.guid
+      one_to_one :concept                         # See Concept.guid
+      one_to_one :role_sequence                   # See RoleSequence.guid
+      one_to_one :shape                           # See Shape.guid
     end
 
     class ImplicationRuleName < String
       value_type 
+      one_to_one :implication_rule                # See ImplicationRule.implication_rule_name
     end
 
     class Length < UnsignedInteger
@@ -76,6 +83,9 @@ module ActiveFacts
 
     class Name < String
       value_type :length => 64
+      one_to_one :plural_named_unit, :class => "Unit", :counterpart => :plural_name  # See Unit.plural_name
+      one_to_one :unit                            # See Unit.name
+      one_to_one :vocabulary                      # See Vocabulary.name
     end
 
     class Numerator < Decimal
@@ -295,7 +305,7 @@ module ActiveFacts
       maybe :is_fundamental
       one_to_one :name, :mandatory => true        # See Name.unit
       has_one :offset                             # See Offset.all_unit
-      one_to_one :plural_name, :class => Name     # See Name.unit_as_plural_name
+      one_to_one :plural_name, :class => Name, :counterpart => :plural_named_unit  # See Name.plural_named_unit
       has_one :vocabulary, :mandatory => true     # See Vocabulary.all_unit
     end
 

data/lib/activefacts/vocabulary/verbaliser.rb

@@ -139,10 +139,10 @@ module ActiveFacts
             @player_by_role_ref[ref] or ref.play && @player_by_play[ref.play]
           end
         if existing_player
-          debug :player, "Using existing player for #{ref.role.object_type.name} #{ref.respond_to?(:role_sequence) && ref.role_sequence.all_reading.size > 0 ? ' in reading' : ''}in '#{ref.role.fact_type.default_reading}'"
+          trace :player, "Using existing player for #{ref.role.object_type.name} #{ref.respond_to?(:role_sequence) && ref.role_sequence.all_reading.size > 0 ? ' in reading' : ''}in '#{ref.role.fact_type.default_reading}'"
           return existing_player
         else
-          debug :player, "Adding new player for #{ref.role.object_type.name} #{ref.respond_to?(:role_sequence) && ref.role_sequence.all_reading.size > 0 ? ' in reading' : ''}in '#{ref.role.fact_type.default_reading}'"
+          trace :player, "Adding new player for #{ref.role.object_type.name} #{ref.respond_to?(:role_sequence) && ref.role_sequence.all_reading.size > 0 ? ' in reading' : ''}in '#{ref.role.fact_type.default_reading}'"
           p = Player.new(ref.role.object_type)
           @players.push(p)
           p
@@ -162,11 +162,11 @@ module ActiveFacts
 
       # Add a RoleRef to an existing Player
       def add_role_player player, role_ref
-        #debug :subscript, "Adding role_ref #{role_ref.object_id} to player #{player.object_id}"
+        #trace :subscript, "Adding role_ref #{role_ref.object_id} to player #{player.object_id}"
         if jr = role_ref.play
           add_play(player, jr)
         elsif !player.role_refs.include?(role_ref)
-          debug :subscript, "Adding reference to player #{player.object_id} for #{role_ref.role.object_type.name} in #{role_ref.role_sequence.describe} with #{role_ref.role_sequence.all_reading.size} readings"
+          trace :subscript, "Adding reference to player #{player.object_id} for #{role_ref.role.object_type.name} in #{role_ref.role_sequence.describe} with #{role_ref.role_sequence.all_reading.size} readings"
           player.role_refs.push(role_ref)
           @player_by_role_ref[role_ref] = player
         end
@@ -222,9 +222,9 @@ module ActiveFacts
         end
         p = existing_players[0] || player(plays[0])
         debugger if plays.detect{|jr| jr.role.object_type != p.object_type }
-        debug :subscript, "roles are playes of #{p.describe}" do
+        trace :subscript, "roles are playes of #{p.describe}" do
           plays.each do |play|
-            debug :subscript, "#{play.describe}" do
+            trace :subscript, "#{play.describe}" do
               add_play p, play
             end
           end
@@ -244,7 +244,7 @@ module ActiveFacts
         end
         p = existing_players[0] || player(role_refs[0])
 
-        debug :subscript, "#{existing_players[0] ? 'Adding to existing' : 'Creating new'} player for #{role_refs.map{|rr| rr.role.object_type.name}.uniq*', '}" do
+        trace :subscript, "#{existing_players[0] ? 'Adding to existing' : 'Creating new'} player for #{role_refs.map{|rr| rr.role.object_type.name}.uniq*', '}" do
           role_refs.each do |rr|
             unless p.object_type == rr.role.object_type
               # This happens in SubtypePI because uniqueness constraint is built without its implicit subtyping step.
@@ -275,10 +275,10 @@ module ActiveFacts
                 p.role_adjuncts(matching) == player.role_adjuncts(matching)
               end
             if dups.size == 1
-              debug :subscript, "No subscript needed for #{object_type.name}"
+              trace :subscript, "No subscript needed for #{object_type.name}"
               next
             end
-            debug :subscript, "Applying subscripts to #{dups.size} occurrences of #{object_type.name}" do
+            trace :subscript, "Applying subscripts to #{dups.size} occurrences of #{object_type.name}" do
               s = 0
               dups.
                 sort_by{|p|   # Guarantee stable numbering
@@ -350,7 +350,7 @@ module ActiveFacts
           prrs = fact_type.preferred_reading.role_sequence.all_role_ref
           residual_roles = fact_type.all_role.select{|r| !@role_refs.detect{|rr| rr.role == r} }
           residual_roles.each do |role|
-            debug :subscript, "Adding residual role for #{role.object_type.name} (in #{fact_type.default_reading}) not covered in role sequence"
+            trace :subscript, "Adding residual role for #{role.object_type.name} (in #{fact_type.default_reading}) not covered in role sequence"
             preferred_role_ref = prrs.detect{|rr| rr.role == role}
             if p = @player_by_role_ref[preferred_role_ref] and !p.role_refs.include?(preferred_role_ref)
               raise "Adding DUPLICATE residual role for #{role.object_type.name}"
@@ -361,11 +361,11 @@ module ActiveFacts
       end
 
       def prepare_query_players query
-        debug :subscript, "Indexing roles of fact types in #{query.all_step.size} steps" do
+        trace :subscript, "Indexing roles of fact types in #{query.all_step.size} steps" do
           steps = []
           # Register all references to each variable as being for the same player:
           query.all_variable.sort_by{|jn| jn.ordinal}.each do |variable|
-            debug :subscript, "Adding Roles of #{variable.describe}" do
+            trace :subscript, "Adding Roles of #{variable.describe}" do
               plays_have_same_player(variable.all_play.to_a)
               steps = steps | variable.all_step
             end
@@ -388,11 +388,11 @@ module ActiveFacts
           #steps.map{|js|js.fact_type}.uniq.each do |fact_type|
             next if fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
 
-            debug :subscript, "Residual roles in '#{fact_type.default_reading}' are" do
+            trace :subscript, "Residual roles in '#{fact_type.default_reading}' are" do
               prrs = fact_type.preferred_reading.role_sequence.all_role_ref
               residual_roles = fact_type.all_role.select{|r| !r.all_role_ref.detect{|rr| rr.variable && rr.variable.query == query} }
               residual_roles.each do |r|
-                debug :subscript, "Adding residual role for #{r.object_type.name} (in #{fact_type.default_reading}) not covered in query"
+                trace :subscript, "Adding residual role for #{r.object_type.name} (in #{fact_type.default_reading}) not covered in query"
                 preferred_role_ref = prrs.detect{|rr| rr.role == r}
                 if p = @player_by_role_ref[preferred_role_ref] and !p.role_refs.include?(preferred_role_ref)
                   raise "Adding DUPLICATE residual role for #{r.object_type.name} not covered in query"
@@ -433,7 +433,7 @@ module ActiveFacts
           reading.role_sequence.all_role_ref.each do |rr|
             next unless player = @player_by_role_ref[rr]
             next unless subscript = player.subscript
-            debug :subscript, "Need to apply subscript #{subscript} to #{rr.role.object_type.name}"
+            trace :subscript, "Need to apply subscript #{subscript} to #{rr.role.object_type.name}"
           end
           player_by_role = {}
           @player_by_role_ref.keys.each{|rr| player_by_role[rr.role] = @player_by_role_ref[rr] if rr.role.fact_type == fact_type }
@@ -454,7 +454,7 @@ module ActiveFacts
 	  plays = ([step.input_play, step.output_play]+step.all_incidental_play.to_a).compact
 	  variable_by_role = plays.inject({}) { |h, play| h[play.role] = play.variable; h }
 	end
-        debug :subscript, "expanding '#{text}' with #{role_sequence.describe}" do
+        trace :subscript, "expanding '#{text}' with #{role_sequence.describe}" do
           text.gsub(/\{(\d)\}/) do
             role_ref = rrs[$1.to_i]
             # REVISIT: We may need to use the step's role_refs to expand the role players here, not the reading's one (extra adjectives?)
@@ -471,7 +471,7 @@ module ActiveFacts
       def subscripted_player role_ref, subscript = nil, play_name = nil, value = nil
         prr = @player_by_role_ref[role_ref]
         subscript ||= prr.subscript if prr
-        debug :subscript, "Need to apply subscript #{subscript} to #{role_ref.role.object_type.name}" if subscript
+        trace :subscript, "Need to apply subscript #{subscript} to #{role_ref.role.object_type.name}" if subscript
         object_type = role_ref.role.object_type
         (play_name ||
           [
@@ -532,19 +532,19 @@ module ActiveFacts
         # so just use any step involving this node, or just any step.
         if next_steps
           if next_step = next_steps.detect { |ns| !ns.is_objectification_step }
-            debug :query, "Chose new non-objectification step: #{next_step.describe}"
+            trace :query, "Chose new non-objectification step: #{next_step.describe}"
             return next_step
           end
         end
 
         if next_step = @steps.detect { |ns| !ns.is_objectification_step }
-          debug :query, "Chose random non-objectification step: #{next_step.describe}"
+          trace :query, "Chose random non-objectification step: #{next_step.describe}"
           return next_step
         end
 
         next_step = @steps[0]
         if next_step
-          debug :query, "Chose new random step from #{steps.size}: #{next_step.describe}"
+          trace :query, "Chose new random step from #{steps.size}: #{next_step.describe}"
           if next_step.is_objectification_step
             # if this objectification plays any roles (other than its FT roles) in remaining steps, use one of those first:
             fact_type = next_step.fact_type.implying_role.fact_type
@@ -590,7 +590,7 @@ module ActiveFacts
               end
             next_reading
           end
-        debug :query, "#{next_reading ? "'"+next_reading.expand+"'" : "No reading"} contracts against last node '#{next_node.object_type.name}'"
+        trace :query, "#{next_reading ? "'"+next_reading.expand+"'" : "No reading"} contracts against last node '#{next_node.object_type.name}'"
         return [next_step, next_reading]
       end
 
@@ -621,7 +621,7 @@ module ActiveFacts
                 js.input_play.variable.object_type == object_type || js.output_play.variable.object_type == object_type
             }
           steps << other_step
-          debug :query, "Emitting objectification step allows deleting #{other_step.describe}"
+          trace :query, "Emitting objectification step allows deleting #{other_step.describe}"
           step_completed(other_step)
         end
 
@@ -658,12 +658,12 @@ module ActiveFacts
         exit_node = @variables.detect{|jn| jn.all_play.detect{|jr| jr.role == last_role_ref.role}}
         exit_step = nil
 
-	debug :query, "Stepping over an objectification to #{exit_node.object_type.name} requires eliding the other implied steps" do
+	trace :query, "Stepping over an objectification to #{exit_node.object_type.name} requires eliding the other implied steps" do
 	  count = 0
 	  while other_step =
 	    @steps.
 	      detect{|js|
-		debug :query, "Considering step '#{js.fact_type.default_reading}'"
+		trace :query, "Considering step '#{js.fact_type.default_reading}'"
 		next unless js.is_objectification_step
 
 		# REVISIT: This test is too weak: We need to ensure that the same variables are involved, not just the same object types:
@@ -671,7 +671,7 @@ module ActiveFacts
 		exit_step = js if js.output_play.variable == exit_node
 		true
 	      }
-	    debug :query, "Emitting objectified FT allows deleting #{other_step.describe}"
+	    trace :query, "Emitting objectified FT allows deleting #{other_step.describe}"
 	    step_completed(other_step)
   #          raise "The objectification of '#{fact_type.default_reading}' should not cause the deletion of more than #{fact_type.all_role.size} other steps" if (count += 1) > fact_type.all_role.size
 	  end
@@ -685,12 +685,12 @@ module ActiveFacts
         readings = ''
         next_node = @role_refs[0].play.variable   # Choose a place to start
         last_is_contractable = false
-        debug :query, "Variables are #{@variables.map{|jn| jn.describe }.inspect}, Steps are #{@steps.map{|js| js.describe }.inspect}" do
+        trace :query, "Variables are #{@variables.map{|jn| jn.describe }.inspect}, Steps are #{@steps.map{|js| js.describe }.inspect}" do
           until @steps.empty?
             next_reading = nil
             # Choose amonst all remaining steps we can take from the next node, if any
             next_steps = @steps_by_variable[next_node]
-            debug :query, "Next Steps from #{next_node.describe} are #{(next_steps||[]).map{|js| js.describe }.inspect}"
+            trace :query, "Next Steps from #{next_node.describe} are #{(next_steps||[]).map{|js| js.describe }.inspect}"
 
             # See if we can find a next step that contracts against the last (if any):
             next_step = nil
@@ -699,7 +699,7 @@ module ActiveFacts
                 end
 
             if next_step
-              debug :query, "Chose #{next_step.describe} because it's contractable against last node #{next_node.object_type.name} using #{next_reading.expand}"
+              trace :query, "Chose #{next_step.describe} because it's contractable against last node #{next_node.object_type.name} using #{next_reading.expand}"
 
               player_by_role =
                 next_step.all_play.inject({}) {|h, jr| h[jr.role] = @player_by_play[jr]; h }