activefacts 1.1.0 → 1.2.0

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

@@ -66,8 +66,7 @@ module ActiveFacts
 
     class ValueType
       def needs_surrogate
-	supertype_names = supertypes_transitive.map(&:name)
-	!(supertype_names.include?('Auto Counter') or supertype_names.include?('Guid') or supertype_names.include?('ID'))
+	!is_auto_assigned
       end
 
       def inject_surrogate

data/lib/activefacts/mapping/rails.rb

@@ -4,52 +4,7 @@ require 'active_support'
 require 'digest/sha1'
 
 module ActiveFacts
-
   module Persistence
-    # Return ActiveRecord type and (modified?) length for the passed base type
-    def self.rails_type(type, length)
-      rails_type = case type
-	when /^Auto ?Counter$/
-	  'integer'	    # REVISIT: Need to detect surrogate ID fields and handle them correctly
-
-	when /^Unsigned ?Integer$/,
-	  /^Integer$/,
-	  /^Signed ?Integer$/,
-	  /^Unsigned ?Small ?Integer$/,
-	  /^Signed ?Small ?Integer$/,
-	  /^Unsigned ?Tiny ?Integer$/
-	  length = nil
-	  'integer'
-
-	when /^Decimal$/
-	  'decimal'
-
-	when /^Fixed ?Length ?Text$/, /^Char$/
-	  'string'
-	when /^Variable ?Length ?Text$/, /^String$/
-	  'string'
-	when /^Large ?Length ?Text$/, /^Text$/
-	  'text'
-
-	when /^Date ?And ?Time$/, /^Date ?Time$/
-	  'datetime'
-	when /^Date$/
-	  'datetime'
-	when /^Time$/
-	  'time'
-	when /^Auto ?Time ?Stamp$/
-	  'timestamp'
-
-	when /^Money$/
-	  'decimal'
-	when /^Picture ?Raw ?Data$/, /^Image$/, /^Variable ?Length ?Raw ?Data$/, /^Blob$/
-	  'binary'
-	when /^BIT$/
-	  'boolean'
-	else type # raise "ActiveRecord type unknown for standard type #{type}"
-	end
-      [rails_type, length]
-    end
 
     def self.rails_plural_name name
       # Crunch spaces and pluralise the first part, all in snake_case
@@ -74,6 +29,58 @@ module ActiveFacts
       def rails_name
 	Persistence::rails_singular_name(name('_'))
       end
+
+      def rails_type
+	type_name, params, constraints = *type()
+	rails_type = case type_name
+	  when /^Auto ?Counter$/i
+	    'serial'	    # REVISIT: Need to detect surrogate ID fields and handle them correctly
+
+	  when /^[Ug]uid$/i
+	    'uuid'
+
+	  when /^Unsigned ?Integer$/i,
+	    /^Integer$/i,
+	    /^Signed ?Integer$/i,
+	    /^Unsigned ?Small ?Integer$/i,
+	    /^Signed ?Small ?Integer$/i,
+	    /^Unsigned ?Tiny ?Integer$/i
+	    length = nil
+	    'integer'
+
+	  when /^Decimal$/i
+	    'decimal'
+
+	  when /^Float$/i, /^Double$/i, /^Real$/i
+	    'float'
+
+	  when /^Fixed ?Length ?Text$/i, /^Char$/i
+	    'string'
+	  when /^Variable ?Length ?Text$/i, /^String$/i
+	    'string'
+	  when /^Large ?Length ?Text$/i, /^Text$/i
+	    'text'
+
+	  when /^Date ?And ?Time$/i, /^Date ?Time$/i
+	    'datetime'
+	  when /^Date$/i
+	    'datetime'
+	  when /^Time$/i
+	    'time'
+	  when /^Auto ?Time ?Stamp$/i
+	    'timestamp'
+
+	  when /^Money$/i
+	    'decimal'
+	  when /^Picture ?Raw ?Data$/i, /^Image$/i, /^Variable ?Length ?Raw ?Data$/i, /^Blob$/i
+	    'binary'
+	  when /^BIT$/i, /^Boolean$/i
+	    'boolean'
+	  else
+	    type_name # raise "ActiveRecord type unknown for standard type #{type}"
+	  end
+	[rails_type, params[:length]]
+      end
     end
 
     class Index

data/lib/activefacts/persistence/columns.rb

@@ -163,15 +163,15 @@ module ActiveFacts
         end
 
         vt = references[-1].is_self_value ? references[-1].from : references[-1].to
-        params[:length] ||= vt.length if vt.length.to_i != 0
-        params[:scale] ||= vt.scale if vt.scale.to_i != 0
-        while vt.supertype
+	begin
           params[:length] ||= vt.length if vt.length.to_i != 0
           params[:scale] ||= vt.scale if vt.scale.to_i != 0
           constraints << vt.value_constraint if vt.value_constraint
+	  last_vt = vt
           vt = vt.supertype
-        end
-        return [vt.name, params, constraints]
+        end while vt
+	params[:underlying_type] = last_vt
+        return [last_vt.name, params, constraints]
       end
 
       # The comment is the readings from the References expressed as a series of steps (not a full verbalisation)

data/lib/activefacts/persistence/tables.rb

@@ -46,13 +46,15 @@ module ActiveFacts
         @is_table
       end
 
-      # Is this ValueType auto-assigned on first save to the database?
+      # Is this ValueType auto-assigned either at assert or on first save to the database?
       def is_auto_assigned
-        # REVISIT: Find a better way to determine AutoCounters (ValueType unary role?)
         type = self
-        type = type.supertype while type.supertype
-        type.name =~ /^Auto/
+	while type
+	  return true if type.name =~ /^Auto/ || type.transaction_phase
+	  type = type.supertype
+	end
       end
+      false
     end
 
     class EntityType < DomainObjectType

data/lib/activefacts/support.rb

@@ -1,7 +1,5 @@
 #
 #       ActiveFacts Support code.
-#       The trace method supports indented tracing.
-#       Set the TRACE environment variable to enable it. Search the code to find the TRACE keywords, or use "all".
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #

data/lib/activefacts/version.rb

@@ -7,7 +7,7 @@
 module ActiveFacts
   module Version
     MAJOR = 1
-    MINOR = 1
+    MINOR = 2
     PATCH = 0
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')

data/lib/activefacts/vocabulary/extensions.rb

@@ -265,6 +265,13 @@ module ActiveFacts
       def subtypes_transitive
         [self] + subtypes.map{|st| st.subtypes_transitive}.flatten
       end
+
+      def common_supertype(other)
+	return nil unless other.is_?(ActiveFacts::Metamodel::ValueType)
+	return self if other.supertypes_transitive.include?(self)
+	return other if supertypes_transitive.include(other)
+	nil
+      end
     end
 
     class EntityType
@@ -478,6 +485,13 @@ module ActiveFacts
         return nil
       end
 
+      def common_supertype(other)
+	return nil unless other.is_?(ActiveFacts::Metamodel::EntityType)
+	candidates = supertypes_transitive & other.supertypes_transitive
+	return candidates[0] if candidates.size <= 1
+	candidates[0] # REVISIT: This might not be the closest supertype
+      end
+
       # This entity type has just objectified a fact type. Create the necessary ImplicitFactTypes with phantom roles
       def create_implicit_fact_types
         fact_type.all_role.map do |role|
@@ -722,23 +736,26 @@ module ActiveFacts
           "#{is_optional ? 'maybe ' : ''}" +
           (is_unary_step ? '(unary) ' : "from #{input_play.describe} ") +
           "#{is_disallowed ? 'not ' : ''}" +
-          "to #{output_play.describe} " +
-          "over " +
-          (is_objectification_step ? 'objectification ' : '') +
-          "'#{fact_type.default_reading}'"
+          "to #{output_plays.map(&:describe)*', '}" +
+          (objectification_variable ? ", objectified as #{objectification_variable.describe}" : '') +
+          " '#{fact_type.default_reading}'"
+      end
+
+      def input_play
+	all_play.detect{|p| p.is_input}
+      end
+
+      def output_plays
+	all_play.reject{|p| p.is_input}
       end
 
       def is_unary_step
         # Preserve this in case we have to use a real variable for the phantom
-        input_play == output_play
+        all_play.size == 1
       end
 
       def is_objectification_step
-        fact_type.is_a?(LinkFactType)
-      end
-
-      def all_play
-        [input_play, output_play].uniq + all_incidental_play.to_a
+        !!objectification_variable
       end
 
       def external_fact_type
@@ -750,38 +767,27 @@ module ActiveFacts
       def describe
         object_type.name +
           (subscript ? "(#{subscript})" : '') +
-          " JN#{ordinal}" +
+          " Var#{ordinal}" +
           (value ? ' = '+value.to_s : '')
       end
 
       def all_step
-        all_play.map do |jr|
-          jr.all_step_as_input_play.to_a +
-            jr.all_step_as_output_play.to_a
-        end.
-          flatten.
-          uniq
+        all_play.map(&:step).uniq
       end
     end
 
     class Play
       def describe
-        "#{role.object_type.name} JN#{variable.ordinal}" +
+        "#{role.object_type.name} Var#{variable.ordinal}" +
           (role_ref ? " (projected)" : "")
       end
-
-      def all_step
-        (all_step_as_input_play.to_a +
-          all_step_as_output_play.to_a +
-          [step]).flatten.compact.uniq
-      end
     end
 
     class Query
       def show
         steps_shown = {}
         trace :query, "Displaying full contents of Query #{concept.guid}" do
-          all_variable.sort_by{|jn| jn.ordinal}.each do |variable|
+          all_variable.sort_by{|var| var.ordinal}.each do |variable|
             trace :query, "#{variable.describe}" do
               variable.all_step.
                 each do |step|
@@ -798,7 +804,7 @@ module ActiveFacts
       end
 
       def all_step
-        all_variable.map{|jn| jn.all_step.to_a}.flatten.uniq
+        all_variable.map{|var| var.all_step.to_a}.flatten.uniq
       end
 
       # Check all parts of this query for validity
@@ -808,7 +814,7 @@ module ActiveFacts
 
         # Check the variables:
         steps = []
-        variables = all_variable.sort_by{|jn| jn.ordinal}
+        variables = all_variable.sort_by{|var| var.ordinal}
         variables.each_with_index do |variable, i|
           raise "Variable #{i} should have ordinal #{variable.ordinal}" unless variable.ordinal == i
           raise "Variable #{i} has missing object_type" unless variable.object_type
@@ -1025,22 +1031,38 @@ module ActiveFacts
       def verbalise(context = nil)
         return "#{object_type.name} #{value}" if object_type.is_a?(ValueType)
 
-        return "#{object_type.name} where #{fact.verbalise(context)}" if object_type.fact_type
+        return "#{object_type.name} (in which #{fact.verbalise(context)})" if object_type.fact_type
 
         # It's an entity that's not an objectified fact type
-        # REVISIT: If it has a simple identifier, there's no need to fully verbalise the identifying facts
-        pi = object_type.preferred_identifier
-        identifying_role_refs = pi.role_sequence.all_role_ref_in_order
-        "#{object_type.name}" +
-          " is identified by " +      # REVISIT: Where the single fact type is TypeInheritance, we can shrink this
-          if identifying_role_refs.size == 1 &&
-            (role = identifying_role_refs[0].role) &&
-            (my_role = (role.fact_type.all_role.to_a-[role])[0]) &&
-            (identifying_fact = my_role.all_role_value.detect{|rv| rv.instance == self}.fact) &&
-            (identifying_instance = identifying_fact.all_role_value.detect{|rv| rv.role == role}.instance)
-
-              "its #{identifying_instance.verbalise(context)}"
-          else
+
+        # If it has a simple identifier, there's no need to fully verbalise the identifying facts.
+	# This recursive block returns either the identifying value or nil
+	simple_identifier = proc do |instance|
+	    if instance.object_type.is_a?(ActiveFacts::Metamodel::ValueType)
+	      instance
+	    else
+	      pi = instance.object_type.preferred_identifier
+	      identifying_role_refs = pi.role_sequence.all_role_ref_in_order
+	      if identifying_role_refs.size != 1
+		nil
+	      else
+		role = identifying_role_refs[0].role
+		my_role = (role.fact_type.all_role.to_a-[role])[0]
+		identifying_fact = my_role.all_role_value.detect{|rv| rv.instance == self}.fact
+		irv = identifying_fact.all_role_value.detect{|rv| rv.role == role}
+		identifying_instance = irv.instance
+		simple_identifier.call(identifying_instance)
+	      end
+	    end
+	  end
+
+	if (id = simple_identifier.call(self))
+	  "#{object_type.name} #{id.value}"
+	else
+	  pi = object_type.preferred_identifier
+	  identifying_role_refs = pi.role_sequence.all_role_ref_in_order
+	  "#{object_type.name}" +
+	    " is identified by " +      # REVISIT: Where the single fact type is TypeInheritance, we can shrink this
             identifying_role_refs.map do |rr|
               rr = rr.preferred_reference
               [ (l = rr.leading_adjective) ? l+"-" : nil,
@@ -1056,7 +1078,7 @@ module ActiveFacts
               #identifying_instance = counterpart_role.all_role_value.detect{|rv| rv.fact == identifying_fact}.instance
               identifying_fact.verbalise(context)
             end*", "
-          end
+	end
 
       end
     end

data/lib/activefacts/vocabulary/metamodel.rb

@@ -66,6 +66,7 @@ module ActiveFacts
       one_to_one :concept                         # See Concept.guid
       one_to_one :role_sequence                   # See RoleSequence.guid
       one_to_one :shape                           # See Shape.guid
+      one_to_one :step                            # See Step.guid
     end
 
     class ImplicationRuleName < String
@@ -292,6 +293,15 @@ module ActiveFacts
       has_one :orm_diagram, :class => "ORMDiagram", :mandatory => true  # See ORMDiagram.all_shape
     end
 
+    class Step
+      identified_by :guid
+      has_one :alternative_set                    # See AlternativeSet.all_step
+      has_one :fact_type, :mandatory => true      # See FactType.all_step
+      one_to_one :guid, :mandatory => true        # See Guid.step
+      maybe :is_disallowed
+      maybe :is_optional
+    end
+
     class SubsetConstraint < SetConstraint
       has_one :subset_role_sequence, :class => RoleSequence, :mandatory => true  # See RoleSequence.all_subset_constraint_as_subset_role_sequence
       has_one :superset_role_sequence, :class => RoleSequence, :mandatory => true  # See RoleSequence.all_subset_constraint_as_superset_role_sequence
@@ -329,6 +339,7 @@ module ActiveFacts
       one_to_one :projection, :class => Role      # See Role.variable_as_projection
       has_one :query, :mandatory => true          # See Query.all_variable
       has_one :role_name, :class => Name          # See Name.all_variable_as_role_name
+      one_to_one :step, :counterpart => :objectification_variable  # See Step.objectification_variable
       has_one :subscript                          # See Subscript.all_variable
       has_one :value                              # See Value.all_variable
     end
@@ -419,10 +430,11 @@ module ActiveFacts
     end
 
     class Play
-      identified_by :variable, :role
+      identified_by :step, :role
       has_one :role, :mandatory => true           # See Role.all_play
+      has_one :step, :mandatory => true           # See Step.all_play
       has_one :variable, :mandatory => true       # See Variable.all_play
-      has_one :step, :counterpart => :incidental_play  # See Step.all_incidental_play
+      maybe :is_input
     end
 
     class Population
@@ -479,16 +491,6 @@ module ActiveFacts
       maybe :is_mandatory
     end
 
-    class Step
-      identified_by :input_play, :output_play
-      has_one :alternative_set                    # See AlternativeSet.all_step
-      has_one :fact_type, :mandatory => true      # See FactType.all_step
-      has_one :input_play, :class => Play, :mandatory => true  # See Play.all_step_as_input_play
-      maybe :is_disallowed
-      maybe :is_optional
-      has_one :output_play, :class => Play        # See Play.all_step_as_output_play
-    end
-
     class ValueConstraintShape < ConstraintShape
       has_one :object_type_shape                  # See ObjectTypeShape.all_value_constraint_shape
       one_to_one :role_display                    # See RoleDisplay.value_constraint_shape

data/lib/activefacts/vocabulary/verbaliser.rb

@@ -163,8 +163,8 @@ module ActiveFacts
       # Add a RoleRef to an existing Player
       def add_role_player player, role_ref
         #trace :subscript, "Adding role_ref #{role_ref.object_id} to player #{player.object_id}"
-        if jr = role_ref.play
-          add_play(player, jr)
+        if play = role_ref.play
+          add_play(player, play)
         elsif !player.role_refs.include?(role_ref)
           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)
@@ -216,12 +216,11 @@ module ActiveFacts
         return if plays.empty?
 
         # If any of these plays are for a known player, use that, else make a new player.
-        existing_players = plays.map{|jr| @player_by_play[jr] }.compact.uniq
+        existing_players = plays.map{|play| @player_by_play[play] }.compact.uniq
         if existing_players.size > 1
           raise "At most one existing player can play these roles: #{existing_players.map{|p|p.object_type.name}*', '}!"
         end
         p = existing_players[0] || player(plays[0])
-        debugger if plays.detect{|jr| jr.role.object_type != p.object_type }
         trace :subscript, "roles are playes of #{p.describe}" do
           plays.each do |play|
             trace :subscript, "#{play.describe}" do
@@ -281,22 +280,22 @@ module ActiveFacts
             trace :subscript, "Applying subscripts to #{dups.size} occurrences of #{object_type.name}" do
               s = 0
               dups.
-                sort_by{|p|   # Guarantee stable numbering
+                sort_by do |p|   # Guarantee stable numbering
                   p.role_adjuncts(:role_name) + ' ' +
                     # Tie-breaker:
                     p.role_refs.map{|rr| rr.role.fact_type.preferred_reading.text}.sort.to_s
-                }.
+                end.
                 each do |player|
-                jrname = player.plays.map{|jr| jr.role_ref && jr.role_ref.role.role_name}.compact[0]
-                rname = (rr = player.role_refs[0]) && rr.role.role_name
-                if jrname and !rname
-                  # puts "Oops: rolename #{rname.inspect} != #{jrname.inspect}" if jrname != rname
-                  player.variables_by_query.values.each{|jn| jn.role_name = jrname }
-               else
-                  player.subscript = s+1
-                  s += 1
-                end
-              end
+		  jrname = player.plays.map{|play| play.role_ref && play.role_ref.role.role_name}.compact[0]
+		  rname = (rr = player.role_refs[0]) && rr.role.role_name
+		  if jrname and !rname
+		    # puts "Oops: rolename #{rname.inspect} != #{jrname.inspect}" if jrname != rname
+		    player.variables_by_query.values.each{|jn| jn.role_name = jrname }
+		  else
+		    player.subscript = s+1
+		    s += 1
+		  end
+		end
             end
           end
       end
@@ -364,7 +363,7 @@ module ActiveFacts
         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|
+          query.all_variable.to_a.sort_by(&:ordinal).each do |variable|
             trace :subscript, "Adding Roles of #{variable.describe}" do
               plays_have_same_player(variable.all_play.to_a)
               steps = steps | variable.all_step
@@ -445,13 +444,12 @@ module ActiveFacts
       # Expand this reading (or partial reading, during contraction)
       def expand_reading_text(step, text, role_sequence, player_by_role = {})
         if !player_by_role.empty? and !player_by_role.is_a?(Hash) || player_by_role.keys.detect{|k| !k.is_a?(ActiveFacts::Metamodel::Role)}
-          debugger
           raise "Need to change this call to expand_reading_text to pass a role->variable hash"
         end
         rrs = role_sequence.all_role_ref_in_order
 	variable_by_role = {}
 	if step
-	  plays = ([step.input_play, step.output_play]+step.all_incidental_play.to_a).compact
+	  plays = step.all_play
 	  variable_by_role = plays.inject({}) { |h, play| h[play.role] = play.variable; h }
 	end
         trace :subscript, "expanding '#{text}' with #{role_sequence.describe}" do
@@ -462,8 +460,9 @@ module ActiveFacts
 	    variable = variable_by_role[role_ref.role]
 
             play_name = variable && variable.role_name
+	    raise hell if player && player.is_a?(ActiveFacts::Metamodel::EntityType) && player.fact_type && !variable
             subscripted_player(role_ref, player && player.subscript, play_name, variable && variable.value) +
-              objectification_verbalisation(role_ref.role.object_type)
+              objectification_verbalisation(variable)
           end
         end
       end
@@ -495,40 +494,35 @@ module ActiveFacts
         @query = query
         return unless query
 
-        @variables = query.all_variable.sort_by{|jn| jn.ordinal}
+        @variables = query.all_variable.to_a.sort_by(&:ordinal)
 
-        @steps = @variables.map{|jn| jn.all_step }.flatten.uniq
+        @steps = @variables.map(&:all_step).flatten.uniq
         @steps_by_variable = @variables.
-          inject({}) do |h, jn|
-            jn.all_step.each{|js| (h[jn] ||= []) << js}
+          inject({}) do |h, var|
+            var.all_step.each{|step| (h[var] ||= []) << step}
             h
           end
       end
 
-      # Remove this step now that we've processed it:
+      # De-index this step now that we've processed it:
       def step_completed(step)
         @steps.delete(step)
 
-        input_node = step.input_play.variable
-        steps = @steps_by_variable[input_node]
-        steps.delete(step)
-        @steps_by_variable.delete(input_node) if steps.empty?
-
-        output_node = step.output_play.variable
-        if (input_node != output_node)
-          steps = @steps_by_variable[output_node]
+	step.all_play.each do |play|
+	  var = play.variable
+          steps = @steps_by_variable[var]
           steps.delete(step)
-          @steps_by_variable.delete(output_node) if steps.empty?
+	  @steps_by_variable.delete(var) if steps.empty?
         end
       end
 
-      def choose_step(next_node)
-        next_steps = @steps_by_variable[next_node]
+      def choose_step(next_var)
+        next_steps = @steps_by_variable[next_var]
 
         # We need to emit each objectification before mentioning an object that plays a role in one, if possible
         # so that we don't wind up with an objectification as the only way to mention its name.
 
-        # If we don't have a next_node against which we can contract,
+        # If we don't have a next_var against which we can contract,
         # 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 }
@@ -558,26 +552,26 @@ module ActiveFacts
       end
 
       # The step we just emitted (using the reading given) is contractable iff
-      # the reading has the next_node's role player as the final text
-      def node_contractable_against_reading(next_node, reading)
+      # the reading has the next_var's role player as the final text
+      def node_contractable_against_reading(next_var, reading)
         reading &&
           # Find whether last role has no following text, and its ordinal
         (reading.text =~ /\{([0-9])\}$/) &&
           # This reading's RoleRef for that role:
         (role_ref = reading.role_sequence.all_role_ref_in_order[$1.to_i]) &&
           # was that RoleRef for the upcoming node?
-        role_ref.role.object_type == next_node.object_type
+        role_ref.role.object_type == next_var.object_type
       end
 
-      def reading_starts_with_node(reading, next_node)
+      def reading_starts_with_node(reading, next_var)
         reading.text =~ /^\{([0-9])\}/ and
           role_ref = reading.role_sequence.all_role_ref.detect{|rr| rr.ordinal == $1.to_i} and
-          role_ref.role.object_type == next_node.object_type
+          role_ref.role.object_type == next_var.object_type
       end
 
-      # The last reading we emitted ended with the object type name for next_node.
+      # The last reading we emitted ended with the object type name for next_var.
       # Choose a step and a reading that can be contracted against that name
-      def contractable_step(next_steps, next_node)
+      def contractable_step(next_steps, next_var)
         next_reading = nil
         next_step =
           next_steps.detect do |js|
@@ -585,51 +579,47 @@ module ActiveFacts
             # If we find a reading here, it can be contracted against the previous one
             next_reading =
               js.fact_type.all_reading_by_ordinal.detect do |reading|
-                # This step is contractable iff the FactType has a reading that starts with the role of next_node (no preceding text)
-                reading_starts_with_node(reading, next_node)
+                # This step is contractable iff the FactType has a reading that starts with the role of next_var (no preceding text)
+                reading_starts_with_node(reading, next_var)
               end
             next_reading
           end
-        trace :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_var.object_type.name}'"
         return [next_step, next_reading]
       end
 
-      # REVISIT: There might be more than one objectification_verbalisation for a given object_type. Need to get the Variable here and emit an objectification step involving that node.
-      def objectification_verbalisation(object_type)
+      def objectification_verbalisation(variable)
+	return '' unless variable
+	raise "Not fully re-implemented, should pass the variable instead of #{variable.inspect}" unless variable.is_a?(ActiveFacts::Metamodel::Variable)
         objectified_node = nil
-        unless object_type.is_a?(Metamodel::EntityType) and
-          object_type.fact_type and            # Not objectified
-          objectification_step = @steps.
-            detect do |js|
-              # The objectifying entity type should always be the input_variable here, but be safe:
-              js.is_objectification_step and
-                (objectified_node = js.input_play.variable).object_type == object_type ||
-                (objectified_node = js.output_play.variable).object_type == object_type
-            end
-          return ''
-        end
+	object_type = variable.object_type
+        return '' unless object_type.is_a?(Metamodel::EntityType) # Not a entity type
+	return '' unless object_type.fact_type			  # Not objectified
 
-        # REVISIT: We need to be working from the role_ref here - pass it in
-        # if objectification_step.variable != role_ref.variable
+	objectification_step = variable.step
+	return '' unless objectification_step
 
         steps = [objectification_step]
         step_completed(objectification_step)
+
+=begin
         while other_step =
           @steps.
-            detect{|js|
-              js.is_objectification_step and
-                js.input_play.variable.object_type == object_type || js.output_play.variable.object_type == object_type
+            detect{|step|
+              step.is_objectification_step and
+                step.input_play.variable.object_type == object_type || step.output_play.variable.object_type == object_type
             }
           steps << other_step
           trace :query, "Emitting objectification step allows deleting #{other_step.describe}"
           step_completed(other_step)
         end
+=end
 
         # Find all references to roles in this objectified fact type which are relevant to the variables of these steps:
         player_by_role = {}
         steps.each do |step|
-          step.all_play.to_a.map do |jr|
-            player_by_role[jr.role] = @player_by_play[jr]
+          step.all_play.to_a.map do |play|
+            player_by_role[play.role] = @player_by_play[play]
           end
         end
 
@@ -639,14 +629,14 @@ module ActiveFacts
         " (in which #{expand_reading_text(objectification_step, reading.text, reading.role_sequence, player_by_role)})" 
       end
 
-      def elided_objectification(next_step, fact_type, last_is_contractable, next_node)
+      def elided_objectification(next_step, fact_type, last_is_contractable, next_var)
         if last_is_contractable
           # Choose a reading that's contractable against the previous step, if possible
           reading = fact_type.all_reading_by_ordinal.
             detect do |reading|
 	      # Only contract a negative reading if we want one
 	      (!next_step.is_disallowed || !reading.is_negative == !next_step.is_disallowed) and
-		reading_starts_with_node(reading, next_node)
+		reading_starts_with_node(reading, next_var)
             end
         end
         last_is_contractable = false unless reading
@@ -655,7 +645,7 @@ module ActiveFacts
         # Find which role occurs last in the reading, and which Variable is attached
         reading.text =~ /\{(\d)\}[^{]*\Z/
         last_role_ref = reading.role_sequence.all_role_ref_in_order[$1.to_i]
-        exit_node = @variables.detect{|jn| jn.all_play.detect{|jr| jr.role == last_role_ref.role}}
+        exit_node = @variables.detect{|jn| jn.all_play.detect{|play| play.role == last_role_ref.role}}
         exit_step = nil
 
 	trace :query, "Stepping over an objectification to #{exit_node.object_type.name} requires eliding the other implied steps" do
@@ -683,35 +673,49 @@ module ActiveFacts
       def verbalise_query query
         prepare_query query
         readings = ''
-        next_node = @role_refs[0].play.variable   # Choose a place to start
+        next_var = @role_refs[0].play.variable   # Choose a place to start
         last_is_contractable = false
-        trace :query, "Variables are #{@variables.map{|jn| jn.describe }.inspect}, Steps are #{@steps.map{|js| js.describe }.inspect}" do
+
+        trace :query, "Verbalising query" do
+	  if trace(:query)
+	    trace :query, "variables:" do
+	      @variables.each do |var|
+		trace :query, var.describe
+	      end
+	    end
+	    trace :query, "steps:" do
+	      @steps.each do |step|
+		trace :query, step.describe
+	      end
+	    end
+	  end
+
           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]
-            trace :query, "Next Steps from #{next_node.describe} are #{(next_steps||[]).map{|js| js.describe }.inspect}"
+            # Choose amongst all remaining steps we can take from the next node, if any
+            next_steps = @steps_by_variable[next_var]
+            trace :query, "Next Steps from #{next_var.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
             if last_is_contractable && next_steps
-              next_step, next_reading = *contractable_step(next_steps, next_node)
+              next_step, next_reading = *contractable_step(next_steps, next_var)
                 end
 
             if next_step
-              trace :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_var.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 }
+                next_step.all_play.inject({}) {|h, play| h[play.role] = @player_by_play[play]; h }
 	      raise "REVISIT: Needed a negated reading here" if !next_reading.is_negative != !next_step.is_disallowed
 	      raise "REVISIT: Need to emit 'maybe' here" if next_step.is_optional
               readings += expand_contracted_text(next_step, next_reading, player_by_role)
               step_completed(next_step)
             else
-              next_step = choose_step(next_node) if !next_step
+              next_step = choose_step(next_var) if !next_step
 
               player_by_role =
-                next_step.all_play.inject({}) {|h, jr| h[jr.role] = @player_by_play[jr]; h }
+                next_step.all_play.inject({}) {|h, play| h[play.role] = @player_by_play[play]; h }
 
               if next_step.is_unary_step
                 # Objectified unaries get emitted as unaries, not as objectifications:
@@ -731,20 +735,20 @@ module ActiveFacts
                 objectified_node = next_step.input_play.variable
                 raise "Assumption violated that the objectification is the input play" unless objectified_node.object_type.fact_type
                 objectified_node.all_step.map do |other_step|
-                  (other_step.all_incidental_play.to_a + [other_step.output_play]).map do |jr|
-                    player_by_role[jr.role] = @player_by_play[jr]
+		  other_step.all_play.map do |play|
+                    player_by_role[play.role] = @player_by_play[play]
                   end
                 end
 
-                if last_is_contractable and next_node.object_type.is_a?(EntityType) and next_node.object_type.fact_type == fact_type
+                if last_is_contractable and next_var.object_type.is_a?(EntityType) and next_var.object_type.fact_type == fact_type
                   # The last reading we emitted ended with the name of the objectification of this fact type, so we can contract the objectification
                   # REVISIT: Do we need to use player_by_role here (if this objectification is traversed twice and so is subscripted)
                   readings += objectification_verbalisation(fact_type.entity_type)
                 else
                   # This objectified fact type does not need to be made explicit.
 		  negation = next_step.is_disallowed
-                  next_reading, next_node, next_step, last_is_contractable =
-                    *elided_objectification(next_step, fact_type, last_is_contractable, next_node)
+                  next_reading, next_var, next_step, last_is_contractable =
+                    *elided_objectification(next_step, fact_type, last_is_contractable, next_var)
                   if last_is_contractable
 		    raise "REVISIT: Need to emit 'maybe' here" if next_step and next_step.is_optional
                     readings += expand_contracted_text(next_step, next_reading, player_by_role)
@@ -760,11 +764,11 @@ module ActiveFacts
                 end
               else
                 fact_type = next_step.fact_type
-                # Prefer a reading that starts with the player of next_node
+                # Prefer a reading that starts with the player of next_var
                 next_reading = fact_type.all_reading_by_ordinal.
                   detect do |reading|
 		    (!next_step.is_disallowed || !reading.is_negative == !next_step.is_disallowed) and
-		      reading_starts_with_node(reading, next_node)
+		      reading_starts_with_node(reading, next_var)
                   end || fact_type.preferred_reading(next_step.is_disallowed)
                 # REVISIT: If this step and reading has role references with adjectives, we need to expand using those
                 readings += " and " unless readings.empty?
@@ -777,14 +781,16 @@ module ActiveFacts
 
 	    if next_step
 	      # Continue from this step with the node having the most steps remaining
-	      input_steps = @steps_by_variable[input_node = next_step.input_play.variable] || []
-	      output_steps = @steps_by_variable[output_node = next_step.output_play.variable] || []
-	      next_node = input_steps.size > output_steps.size ? input_node : output_node
+	      input_steps = @steps_by_variable[input_var = next_step.input_play.variable] || []
+	      output_play = next_step.output_plays.last
+	      output_steps = (output_play && (output_var = output_play.variable) && @steps_by_variable[output_var]) || []
+
+	      next_var = input_steps.size > output_steps.size ? input_var : output_var
 	      # Prepare for possible contraction following:
-	      last_is_contractable = next_reading && node_contractable_against_reading(next_node, next_reading)
+	      last_is_contractable = next_reading && node_contractable_against_reading(next_var, next_reading)
 	    else
 	      # This shouldn't happen, but an elided objectification that had missing steps can cause it. Survive:
-	      next_node = (steps[0].input_play || steps[0].output_play).variable
+	      next_var = (steps[0].input_play || steps[0].output_plays.last).variable
 	      last_is_contractable = false
 	    end