activefacts 0.8.9 → 0.8.10

data/lib/activefacts/vocabulary/metamodel.rb

@@ -136,6 +136,11 @@ module ActiveFacts
       value_type :length => 256
     end
 
+    class TransactionTiming < String
+      value_type 
+      restrict 'assert', 'commit'
+    end
+
     class UnitId < AutoCounter
       value_type 
     end
@@ -169,12 +174,12 @@ module ActiveFacts
 
     class ContextNote
       identified_by :context_note_id
-      has_one :concept                            # See Concept.all_context_note
       has_one :constraint                         # See Constraint.all_context_note
       one_to_one :context_note_id, :mandatory => true  # See ContextNoteId.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 :fact_type                          # See FactType.all_context_note
+      has_one :object_type                        # See ObjectType.all_context_note
     end
 
     class Enforcement
@@ -201,9 +206,9 @@ module ActiveFacts
 
     class Instance
       identified_by :instance_id
-      has_one :concept, :mandatory => true        # See Concept.all_instance
       one_to_one :fact                            # See Fact.instance
       one_to_one :instance_id, :mandatory => true  # See InstanceId.instance
+      has_one :object_type, :mandatory => true    # See ObjectType.all_instance
       has_one :population, :mandatory => true     # See Population.all_instance
       has_one :value                              # See Value.all_instance
     end
@@ -215,9 +220,10 @@ module ActiveFacts
 
     class JoinNode
       identified_by :join, :ordinal
-      has_one :concept, :mandatory => true        # See Concept.all_join_node
       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
     end
@@ -254,8 +260,8 @@ module ActiveFacts
       identified_by :fact_type, :ordinal
       has_one :fact_type, :mandatory => true      # See FactType.all_role
       has_one :ordinal, :mandatory => true        # See Ordinal.all_role
-      has_one :concept, :mandatory => true        # See Concept.all_role
-      one_to_one :implicit_fact_type              # See ImplicitFactType.role
+      one_to_one :implicit_fact_type, :counterpart => :implying_role  # See ImplicitFactType.implying_role
+      has_one :object_type, :mandatory => true    # See ObjectType.all_role
       has_one :role_name, :class => Name          # See Name.all_role_as_role_name
     end
 
@@ -329,14 +335,6 @@ module ActiveFacts
       has_one :value, :mandatory => true          # See Value.all_bound
     end
 
-    class Concept
-      identified_by :vocabulary, :name
-      maybe :is_independent
-      has_one :name, :mandatory => true           # See Name.all_concept
-      has_one :pronoun                            # See Pronoun.all_concept
-      has_one :vocabulary, :mandatory => true     # See Vocabulary.all_concept
-    end
-
     class ConstraintShape < Shape
       has_one :constraint, :mandatory => true     # See Constraint.all_constraint_shape
     end
@@ -367,10 +365,6 @@ module ActiveFacts
       has_one :vocabulary, :mandatory => true     # See Vocabulary.all_diagram
     end
 
-    class EntityType < Concept
-      one_to_one :fact_type                       # See FactType.entity_type
-    end
-
     class FactTypeShape < Shape
       has_one :display_role_names_setting         # See DisplayRoleNamesSetting.all_fact_type_shape
       has_one :fact_type, :mandatory => true      # See FactType.all_fact_type_shape
@@ -397,9 +391,17 @@ module ActiveFacts
       has_one :context_note, :mandatory => true   # See ContextNote.all_model_note_shape
     end
 
+    class ObjectType
+      identified_by :vocabulary, :name
+      maybe :is_independent
+      has_one :name, :mandatory => true           # See Name.all_object_type
+      has_one :pronoun                            # See Pronoun.all_object_type
+      has_one :vocabulary, :mandatory => true     # See Vocabulary.all_object_type
+    end
+
     class ObjectTypeShape < Shape
-      has_one :concept, :mandatory => true        # See Concept.all_object_type_shape
       maybe :has_expanded_reference_mode
+      has_one :object_type, :mandatory => true    # See ObjectType.all_object_type_shape
     end
 
     class ObjectifiedFactTypeNameShape < Shape
@@ -461,14 +463,6 @@ module ActiveFacts
       maybe :is_mandatory
     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 ValueConstraintShape < ConstraintShape
       has_one :object_type_shape                  # See ObjectTypeShape.all_value_constraint_shape
       one_to_one :role_display                    # See RoleDisplay.value_constraint_shape
@@ -480,8 +474,8 @@ module ActiveFacts
       has_one :minimum_bound, :class => Bound     # See Bound.all_value_range_as_minimum_bound
     end
 
-    class ValueType < Concept
-      maybe :is_auto_assigned
+    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
@@ -495,20 +489,32 @@ module ActiveFacts
       has_one :value_range, :mandatory => true    # See ValueRange.all_allowed_range
     end
 
+    class EntityType < ObjectType
+      one_to_one :fact_type                       # See FactType.entity_type
+    end
+
     class ImplicitBooleanValueType < ValueType
     end
 
-    class Parameter
-      identified_by :name, :value_type
-      has_one :name, :mandatory => true           # See Name.all_parameter
-      has_one :value_type, :mandatory => true     # See ValueType.all_parameter
+    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
+    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 ParamValue
-      identified_by :value, :parameter
-      has_one :parameter, :mandatory => true      # See Parameter.all_param_value
-      has_one :value, :mandatory => true          # See Value.all_param_value
-      has_one :value_type, :mandatory => true     # See ValueType.all_param_value
+    class FacetValue
+      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
     end
 
   end

data/lib/activefacts/vocabulary/verbaliser.rb

@@ -11,15 +11,15 @@ module ActiveFacts
     # * Maintains verbalisation context to expand readings using subscripting where needed
     # * Verbalises Joins by iteratively choosing a Join Step and expanding readings
     #
-    # The verbalisation context consists of a set of Players, each for one Concept.
-    # There may be more than one Player for the same Concept. If adjectives or role
+    # 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
     # names don't make such duplicates unambiguous, subscripts will be generated.
     # 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 Concept. Where a join traverses two roles of a ternary fact type, there
+    # 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.
     #
@@ -37,11 +37,11 @@ module ActiveFacts
     #
     # 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
-    # are over only one Concept, by traversing a single FactType (and possibly,
+    # are over only one ObjectType, by traversing a single FactType (and possibly,
     # multiple TypeInheritance FactTypes) for each RoleRef. Note however that when
-    # the Concept is an objectified Fact Type, the FactType traversed might be a
+    # 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
-    # identified by the projected RoleRef, except for the joined-over Concept whose
+    # identified by the projected RoleRef, except for the joined-over ObjectType whose
     # Player is... well, read the next paragraph!
     #
     # REVISIT: I believe that the foregoing paragraph is out of date, except with
@@ -54,7 +54,7 @@ module ActiveFacts
     # 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 Concept (no implicit subtyping Join is allowed). Instead, the input modules
+    # same ObjectType (no implicit subtyping Join is allowed). Instead, the input modules
     # find the closest common supertype and create explicit JoinSteps so its roles
     # can be projected.
     #
@@ -99,9 +99,9 @@ module ActiveFacts
       end
 
       class Player
-        attr_accessor :concept, :join_nodes_by_join, :subscript, :join_roles, :role_refs
-        def initialize concept
-          @concept = concept
+        attr_accessor :object_type, :join_nodes_by_join, :subscript, :join_roles, :role_refs
+        def initialize object_type
+          @object_type = object_type
           @join_nodes_by_join = {}
           @subscript = nil
           @join_roles = []
@@ -111,30 +111,41 @@ module ActiveFacts
         # What words are used (across all roles) for disambiguating the references to this player?
         # If more than one set of adjectives was used, this player must have been subject to loose binding.
         # This method is used to decide when subscripts aren't needed.
-        def role_adjuncts
-          adjuncts = @role_refs.map{|rr|
-            [
-              rr.leading_adjective,
-              # rr.role.role_name,
-              rr.trailing_adjective
-            ].compact}.uniq.sort
+        def role_adjuncts matching
+          if matching == :loose
+            adjuncts = []
+          else
+            adjuncts = @role_refs.map{|rr|
+              [
+                rr.leading_adjective,
+                matching == :rolenames ? rr.role.role_name : nil,
+                rr.trailing_adjective
+              ].compact}.uniq.sort
+          end
+          adjuncts += [@join_nodes_by_join.values.map{|jn| jn.role_name}.compact[0]].compact
           adjuncts.flatten*"_"
         end
 
         def describe
-          @concept.name + (@join_nodes_by_join.size > 0 ? " (in #{@join_nodes_by_join.size} joins)" : "")
+          @object_type.name + (@join_nodes_by_join.size > 0 ? " (in #{@join_nodes_by_join.size} joins)" : "")
         end
       end
 
       # Find or create a Player to which we can add this role_ref
       def player(ref)
-        if ref.is_a?(ActiveFacts::Metamodel::JoinRole)
-          @player_by_join_role[ref] or
-            @players.push(p = Player.new(ref.role.concept)) && p
+        existing_player = if ref.is_a?(ActiveFacts::Metamodel::JoinRole)
+            @player_by_join_role[ref]
+          else
+            @player_by_role_ref[ref] or ref.join_role && @player_by_join_role[ref.join_role]
+          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}'"
+          return existing_player
         else
-          @player_by_role_ref[ref] or
-            ref.join_role && @player_by_join_role[ref.join_role] or
-            @players.push(p = Player.new(ref.role.concept)) && p
+          debug :player, "Adding new player for #{ref.role.object_type.name} #{ref.respond_to?(:role_sequence) && ref.role_sequence.all_reading.size > 0 ? ' in reading' : ''}in '#{ref.role.fact_type.default_reading}'"
+          p = Player.new(ref.role.object_type)
+          @players.push(p)
+          p
         end
       end
 
@@ -142,7 +153,7 @@ module ActiveFacts
         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.concept.name} may only have one join node per join, not #{jn1.concept.name} and #{jn.concept.name}"
+          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}"
         end
         player.join_nodes_by_join[jn.join] = jn
         @player_by_join_role[join_role] = player
@@ -155,7 +166,7 @@ module ActiveFacts
         if jr = role_ref.join_role
           add_join_role(player, jr)
         elsif !player.role_refs.include?(role_ref)
-          debug :subscript, "Adding reference to player #{player.object_id} for #{role_ref.role.concept.name} in #{role_ref.role_sequence.describe} with #{role_ref.role_sequence.all_reading.size} readings"
+          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)
           @player_by_role_ref[role_ref] = player
         end
@@ -182,11 +193,7 @@ module ActiveFacts
           elsif role_name = role_ref.role.role_name and role_name != ''
             role_name
           else
-            role_words = []
-            role_words << preferred_role_ref.leading_adjective if preferred_role_ref.leading_adjective != ""
-            role_words << preferred_role_ref.role.concept.name
-            role_words << preferred_role_ref.trailing_adjective if preferred_role_ref.trailing_adjective != ""
-            role_name = role_words.compact*"-"
+            role_name = preferred_role_ref.cql_name
             if p = player(preferred_role_ref) and p.subscript
               role_name += "(#{p.subscript})"
             end
@@ -211,10 +218,10 @@ module ActiveFacts
         # 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 existing_players.size > 1
-          raise "Can't join these roles to more than one existing player: #{existing_players.map{|p|p.concept.name}*', '}!"
+          raise "Can't join these roles to more than one existing player: #{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.concept != p.concept }
+        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
@@ -233,17 +240,17 @@ module ActiveFacts
         existing_players =
           role_refs.map{|rr| @player_by_role_ref[rr] || @player_by_join_role[rr.join_role] }.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.concept.name}*', '}!"
+          raise "Can't join these role_refs to more than one existing player: #{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.concept.name}.uniq*', '}" do
+        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.concept == rr.role.concept
+            unless p.object_type == rr.role.object_type
               # This happens in SubtypePI because uniqueness constraint is built without its implicit subtyping join.
               # For now, explode only if there's no common supertype:
-              if 0 == (p.concept.supertypes_transitive & rr.role.concept.supertypes_transitive).size
-                raise "REVISIT: Internal error, trying to add role of #{rr.role.concept.name} to player #{p.concept.name}"
+              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}"
               end
             end
             add_role_player(p, rr)
@@ -251,21 +258,44 @@ module ActiveFacts
         end
       end
 
-      def create_subscripts
+      # REVISIT: include_rolenames is a bit of a hack. Role names generally serve to disambiguate players,
+      # so subscripts wouldn't be needed, but where a constraint refers to a fact type which is defined with
+      # role names, those are considered. We should instead consider only the role names that are defined
+      # within the constraint, not in the underlying fact types. For now, this parameter is passed as true
+      # from all the object type verbalisations, and not from constraints.
+      def create_subscripts(matching = :normal)
         # Create subscripts, where necessary
         @players.each { |p| p.subscript = nil } # Wipe subscripts
         @players.
-          map{|p| [p, p.concept] }.
-          each do |player, concept|
+          map{|p| [p, p.object_type] }.
+          each do |player, object_type|
             next if player.subscript  # Done previously
-            dups = @players.select{|p| p.concept == concept && p.role_adjuncts == player.role_adjuncts }
+            dups = @players.select do |p|
+              p.object_type == object_type &&
+                p.role_adjuncts(matching) == player.role_adjuncts(matching)
+              end
             if dups.size == 1
-              debug :subscript, "No subscript needed for #{concept.name}"
+              debug :subscript, "No subscript needed for #{object_type.name}"
               next
             end
-            debug :subscript, "Applying subscripts to #{dups.size} occurrences of #{concept.name}" do
-              dups.each_with_index do |player, index|
-                player.subscript = index+1
+            debug :subscript, "Applying subscripts to #{dups.size} occurrences of #{object_type.name}" do
+              s = 0
+              dups.
+                sort_by{|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
+                }.
+                each do |player|
+                jrname = player.join_roles.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 }
+               else
+                  player.subscript = s+1
+                  s += 1
+                end
               end
             end
           end
@@ -276,7 +306,7 @@ module ActiveFacts
       # and also define adjectives by using the hyphenated form (on at least the first occurrence).
       def expand_reading(reading, frequency_constraints = [], define_role_names = nil, value_constraints = [], &subscript_block)
         reading.expand(frequency_constraints, define_role_names, value_constraints) do |role_ref|
-          (!(role_ref.role.role_name and define_role_names) and p = player(role_ref) and p.subscript) ? "(#{p.subscript})" : ""
+          (!(role_ref.role.role_name and define_role_names != nil) and p = player(role_ref) and p.subscript) ? "(#{p.subscript})" : ""
         end
       end
 
@@ -284,8 +314,8 @@ module ActiveFacts
       # 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
         role_refs = roles.is_a?(Array) ? roles : roles.all_role_ref.to_a
-        role_refs_by_concept = role_refs.inject({}) { |h, r| (h[r.role.concept] ||= []) << r; h }
-        role_refs_by_concept.values.each { |rrs|  role_refs_have_same_player(rrs) }
+        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) }
       end
 
       # These roles are the players in an implicit counterpart join in a Presence Constraint.
@@ -293,9 +323,11 @@ module ActiveFacts
       # Fix the CQL compiler to create proper joins for these presence constraints instead.
       def roles_have_same_player roles
         role_refs = roles.map do |role|
-          pr = role.fact_type.preferred_reading
-          pr.role_sequence.all_role_ref.detect{|rr| rr.role == role}
-        end
+          role.fact_type.all_reading.map{|reading|
+            reading.role_sequence.all_role_ref.detect{|rr| rr.role == role}
+          } +
+          role.all_role_ref.select{|rr| rr.role_sequence.all_reading.size == 0 }
+        end.flatten.uniq
         role_refs_have_same_player(role_refs)
       end
 
@@ -316,10 +348,10 @@ module ActiveFacts
           prrs = fact_type.preferred_reading.role_sequence.all_role_ref
           residual_roles = fact_type.all_role.select{|r| !@role_refs.detect{|rr| rr.role == r} }
           residual_roles.each do |role|
-            debug :subscript, "Adding residual role for #{role.concept.name} (in #{fact_type.default_reading}) not covered in role sequence"
+            debug :subscript, "Adding residual role for #{role.object_type.name} (in #{fact_type.default_reading}) not covered in role sequence"
             preferred_role_ref = prrs.detect{|rr| rr.role == role}
             if p = @player_by_role_ref[preferred_role_ref] and !p.role_refs.include?(preferred_role_ref)
-              raise "Adding DUPLICATE residual role for #{role.concept.name}"
+              raise "Adding DUPLICATE residual role for #{role.object_type.name}"
             end
             role_refs_have_same_player([prrs.detect{|rr| rr.role == role}])
           end
@@ -340,13 +372,13 @@ module ActiveFacts
 =begin
           # For each fact type traversed, register a player for each role *not* linked to this join
           # REVISIT: Using the preferred_reading role_ref is wrong here; the same preferred_reading might occur twice,
-          # so the respective concept will need more than one Player and will be subscripted to keep them from being joined.
+          # 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
 
           join_steps.map do |js|
             if js.fact_type.is_a?(ActiveFacts::Metamodel::ImplicitFactType)
-              js.fact_type.role.fact_type
+              js.fact_type.implying_role.fact_type
             else
               js.fact_type
             end
@@ -358,10 +390,10 @@ module ActiveFacts
               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.each do |r|
-                debug :subscript, "Adding residual role for #{r.concept.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 join"
                 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.concept.name} not covered in join"
+                  raise "Adding DUPLICATE residual role for #{r.object_type.name} not covered in join"
                 end
                 role_refs_have_same_player([preferred_role_ref])
               end
@@ -388,7 +420,7 @@ module ActiveFacts
           # Choose a reading that start with the (first) role which caused us to emit this fact type:
           reading = fact_type.reading_preferably_starting_with_role(role_by_fact_type[fact_type])
           if join_over and      # Find a reading preferably starting with the joined_over role:
-            joined_role = fact_type.all_role.select{|r| join_over.subtypes_transitive.include?(r.concept)}[0]
+            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:
@@ -399,13 +431,11 @@ module ActiveFacts
           reading.role_sequence.all_role_ref.each do |rr|
             next unless player = @player_by_role_ref[rr]
             next unless subscript = player.subscript
-            debug :subscript, "Need to apply subscript #{subscript} to #{rr.role.concept.name}"
+            debug :subscript, "Need to apply subscript #{subscript} to #{rr.role.object_type.name}"
           end
           player_by_role = {}
           @player_by_role_ref.keys.each{|rr| player_by_role[rr.role] = @player_by_role_ref[rr] if rr.role.fact_type == fact_type }
-          #role_refs = @player_by_role_ref.keys.select{|rr| rr.role.fact_type == fact_type}
           expand_reading_text(nil, reading.text, reading.role_sequence, player_by_role)
-          #reading.expand(name_substitutions)
         end
         joiner ? readings*joiner : readings
       end
@@ -421,37 +451,29 @@ module ActiveFacts
           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?)
+            # 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]
 
-=begin
-            rr = role_refs.detect{|rr| rr.role == role_ref.role} || role_ref
-
-            player = @player_by_role_ref[rr] and subscript = player.subscript
-            if !subscript and
-              pp = @players.select{|p|p.concept == rr.role.concept} and
-              pp.detect{|p|p.subscript}
-              # raise "Internal error: Subscripted players (of the same concept #{pp[0].concept.name}) when this player isn't subscripted"
-            end
-=end
-
-            subscripted_player(role_ref, player && player.subscript) +
-              objectification_verbalisation(role_ref.role.concept)
+            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) +
+              objectification_verbalisation(role_ref.role.object_type)
           end
         end
       end
 
-      def subscripted_player role_ref, subscript = nil
-        if subscript
-          debug :subscript, "Need to apply subscript #{subscript} to #{role_ref.role.concept.name}"
-        end
-        concept = role_ref.role.concept
-        [
-          role_ref.leading_adjective,
-          concept.name,
-          role_ref.trailing_adjective
-        ].compact*' ' +
+      def subscripted_player role_ref, subscript = nil, join_role_name = 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 ||
+          [
+            role_ref.leading_adjective,
+            object_type.name,
+            role_ref.trailing_adjective
+          ].compact*' '
+        ) +
           (subscript ? "(#{subscript})" : '')
       end
 
@@ -515,9 +537,9 @@ module ActiveFacts
           debug :join, "Chose new random step from #{join_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.role.fact_type
-            jn = [next_step.input_join_role.join_node, next_step.output_join_role.join_node].detect{|jn| jn.concept == fact_type.entity_type}
-            sr = @join_steps_by_join_node[jn].reject{|t| t.fact_type.role and t.fact_type.role.fact_type == fact_type}
+            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}
             next_step = sr[0] if sr.size > 0 
           end
           return next_step
@@ -534,13 +556,13 @@ module ActiveFacts
           # 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.concept == next_node.concept
+        role_ref.role.object_type == next_node.object_type
       end
 
       def reading_starts_with_node(reading, next_node)
         reading.text =~ /^\{([0-9])\}/ and
           role_ref = reading.role_sequence.all_role_ref.detect{|rr| rr.ordinal == $1.to_i} and
-          role_ref.role.concept == next_node.concept
+          role_ref.role.object_type == next_node.object_type
       end
 
       # The last reading we emitted ended with the object type name for next_node.
@@ -558,21 +580,21 @@ module ActiveFacts
               end
             next_reading
           end
-        debug :join, "#{next_reading ? "'"+next_reading.expand+"'" : "No reading"} contracts against last node '#{next_node.concept.name}'"
+        debug :join, "#{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 concept. Need to get the Join Node here and emit an objectification step involving that node.
-      def objectification_verbalisation(concept)
+      # 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.
+      def objectification_verbalisation(object_type)
         objectified_node = nil
-        unless concept.is_a?(Metamodel::EntityType) and
-          concept.fact_type and            # Not objectified
+        unless object_type.is_a?(Metamodel::EntityType) and
+          object_type.fact_type and            # Not objectified
           objectification_step = @join_steps.
             detect do |js|
               # The objectifying entity type should always be the input_join_node here, but be safe:
               js.is_objectification_step and
-                (objectified_node = js.input_join_role.join_node).concept == concept ||
-                (objectified_node = js.output_join_role.join_node).concept == concept
+                (objectified_node = js.input_join_role.join_node).object_type == object_type ||
+                (objectified_node = js.output_join_role.join_node).object_type == object_type
             end
           return ''
         end
@@ -586,7 +608,7 @@ module ActiveFacts
           @join_steps.
             detect{|js|
               js.is_objectification_step and
-                js.input_join_role.join_node.concept == concept || js.output_join_role.join_node.concept == concept
+                js.input_join_role.join_node.object_type == object_type || js.output_join_role.join_node.object_type == object_type
             }
           steps << other_step
           debug :join, "Emitting objectification step allows deleting #{other_step.describe}"
@@ -601,9 +623,9 @@ module ActiveFacts
           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 == concept.fact_type}}}.flatten.compact.uniq
+        # 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
 
-        reading = concept.fact_type.preferred_reading
+        reading = object_type.fact_type.preferred_reading
         " (where #{expand_reading_text(objectification_step, reading.text, reading.role_sequence, player_by_role)})" 
       end
 
@@ -624,16 +646,19 @@ module ActiveFacts
         exit_node = @join_nodes.detect{|jn| jn.all_join_role.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
-              next unless js.input_join_role.join_node.concept == fact_type.entity_type || js.output_join_role.join_node.concept == fact_type.entity_type
+              # 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]
       end
@@ -657,7 +682,7 @@ module ActiveFacts
                 end
 
             if next_step
-              debug :join, "Chose #{next_step.describe} because it's contractable against last node #{next_node.concept.name} using #{next_reading.expand}"
+              debug :join, "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 }
@@ -671,26 +696,26 @@ module ActiveFacts
 
               if next_step.is_unary_step
                 # Objectified unaries get emitted as unaries, not as objectifications:
-                # REVISIT: There must be a simpler way of finding the preferred reading here:
-                rr = next_step.input_join_node.all_role_ref.detect{|rr| rr.role.fact_type.is_a?(ImplicitFactType) }
-                next_reading = rr.role.fact_type.role.fact_type.preferred_reading
+                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
                 readings += " and " unless readings.empty?
                 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
-                fact_type = next_step.fact_type.role.fact_type
+                fact_type = next_step.fact_type.implying_role.fact_type
 
                 # 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.concept.fact_type
+                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]
                   end
                 end
 
-                if last_is_contractable and next_node.concept.is_a?(EntityType) and next_node.concept.fact_type == fact_type
+                if last_is_contractable and next_node.object_type.is_a?(EntityType) and next_node.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)