activefacts 0.8.16 → 0.8.18

data/lib/activefacts/vocabulary/metamodel.rb

@@ -11,9 +11,13 @@ module ActiveFacts
       value_type 
     end
 
+    class AggregateCode < String
+      value_type :length => 32
+    end
+
     class Assimilation < String
       value_type 
-      restrict 'partitioned', 'separate'
+      restrict 'absorbed', 'partitioned', 'separate'
     end
 
     class ContextNoteKind < String
@@ -58,6 +62,10 @@ module ActiveFacts
       value_type 
     end
 
+    class ImplicationRuleName < String
+      value_type 
+    end
+
     class Length < UnsignedInteger
       value_type :length => 32
     end
@@ -87,6 +95,10 @@ module ActiveFacts
       restrict 'feminine', 'masculine', 'neuter', 'personal'
     end
 
+    class RegularExpression < String
+      value_type 
+    end
+
     class RingType < String
       value_type 
     end
@@ -126,9 +138,15 @@ module ActiveFacts
       one_to_one :agent_name, :mandatory => true  # See AgentName.agent
     end
 
+    class Aggregate
+      identified_by :aggregate_code
+      one_to_one :aggregate_code, :mandatory => true  # See AggregateCode.aggregate
+    end
+
     class AlternativeSet
       identified_by :guid
       one_to_one :guid, :mandatory => true        # See Guid.alternative_set
+      maybe :members_are_exclusive
     end
 
     class Coefficient
@@ -141,6 +159,7 @@ module ActiveFacts
     class Concept
       identified_by :guid
       one_to_one :guid, :mandatory => true        # See Guid.concept
+      has_one :implication_rule                   # See ImplicationRule.all_concept
     end
 
     class Constraint < Concept
@@ -149,9 +168,9 @@ module ActiveFacts
     end
 
     class ContextNote < Concept
-      has_one :concept                            # See Concept.all_context_note
       has_one :context_note_kind, :mandatory => true  # See ContextNoteKind.all_context_note
       has_one :discussion, :mandatory => true     # See Discussion.all_context_note
+      has_one :relevant_concept, :class => Concept  # See Concept.all_context_note_as_relevant_concept
     end
 
     class Enforcement
@@ -169,7 +188,9 @@ module ActiveFacts
     class FactType < Concept
     end
 
-    class ImplicitFactType < FactType
+    class ImplicationRule
+      identified_by :implication_rule_name
+      one_to_one :implication_rule_name, :mandatory => true  # See ImplicationRuleName.implication_rule
     end
 
     class Instance < Concept
@@ -179,23 +200,13 @@ module ActiveFacts
       has_one :value                              # See Value.all_instance
     end
 
-    class Join < Concept
-    end
-
-    class JoinNode
-      identified_by :join, :ordinal
-      has_one :join, :mandatory => true           # See Join.all_join_node
-      has_one :object_type, :mandatory => true    # See ObjectType.all_join_node
-      has_one :ordinal, :mandatory => true        # See Ordinal.all_join_node
-      has_one :role_name, :class => Name          # See Name.all_join_node_as_role_name
-      has_one :subscript                          # See Subscript.all_join_node
-      has_one :value                              # See Value.all_join_node
+    class LinkFactType < FactType
     end
 
-    class Position
+    class Location
       identified_by :x, :y
-      has_one :x, :mandatory => true              # See X.all_position
-      has_one :y, :mandatory => true              # See Y.all_position
+      has_one :x, :mandatory => true              # See X.all_location
+      has_one :y, :mandatory => true              # See Y.all_location
     end
 
     class PresenceConstraint < Constraint
@@ -206,9 +217,13 @@ module ActiveFacts
       has_one :role_sequence, :mandatory => true  # See RoleSequence.all_presence_constraint
     end
 
+    class Query < Concept
+    end
+
     class Reading
       identified_by :fact_type, :ordinal
       has_one :fact_type, :mandatory => true      # See FactType.all_reading
+      maybe :is_negative
       has_one :ordinal, :mandatory => true        # See Ordinal.all_reading
       has_one :role_sequence, :mandatory => true  # See RoleSequence.all_reading
       has_one :text, :mandatory => true           # See Text.all_reading
@@ -223,7 +238,7 @@ module ActiveFacts
     class Role < Concept
       identified_by :fact_type, :ordinal
       has_one :fact_type, :mandatory => true      # See FactType.all_role
-      one_to_one :implicit_fact_type, :counterpart => :implying_role  # See ImplicitFactType.implying_role
+      one_to_one :link_fact_type, :counterpart => :implying_role  # See LinkFactType.implying_role
       has_one :object_type, :mandatory => true    # See ObjectType.all_role
       has_one :ordinal, :mandatory => true        # See Ordinal.all_role
       has_one :role_name, :class => Name          # See Name.all_role_as_role_name
@@ -236,7 +251,7 @@ module ActiveFacts
     end
 
     class RoleValue
-      identified_by :instance, :fact
+      identified_by :fact, :role
       has_one :fact, :mandatory => true           # See Fact.all_role_value
       has_one :instance, :mandatory => true       # See Instance.all_role_value
       has_one :population, :mandatory => true     # See Population.all_role_value
@@ -248,10 +263,10 @@ module ActiveFacts
 
     class Shape
       identified_by :guid
-      has_one :diagram, :mandatory => true        # See Diagram.all_shape
       one_to_one :guid, :mandatory => true        # See Guid.shape
       maybe :is_expanded
-      has_one :position                           # See Position.all_shape
+      has_one :location                           # See Location.all_shape
+      has_one :orm_diagram, :class => "ORMDiagram", :mandatory => true  # See ORMDiagram.all_shape
     end
 
     class SubsetConstraint < SetConstraint
@@ -270,21 +285,41 @@ module ActiveFacts
     end
 
     class Value
-      identified_by :literal, :is_a_string, :unit
-      maybe :is_a_string
+      identified_by :literal, :is_literal_string, :unit
+      maybe :is_literal_string
       has_one :literal, :mandatory => true        # See Literal.all_value
       has_one :unit                               # See Unit.all_value
+      has_one :value_type, :mandatory => true     # See ValueType.all_value
     end
 
     class ValueConstraint < Constraint
+      has_one :regular_expression                 # See RegularExpression.all_value_constraint
       one_to_one :role, :counterpart => :role_value_constraint  # See Role.role_value_constraint
     end
 
+    class Variable
+      identified_by :query, :ordinal
+      has_one :object_type, :mandatory => true    # See ObjectType.all_variable
+      has_one :ordinal, :mandatory => true        # See Ordinal.all_variable
+      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
+      has_one :subscript                          # See Subscript.all_variable
+      has_one :value                              # See Value.all_variable
+    end
+
     class Vocabulary
       identified_by :name
       one_to_one :name, :mandatory => true        # See Name.vocabulary
     end
 
+    class Aggregation
+      identified_by :aggregate, :aggregated_variable
+      has_one :aggregate, :mandatory => true      # See Aggregate.all_aggregation
+      has_one :aggregated_variable, :class => Variable, :mandatory => true  # See Variable.all_aggregation_as_aggregated_variable
+      has_one :variable, :mandatory => true       # See Variable.all_aggregation
+    end
+
     class Agreement
       identified_by :context_note
       one_to_one :context_note, :mandatory => true  # See ContextNote.agreement
@@ -333,27 +368,13 @@ module ActiveFacts
       has_one :rotation_setting                   # See RotationSetting.all_fact_type_shape
     end
 
-    class JoinRole
-      identified_by :join_node, :role
-      has_one :join_node, :mandatory => true      # See JoinNode.all_join_role
-      has_one :role, :mandatory => true           # See Role.all_join_role
-      has_one :join_step, :counterpart => :incidental_join_role  # See JoinStep.all_incidental_join_role
-    end
-
-    class JoinStep
-      identified_by :input_join_role, :output_join_role
-      has_one :alternative_set                    # See AlternativeSet.all_join_step
-      has_one :fact_type, :mandatory => true      # See FactType.all_join_step
-      has_one :input_join_role, :class => JoinRole, :mandatory => true  # See JoinRole.all_join_step_as_input_join_role
-      maybe :is_anti
-      maybe :is_outer
-      has_one :output_join_role, :class => JoinRole, :mandatory => true  # See JoinRole.all_join_step_as_output_join_role
-    end
-
     class ModelNoteShape < Shape
       has_one :context_note, :mandatory => true   # See ContextNote.all_model_note_shape
     end
 
+    class ORMDiagram < Diagram
+    end
+
     class ObjectType < Concept
       identified_by :vocabulary, :name
       maybe :is_independent
@@ -368,10 +389,16 @@ module ActiveFacts
     end
 
     class ObjectifiedFactTypeNameShape < Shape
-      identified_by :fact_type_shape
       one_to_one :fact_type_shape, :mandatory => true  # See FactTypeShape.objectified_fact_type_name_shape
     end
 
+    class Play
+      identified_by :variable, :role
+      has_one :role, :mandatory => true           # See Role.all_play
+      has_one :variable, :mandatory => true       # See Variable.all_play
+      has_one :step, :counterpart => :incidental_play  # See Step.all_incidental_play
+    end
+
     class Population < Concept
       identified_by :vocabulary, :name
       has_one :name, :mandatory => true           # See Name.all_population
@@ -379,7 +406,6 @@ module ActiveFacts
     end
 
     class ReadingShape < Shape
-      identified_by :fact_type_shape
       one_to_one :fact_type_shape, :mandatory => true  # See FactTypeShape.reading_shape
       has_one :reading, :mandatory => true        # See Reading.all_reading_shape
     end
@@ -404,8 +430,8 @@ module ActiveFacts
       has_one :ordinal, :mandatory => true        # See Ordinal.all_role_ref
       has_one :role, :mandatory => true           # See Role.all_role_ref
       has_one :role_sequence, :mandatory => true  # See RoleSequence.all_role_ref
-      one_to_one :join_role                       # See JoinRole.role_ref
       has_one :leading_adjective, :class => Adjective  # See Adjective.all_role_ref_as_leading_adjective
+      one_to_one :play                            # See Play.role_ref
       has_one :trailing_adjective, :class => Adjective  # See Adjective.all_role_ref_as_trailing_adjective
     end
 
@@ -426,6 +452,16 @@ 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
@@ -437,49 +473,53 @@ module ActiveFacts
       has_one :minimum_bound, :class => Bound     # See Bound.all_value_range_as_minimum_bound
     end
 
-    class ValueType < ObjectType
-      has_one :auto_assigned_transaction_timing, :class => TransactionTiming  # See TransactionTiming.all_value_type_as_auto_assigned_transaction_timing
-      has_one :length                             # See Length.all_value_type
-      has_one :scale                              # See Scale.all_value_type
-      has_one :supertype, :class => ValueType     # See ValueType.all_value_type_as_supertype
-      has_one :unit                               # See Unit.all_value_type
-      one_to_one :value_constraint                # See ValueConstraint.value_type
-    end
-
     class AllowedRange
       identified_by :value_constraint, :value_range
       has_one :value_constraint, :mandatory => true  # See ValueConstraint.all_allowed_range
       has_one :value_range, :mandatory => true    # See ValueRange.all_allowed_range
     end
 
-    class EntityType < ObjectType
+    class DomainObjectType < ObjectType
+    end
+
+    class EntityType < DomainObjectType
       one_to_one :fact_type                       # See FactType.entity_type
       maybe :is_implied_by_objectification
     end
 
+    class TypeInheritance < FactType
+      identified_by :subtype, :supertype
+      has_one :subtype, :class => EntityType, :mandatory => true  # See EntityType.all_type_inheritance_as_subtype
+      has_one :supertype, :class => EntityType, :mandatory => true  # See EntityType.all_type_inheritance_as_supertype
+      has_one :assimilation                       # See Assimilation.all_type_inheritance
+      maybe :provides_identification
+    end
+
+    class ValueType < DomainObjectType
+      has_one :length                             # See Length.all_value_type
+      has_one :scale                              # See Scale.all_value_type
+      has_one :supertype, :class => ValueType     # See ValueType.all_value_type_as_supertype
+      has_one :transaction_timing                 # See TransactionTiming.all_value_type
+      has_one :unit                               # See Unit.all_value_type
+      one_to_one :value_constraint                # See ValueConstraint.value_type
+    end
+
     class Facet
       identified_by :value_type, :name
       has_one :name, :mandatory => true           # See Name.all_facet
       has_one :value_type, :mandatory => true     # See ValueType.all_facet
+      has_one :facet_value_type, :class => ValueType, :mandatory => true  # See ValueType.all_facet_as_facet_value_type
     end
 
-    class FacetValue
+    class FacetRestriction
       identified_by :value_type, :facet
-      has_one :facet, :mandatory => true          # See Facet.all_facet_value
-      has_one :value, :mandatory => true          # See Value.all_facet_value
-      has_one :value_type, :mandatory => true     # See ValueType.all_facet_value
+      has_one :facet, :mandatory => true          # See Facet.all_facet_restriction
+      has_one :value_type, :mandatory => true     # See ValueType.all_facet_restriction
+      has_one :value, :mandatory => true          # See Value.all_facet_restriction
     end
 
     class ImplicitBooleanValueType < ValueType
     end
 
-    class TypeInheritance < FactType
-      identified_by :subtype, :supertype
-      has_one :subtype, :class => EntityType, :mandatory => true  # See EntityType.all_type_inheritance_as_subtype
-      has_one :supertype, :class => EntityType, :mandatory => true  # See EntityType.all_type_inheritance_as_supertype
-      has_one :assimilation                       # See Assimilation.all_type_inheritance
-      maybe :provides_identification
-    end
-
   end
 end

data/lib/activefacts/vocabulary/verbaliser.rb

@@ -9,7 +9,7 @@ module ActiveFacts
     #
     # The Verbaliser fulfils two roles:
     # * Maintains verbalisation context to expand readings using subscripting where needed
-    # * Verbalises Joins by iteratively choosing a Join Step and expanding readings
+    # * Verbalises Queries by iteratively choosing a Step and expanding readings
     #
     # The verbalisation context consists of a set of Players, each for one ObjectType.
     # There may be more than one Player for the same ObjectType. If adjectives or role
@@ -17,30 +17,30 @@ module ActiveFacts
     # Thus, the verbalisation context must be completely populated before subscript
     # generation, which must be before any Player name gets verbalised.
     #
-    # When a Player occurs in a Join, it corresponds to one Join Node of that Join.
-    # Each such Player has one or more JoinRoles, which refer to roles played by
-    # that ObjectType. Where a join traverses two roles of a ternary fact type, there
-    # will be a residual node that has only a single JoinRole with no other meaning.
-    # A JoinRole must be for exactly one Player, so is used to identify a Player.
+    # When a Player occurs in a Query, it corresponds to one Variable of that Query.
+    # Each such Player has one or more Plays, which refer to roles played by
+    # that ObjectType. Where a query traverses two roles of a ternary fact type, there
+    # will be a residual node that has only a single Play with no other meaning.
+    # A Play must be for exactly one Player, so is used to identify a Player.
     #
-    # When a Player occurs outside a Join, it's identified by a projected RoleRef.
+    # When a Player occurs outside a Query, it's identified by a projected RoleRef.
     # REVISIT: This is untrue when a uniqueness constraint is imported from NORMA.
-    # In this case no join will be constructed to project the roles of the constrained
+    # In this case no query will be constructed to project the roles of the constrained
     # object type (only the constrained roles will be projected) - this will be fixed.
     #
     # Each constraint (except Ring Constraints) has one or more RoleSequence containing
-    # the projected RoleRefs. Each constrained RoleSequence may have an associated Join.
-    # If it has a Join, each RoleRef is projected from a JoinRole, otherwise none are.
+    # the projected RoleRefs. Each constrained RoleSequence may have an associated Query.
+    # If it has a Query, each RoleRef is projected from a Play, otherwise none are.
     #
-    # The only type of join possible in a Ring Constraint is a subtyping join, which
+    # The only type of query possible in a Ring Constraint is a subtyping query, which
     # is always implicit and unambiguous, so is never instantiated.
     #
-    # A constrained RoleSequence that has no explicit Join may have an implicit join,
-    # as per ORM2, when the roles aren't in the same fact type.  These implicit joins
+    # A constrained RoleSequence that has no explicit Query may have an implicit query,
+    # as per ORM2, when the roles aren't in the same fact type.  These implicit queries
     # are over only one ObjectType, by traversing a single FactType (and possibly,
     # multiple TypeInheritance FactTypes) for each RoleRef. Note however that when
     # the ObjectType is an objectified Fact Type, the FactType traversed might be a
-    # phantom of the objectification. In the case of implicit joins, each Player is
+    # phantom of the objectification. In the case of implicit queries, each Player is
     # identified by the projected RoleRef, except for the joined-over ObjectType whose
     # Player is... well, read the next paragraph!
     #
@@ -48,14 +48,14 @@ module ActiveFacts
     # respect to PresenceConstraints imported from NORMA (both external mandatory
     # and external uniqueness constraints). The joined-over Player in a UC is
     # identified by its RoleRefs in the RoleSequence of the Fact Type's preferred
-    # reading. Subtyping joins in a mandatory constraint will probably malfunction.
-    # However, all other such joins are expliciti, and these should be also.
+    # reading. Subtyping steps in a mandatory constraint will probably malfunction.
+    # However, all other such queries are explicit, and these should be also.
     #
     # For a SetComparisonConstraint, there are two or more constrained RoleSequences.
     # The matching RoleRefs (by Ordinal position) are for joined players, that is,
     # one individual instance plays both roles. The RoleRefs must (now) be for the
-    # same ObjectType (no implicit subtyping Join is allowed). Instead, the input modules
-    # find the closest common supertype and create explicit JoinSteps so its roles
+    # same ObjectType (no implicit subtyping step is allowed). Instead, the input modules
+    # find the closest common supertype and create explicit Steps so its roles
     # can be projected.
     #
     # When expanding Reading text however, the RoleRefs in the reading's RoleSequence
@@ -67,44 +67,44 @@ module ActiveFacts
     class Verbaliser
       # Verbalisation context:
       attr_reader :players
-      attr_reader :player_by_join_role        # Used for each join
-      attr_reader :player_joined_over         # Used when there's an implicit join
-      attr_reader :player_by_role_ref         # Used when a constrained role sequence has no join
+      attr_reader :player_by_play             # Used for each query
+      attr_reader :player_joined_over         # Used when there's an implicit query
+      attr_reader :player_by_role_ref         # Used when a constrained role sequence has no query
 
       # The projected role references over which we're verbalising
       attr_reader :role_refs
 
-      # Join Verbaliser context:
-      attr_reader :join
-      attr_reader :join_nodes                 # All Join Nodes
-      attr_reader :join_steps                 # All remaining unemitted Join Steps
-      attr_reader :join_steps_by_join_node    # A Hash by Join Node containing an array of remaining steps
+      # Query Verbaliser context:
+      attr_reader :query
+      attr_reader :variables                  # All Variables
+      attr_reader :steps                      # All remaining unemitted Steps
+      attr_reader :steps_by_variable          # A Hash by Variable containing an array of remaining steps
 
       def initialize role_refs = nil
         @role_refs = role_refs
 
         # Verbalisation context:
         @players = []
-        @player_by_join_role = {}
+        @player_by_play = {}
         @player_by_role_ref = {}
         @player_joined_over = nil
 
-        # Join Verbaliser context:
-        @join = nil
-        @join_nodes = []
-        @join_steps = []
-        @join_steps_by_join_node = {}
+        # Query Verbaliser context:
+        @query = nil
+        @variables = []
+        @steps = []
+        @steps_by_variable = {}
 
         add_role_refs role_refs if role_refs
       end
 
       class Player
-        attr_accessor :object_type, :join_nodes_by_join, :subscript, :join_roles, :role_refs
+        attr_accessor :object_type, :variables_by_query, :subscript, :plays, :role_refs
         def initialize object_type
           @object_type = object_type
-          @join_nodes_by_join = {}
+          @variables_by_query = {}
           @subscript = nil
-          @join_roles = []
+          @plays = []
           @role_refs = []
         end
 
@@ -122,21 +122,21 @@ module ActiveFacts
                 rr.trailing_adjective
               ].compact}.uniq.sort
           end
-          adjuncts += [@join_nodes_by_join.values.map{|jn| jn.role_name}.compact[0]].compact
+          adjuncts += [@variables_by_query.values.map{|jn| jn.role_name}.compact[0]].compact
           adjuncts.flatten*"_"
         end
 
         def describe
-          @object_type.name + (@join_nodes_by_join.size > 0 ? " (in #{@join_nodes_by_join.size} joins)" : "")
+          @object_type.name + (@variables_by_query.size > 0 ? " (in #{@variables_by_query.size} variables)" : "")
         end
       end
 
       # Find or create a Player to which we can add this role_ref
       def player(ref)
-        existing_player = if ref.is_a?(ActiveFacts::Metamodel::JoinRole)
-            @player_by_join_role[ref]
+        existing_player = if ref.is_a?(ActiveFacts::Metamodel::Play)
+            @player_by_play[ref]
           else
-            @player_by_role_ref[ref] or ref.join_role && @player_by_join_role[ref.join_role]
+            @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}'"
@@ -149,22 +149,22 @@ module ActiveFacts
         end
       end
 
-      def add_join_role player, join_role
-        return if player.join_roles.include?(join_role)
-        jn = join_role.join_node
-        if jn1 = player.join_nodes_by_join[jn.join] and jn1 != jn
-          raise "Player for #{player.object_type.name} may only have one join node per join, not #{jn1.object_type.name} and #{jn.object_type.name}"
+      def add_play player, play
+        return if player.plays.include?(play)
+        jn = play.variable
+        if jn1 = player.variables_by_query[jn.query] and jn1 != jn
+          raise "Player for #{player.object_type.name} may only have one variable per query, not #{jn1.object_type.name} and #{jn.object_type.name}"
         end
-        player.join_nodes_by_join[jn.join] = jn
-        @player_by_join_role[join_role] = player
-        player.join_roles << join_role
+        player.variables_by_query[jn.query] = jn
+        @player_by_play[play] = player
+        player.plays << play
       end
 
       # 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}"
-        if jr = role_ref.join_role
-          add_join_role(player, jr)
+        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"
           player.role_refs.push(role_ref)
@@ -212,20 +212,20 @@ module ActiveFacts
         end
       end
 
-      def join_roles_have_same_player join_roles
-        return if join_roles.empty?
+      def plays_have_same_player plays
+        return if plays.empty?
 
-        # If any of these join_roles are for a known player, use that, else make a new player.
-        existing_players = join_roles.map{|jr| @player_by_join_role[jr] }.compact.uniq
+        # 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
         if existing_players.size > 1
-          raise "Can't join these roles to more than one existing player: #{existing_players.map{|p|p.object_type.name}*', '}!"
+          raise "At most one existing player can play these roles: #{existing_players.map{|p|p.object_type.name}*', '}!"
         end
-        p = existing_players[0] || player(join_roles[0])
-        debugger if join_roles.detect{|jr| jr.role.object_type != p.object_type }
-        debug :subscript, "Joining roles to #{p.describe}" do
-          join_roles.each do |jr|
-            debug :subscript, "#{jr.describe}" do
-              add_join_role p, jr
+        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
+          plays.each do |play|
+            debug :subscript, "#{play.describe}" do
+              add_play p, play
             end
           end
         end
@@ -238,16 +238,16 @@ module ActiveFacts
 
         # If any of these role_refs are for a known player, use that, else make a new player.
         existing_players =
-          role_refs.map{|rr| @player_by_role_ref[rr] || @player_by_join_role[rr.join_role] }.compact.uniq
+          role_refs.map{|rr| @player_by_role_ref[rr] || @player_by_play[rr.play] }.compact.uniq
         if existing_players.size > 1
-          raise "Can't join these role_refs to more than one existing player: #{existing_players.map{|p|p.object_type.name}*', '}!"
+          raise "At most one existing player can play these roles: #{existing_players.map{|p|p.object_type.name}*', '}!"
         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
           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 join.
+              # This happens in SubtypePI because uniqueness constraint is built without its implicit subtyping step.
               # For now, explode only if there's no common supertype:
               if 0 == (p.object_type.supertypes_transitive & rr.role.object_type.supertypes_transitive).size
                 raise "REVISIT: Internal error, trying to add role of #{rr.role.object_type.name} to player #{p.object_type.name}"
@@ -287,11 +287,11 @@ module ActiveFacts
                     p.role_refs.map{|rr| rr.role.fact_type.preferred_reading.text}.sort.to_s
                 }.
                 each do |player|
-                jrname = player.join_roles.map{|jr| jr.role_ref && jr.role_ref.role.role_name}.compact[0]
+                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.join_nodes_by_join.values.each{|jn| jn.role_name = jrname }
+                  player.variables_by_query.values.each{|jn| jn.role_name = jrname }
                else
                   player.subscript = s+1
                   s += 1
@@ -312,9 +312,9 @@ module ActiveFacts
         end
       end
 
-      # Where no explicit Join has been created, a join is still sometimes present (e.g. in a constraint from NORMA)
-      # REVISIT: This probably doesn't produce the required result. Need to fix the NORMA importer to create the join.
-      def role_refs_are_subtype_joined roles
+      # Where no explicit Query has been created, a query is still sometimes present (e.g. in a constraint from NORMA)
+      # REVISIT: This probably doesn't produce the required result. Need to fix the NORMA importer to create the query.
+      def role_refs_have_subtype_steps roles
         role_refs = roles.is_a?(Array) ? roles : roles.all_role_ref.to_a
         role_refs_by_object_type = role_refs.inject({}) { |h, r| (h[r.role.object_type] ||= []) << r; h }
         role_refs_by_object_type.values.each { |rrs|  role_refs_have_same_player(rrs) }
@@ -322,7 +322,7 @@ module ActiveFacts
 
       # These roles are the players in an implicit counterpart join in a Presence Constraint.
       # REVISIT: It's not clear that we can safely use the preferred_reading's RoleRefs here.
-      # Fix the CQL compiler to create proper joins for these presence constraints instead.
+      # Fix the CQL compiler to create proper queries for these presence constraints instead.
       def roles_have_same_player roles
         role_refs = roles.map do |role|
           role.fact_type.all_reading.map{|reading|
@@ -336,8 +336,8 @@ module ActiveFacts
       def prepare_role_sequence role_sequence, join_over = nil
         @role_refs = role_sequence.is_a?(Array) ? role_sequence : role_sequence.all_role_ref.to_a
 
-        if jrr = @role_refs.detect{|rr| rr.join_role && rr.join_role.join_node}
-          return prepare_join_players(jrr.join_role.join_node.join)
+        if jrr = @role_refs.detect{|rr| rr.play && rr.play.variable}
+          return prepare_query_players(jrr.play.variable.query)
         end
 
         # Ensure that all the joined-over role_refs are indexed for subscript generation.
@@ -360,42 +360,42 @@ module ActiveFacts
         end
       end
 
-      def prepare_join_players join
-        debug :subscript, "Indexing roles of fact types in #{join.all_join_step.size} join steps" do
-          join_steps = []
-          # Register all references to each join node as being for the same player:
-          join.all_join_node.sort_by{|jn| jn.ordinal}.each do |join_node|
-            debug :subscript, "Adding Roles of #{join_node.describe}" do
-              join_roles_have_same_player(join_node.all_join_role.to_a)
-              join_steps = join_steps | join_node.all_join_step
+      def prepare_query_players query
+        debug :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
+              plays_have_same_player(variable.all_play.to_a)
+              steps = steps | variable.all_step
             end
           end
 
 =begin
-          # For each fact type traversed, register a player for each role *not* linked to this join
+          # For each fact type traversed, register a player for each role *not* linked to this query
           # REVISIT: Using the preferred_reading role_ref is wrong here; the same preferred_reading might occur twice,
           # so the respective object_type will need more than one Player and will be subscripted to keep them from being joined.
-          # Accordingly, there must be a join step for each such role, and to enforce that, I raise an exception here on duplication.
-          # This isn't needed now all JoinNodes have at least one JoinRole
+          # Accordingly, there must be a step for each such role, and to enforce that, I raise an exception here on duplication.
+          # This isn't needed now all Variables have at least one Play
 
-          join_steps.map do |js|
-            if js.fact_type.is_a?(ActiveFacts::Metamodel::ImplicitFactType)
+          steps.map do |js|
+            if js.fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
               js.fact_type.implying_role.fact_type
             else
               js.fact_type
             end
           end.uniq.each do |fact_type|
-          #join_steps.map{|js|js.fact_type}.uniq.each do |fact_type|
-            next if fact_type.is_a?(ActiveFacts::Metamodel::ImplicitFactType)
+          #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
               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.join_node && rr.join_node.join == join} }
+              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 join"
+                debug :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 join"
+                  raise "Adding DUPLICATE residual role for #{r.object_type.name} not covered in query"
                 end
                 role_refs_have_same_player([preferred_role_ref])
               end
@@ -405,15 +405,15 @@ module ActiveFacts
         end
       end
 
-      def verbalise_over_role_sequence role_sequence, joiner = ' and ', role_proximity = :both
+      def verbalise_over_role_sequence role_sequence, conjunction = ' and ', role_proximity = :both
         @role_refs = role_sequence.is_a?(Array) ? role_sequence : role_sequence.all_role_ref.to_a
 
-        if jrr = role_refs.detect{|rr| rr.join_role}
-          return verbalise_join(jrr.join_role.join_node.join)
+        if jrr = role_refs.detect{|rr| rr.play}
+          return verbalise_query(jrr.play.variable.query)
         end
 
-        # First, figure out whether there's a join:
-        join_over, joined_roles = *Metamodel.join_roles_over(role_sequence.all_role_ref.map{|rr|rr.role}, role_proximity)
+        # First, figure out whether there's a query:
+        join_over, joined_roles = *Metamodel.plays_over(role_sequence.all_role_ref.map{|rr|rr.role}, role_proximity)
 
         role_by_fact_type = {}
         fact_types = @role_refs.map{|rr| ft = rr.role.fact_type; role_by_fact_type[ft] ||= rr.role; ft}.uniq
@@ -425,7 +425,7 @@ module ActiveFacts
             joined_role = fact_type.all_role.select{|r| join_over.subtypes_transitive.include?(r.object_type)}[0]
             reading = fact_type.reading_preferably_starting_with_role joined_role
 
-            # Use the name of the joined_over object, not the role player, in case of a subtype join:
+            # Use the name of the joined_over object, not the role player, in case of a subtype step:
             rrrs = reading.role_sequence.all_role_ref_in_order
             role_index = (0..rrrs.size).detect{|i| rrrs[i].role == joined_role }
             name_substitutions[role_index] = [nil, join_over.name]
@@ -439,43 +439,48 @@ module ActiveFacts
           @player_by_role_ref.keys.each{|rr| player_by_role[rr.role] = @player_by_role_ref[rr] if rr.role.fact_type == fact_type }
           expand_reading_text(nil, reading.text, reading.role_sequence, player_by_role)
         end
-        joiner ? readings*joiner : readings
+        conjunction ? readings*conjunction : readings
       end
 
       # 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->join_node hash"
+          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
+	  variable_by_role = plays.inject({}) { |h, play| h[play.role] = play.variable; h }
+	end
         debug :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?)
-            # REVISIT: There's no way to get literals to be emitted here (value join step or query result?)
-
             player = player_by_role[role_ref.role]
+	    variable = variable_by_role[role_ref.role]
 
-            join_role_name = player && player.join_nodes_by_join.values.map{|jn| jn.role_name}.compact[0]
-            subscripted_player(role_ref, player && player.subscript, join_role_name) +
+            play_name = variable && variable.role_name
+            subscripted_player(role_ref, player && player.subscript, play_name, variable && variable.value) +
               objectification_verbalisation(role_ref.role.object_type)
           end
         end
       end
 
-      def subscripted_player role_ref, subscript = nil, join_role_name = nil
+      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
         object_type = role_ref.role.object_type
-        (join_role_name ||
+        (play_name ||
           [
             role_ref.leading_adjective,
             object_type.name,
             role_ref.trailing_adjective
           ].compact*' '
         ) +
+	  (value ? ' '+value.inspect : '') +
           (subscript ? "(#{subscript})" : '')
       end
 
@@ -484,72 +489,75 @@ module ActiveFacts
           expand_reading_text(step, reading.text.sub(/\A\{\d\} /,''), reading.role_sequence, role_refs)
       end
 
-      # Each join we wish to verbalise must first have had its players prepared.
-      # Then, this prepares the join for verbalising:
-      def prepare_join join
-        @join = join
-        return unless join
+      # Each query we wish to verbalise must first have had its players prepared.
+      # Then, this prepares the query for verbalising:
+      def prepare_query query
+        @query = query
+        return unless query
 
-        @join_nodes = join.all_join_node.sort_by{|jn| jn.ordinal}
+        @variables = query.all_variable.sort_by{|jn| jn.ordinal}
 
-        @join_steps = @join_nodes.map{|jn| jn.all_join_step }.flatten.uniq
-        @join_steps_by_join_node = @join_nodes.
+        @steps = @variables.map{|jn| jn.all_step }.flatten.uniq
+        @steps_by_variable = @variables.
           inject({}) do |h, jn|
-            jn.all_join_step.each{|js| (h[jn] ||= []) << js}
+            jn.all_step.each{|js| (h[jn] ||= []) << js}
             h
           end
       end
 
       # Remove this step now that we've processed it:
       def step_completed(step)
-        @join_steps.delete(step)
+        @steps.delete(step)
 
-        input_node = step.input_join_role.join_node
-        steps = @join_steps_by_join_node[input_node]
+        input_node = step.input_play.variable
+        steps = @steps_by_variable[input_node]
         steps.delete(step)
-        @join_steps_by_join_node.delete(input_node) if steps.empty?
+        @steps_by_variable.delete(input_node) if steps.empty?
 
-        output_node = step.output_join_role.join_node
+        output_node = step.output_play.variable
         if (input_node != output_node)
-          steps = @join_steps_by_join_node[output_node]
+          steps = @steps_by_variable[output_node]
           steps.delete(step)
-          @join_steps_by_join_node.delete(output_node) if steps.empty?
+          @steps_by_variable.delete(output_node) if steps.empty?
         end
       end
 
       def choose_step(next_node)
-        next_steps = @join_steps_by_join_node[next_node]
+        next_steps = @steps_by_variable[next_node]
+
+        # 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,
-        # so just use any join step involving this node, or just any step.
+        # 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 :join, "Chose new non-objectification step: #{next_step.describe}"
+            debug :query, "Chose new non-objectification step: #{next_step.describe}"
             return next_step
           end
         end
 
-        if next_step = @join_steps.detect { |ns| !ns.is_objectification_step }
-          debug :join, "Chose random non-objectification step: #{next_step.describe}"
+        if next_step = @steps.detect { |ns| !ns.is_objectification_step }
+          debug :query, "Chose random non-objectification step: #{next_step.describe}"
           return next_step
         end
 
-        next_step = @join_steps[0]
+        next_step = @steps[0]
         if next_step
-          debug :join, "Chose new random step from #{join_steps.size}: #{next_step.describe}"
+          debug :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
-            jn = [next_step.input_join_role.join_node, next_step.output_join_role.join_node].detect{|jn| jn.object_type == fact_type.entity_type}
-            sr = @join_steps_by_join_node[jn].reject{|t| r = t.fact_type.implying_role and r.fact_type == fact_type}
+            jn = [next_step.input_play.variable, next_step.output_play.variable].detect{|jn| jn.object_type == fact_type.entity_type}
+            sr = @steps_by_variable[jn].reject{|t| r = t.fact_type.implying_role and r.fact_type == fact_type}
             next_step = sr[0] if sr.size > 0 
           end
           return next_step
         end
-        raise "Internal error: There are more join steps here, but we failed to choose one"
+        raise "Internal error: There are more steps here, but we failed to choose one"
       end
 
-      # The join step we just emitted (using the reading given) is contractable iff
+      # 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)
         reading &&
@@ -573,7 +581,7 @@ module ActiveFacts
         next_reading = nil
         next_step =
           next_steps.detect do |js|
-            next false if js.is_objectification_step
+            next false if js.is_objectification_step or js.is_disallowed
             # 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|
@@ -582,50 +590,50 @@ module ActiveFacts
               end
             next_reading
           end
-        debug :join, "#{next_reading ? "'"+next_reading.expand+"'" : "No reading"} contracts against last node '#{next_node.object_type.name}'"
+        debug :query, "#{next_reading ? "'"+next_reading.expand+"'" : "No reading"} contracts against last node '#{next_node.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 Join Node here and emit an objectification step involving that node.
+      # 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)
         objectified_node = nil
         unless object_type.is_a?(Metamodel::EntityType) and
           object_type.fact_type and            # Not objectified
-          objectification_step = @join_steps.
+          objectification_step = @steps.
             detect do |js|
-              # The objectifying entity type should always be the input_join_node here, but be safe:
+              # The objectifying entity type should always be the input_variable here, but be safe:
               js.is_objectification_step and
-                (objectified_node = js.input_join_role.join_node).object_type == object_type ||
-                (objectified_node = js.output_join_role.join_node).object_type == object_type
+                (objectified_node = js.input_play.variable).object_type == object_type ||
+                (objectified_node = js.output_play.variable).object_type == object_type
             end
           return ''
         end
 
         # REVISIT: We need to be working from the role_ref here - pass it in
-        # if objectification_step.join_node != role_ref.join_node
+        # if objectification_step.variable != role_ref.variable
 
         steps = [objectification_step]
         step_completed(objectification_step)
         while other_step =
-          @join_steps.
+          @steps.
             detect{|js|
               js.is_objectification_step and
-                js.input_join_role.join_node.object_type == object_type || js.output_join_role.join_node.object_type == object_type
+                js.input_play.variable.object_type == object_type || js.output_play.variable.object_type == object_type
             }
           steps << other_step
-          debug :join, "Emitting objectification step allows deleting #{other_step.describe}"
+          debug :query, "Emitting objectification step allows deleting #{other_step.describe}"
           step_completed(other_step)
         end
 
-        # Find all references to roles in this objectified fact type which are relevant to the join nodes of these steps:
+        # 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 |join_step|
-          join_step.all_join_role.to_a.map do |jr|
-            player_by_role[jr.role] = @player_by_join_role[jr]
+        steps.each do |step|
+          step.all_play.to_a.map do |jr|
+            player_by_role[jr.role] = @player_by_play[jr]
           end
         end
 
-        # role_refs = steps.map{|step| [step.input_join_role.join_node, step.output_join_role.join_node].map{|jn| jn.all_role_ref.detect{|rr| rr.role.fact_type == object_type.fact_type}}}.flatten.compact.uniq
+        # role_refs = steps.map{|step| [step.input_play.variable, step.output_play.variable].map{|jn| jn.all_role_ref.detect{|rr| rr.role.fact_type == object_type.fact_type}}}.flatten.compact.uniq
 
         reading = object_type.fact_type.preferred_reading
         " (in which #{expand_reading_text(objectification_step, reading.text, reading.role_sequence, player_by_role)})" 
@@ -636,46 +644,53 @@ module ActiveFacts
           # Choose a reading that's contractable against the previous step, if possible
           reading = fact_type.all_reading_by_ordinal.
             detect do |reading|
-              reading_starts_with_node(reading, next_node)
+	      # 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)
             end
         end
         last_is_contractable = false unless reading
-        reading ||= fact_type.preferred_reading
+        reading ||= fact_type.preferred_reading(next_step.is_disallowed) || fact_type.preferred_reading
 
-        # Find which role occurs last in the reading, and which Join Node is attached
+        # 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 = @join_nodes.detect{|jn| jn.all_join_role.detect{|jr| jr.role == last_role_ref.role}}
+        exit_node = @variables.detect{|jn| jn.all_play.detect{|jr| jr.role == last_role_ref.role}}
         exit_step = nil
 
-        count = 0
-        while other_step =
-          @join_steps.
-            detect{|js|
-              next unless js.is_objectification_step
-              # REVISIT: This test is too weak: We need to ensure that the same join nodes are involved, not just the same object types:
-              next unless js.input_join_role.join_node.object_type == fact_type.entity_type || js.output_join_role.join_node.object_type == fact_type.entity_type
-              exit_step = js if js.output_join_role.join_node == exit_node
-              true
-            }
-          debug :join, "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 join steps" if (count += 1) > fact_type.all_role.size
-        end
-        [ reading, exit_step ? exit_step.input_join_role.join_node : exit_node, exit_step, last_is_contractable]
+	debug :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}'"
+		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:
+		next unless js.input_play.variable.object_type == fact_type.entity_type || js.output_play.variable.object_type == fact_type.entity_type
+		exit_step = js if js.output_play.variable == exit_node
+		true
+	      }
+	    debug :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
+	end
+
+	[ reading, exit_step ? exit_step.input_play.variable : exit_node, exit_step, last_is_contractable]
       end
 
-      def verbalise_join join
-        prepare_join join
+      def verbalise_query query
+        prepare_query query
         readings = ''
-        next_node = @role_refs[0].join_role.join_node   # Choose a place to start
+        next_node = @role_refs[0].play.variable   # Choose a place to start
         last_is_contractable = false
-        debug :join, "Join Nodes are #{@join_nodes.map{|jn| jn.describe }.inspect}, Join Steps are #{@join_steps.map{|js| js.describe }.inspect}" do
-          until @join_steps.empty?
+        debug :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 = @join_steps_by_join_node[next_node]
-            debug :join, "Next Steps from #{next_node.describe} are #{(next_steps||[]).map{|js| js.describe }.inspect}"
+            next_steps = @steps_by_variable[next_node]
+            debug :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
@@ -684,24 +699,28 @@ module ActiveFacts
                 end
 
             if next_step
-              debug :join, "Chose #{next_step.describe} because it's contractable against last node #{next_node.object_type.name} using #{next_reading.expand}"
+              debug :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_join_role.inject({}) {|h, jr| h[jr.role] = @player_by_join_role[jr]; h }
+                next_step.all_play.inject({}) {|h, jr| h[jr.role] = @player_by_play[jr]; 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
 
               player_by_role =
-                next_step.all_join_role.inject({}) {|h, jr| h[jr.role] = @player_by_join_role[jr]; h }
+                next_step.all_play.inject({}) {|h, jr| h[jr.role] = @player_by_play[jr]; h }
 
               if next_step.is_unary_step
                 # Objectified unaries get emitted as unaries, not as objectifications:
-                role = next_step.input_join_role.role
-                role = role.fact_type.implying_role if role.fact_type.is_a?(ImplicitFactType)
-                next_reading = role.fact_type.preferred_reading
+                role = next_step.input_play.role
+                role = role.fact_type.implying_role if role.fact_type.is_a?(LinkFactType)
+		next_reading = role.fact_type.preferred_reading(next_step.is_disallowed) || role.fact_type.preferred_reading
                 readings += " and " unless readings.empty?
+		readings += "it is not the case that " if !next_step.is_disallowed != !next_reading.is_negative
+		raise "REVISIT: Need to emit 'maybe' here" if next_step.is_optional
                 readings += expand_reading_text(next_step, next_reading.text, next_reading.role_sequence, player_by_role)
                 step_completed(next_step)
               elsif next_step.is_objectification_step
@@ -709,11 +728,11 @@ module ActiveFacts
 
                 # This objectification step is over an implicit fact type, so player_by_role won't have all the players
                 # Add the players of other roles associated with steps from this objectified player.
-                objectified_node = next_step.input_join_role.join_node
-                raise "Assumption violated that the objectification is the input join role" unless objectified_node.object_type.fact_type
-                objectified_node.all_join_step.map do |other_step|
-                  (other_step.all_incidental_join_role.to_a + [other_step.output_join_role]).map do |jr|
-                    player_by_role[jr.role] = @player_by_join_role[jr]
+                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]
                   end
                 end
 
@@ -723,16 +742,20 @@ module ActiveFacts
                   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)
                   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)
                   else
                     readings += " and " unless readings.empty?
+		    readings += "it is not the case that " if !!negation != !!next_reading.is_negative
+		    raise "REVISIT: Need to emit 'maybe' here" if next_step and next_step.is_optional
                     readings += expand_reading_text(next_step, next_reading.text, next_reading.role_sequence, player_by_role)
                   end
                   # No need to continue if we just deleted the last step
-                  break if @join_steps.empty?
+                  break if @steps.empty?
 
                 end
               else
@@ -740,21 +763,30 @@ module ActiveFacts
                 # Prefer a reading that starts with the player of next_node
                 next_reading = fact_type.all_reading_by_ordinal.
                   detect do |reading|
-                    reading_starts_with_node(reading, next_node)
-                  end || fact_type.preferred_reading
-                # REVISIT: If this join step and reading has role references with adjectives, we need to expand using those
+		    (!next_step.is_disallowed || !reading.is_negative == !next_step.is_disallowed) and
+		      reading_starts_with_node(reading, next_node)
+                  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?
+		readings += "it is not the case that " if !next_step.is_disallowed != !next_reading.is_negative
+		raise "REVISIT: Need to emit 'maybe' here" if next_step and next_step.is_optional
                 readings += expand_reading_text(next_step, next_reading.text, next_reading.role_sequence, player_by_role)
                 step_completed(next_step)
               end
             end
 
-            # Continue from this step with the node having the most steps remaining
-            input_steps = @join_steps_by_join_node[input_node = next_step.input_join_role.join_node] || []
-            output_steps = @join_steps_by_join_node[output_node = next_step.output_join_role.join_node] || []
-            next_node = input_steps.size > output_steps.size ? input_node : output_node
-            # Prepare for possible contraction following:
-            last_is_contractable = next_reading && node_contractable_against_reading(next_node, next_reading)
+	    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
+	      # Prepare for possible contraction following:
+	      last_is_contractable = next_reading && node_contractable_against_reading(next_node, 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
+	      last_is_contractable = false
+	    end
 
           end
         end