activefacts 0.8.16 → 0.8.18

data/lib/activefacts/generate/version.rb

@@ -23,3 +23,4 @@ module ActiveFacts
   end
 end
 
+ActiveFacts::Registry.generator('version', ActiveFacts::Generate::VERSION)

data/lib/activefacts/input/orm.rb

@@ -144,28 +144,35 @@ module ActiveFacts
         read_diagrams if @options.include?("diagrams")
       end
 
+      def id_of(x)
+	x['id'][1..-1]
+      end
+
       def read_entity_types
         # get and process all the entity types:
         entity_types = []
         x_entity_types = @x_model.xpath("orm:Objects/orm:EntityType")
-        x_entity_types.each{|x|
+        x_entity_types.each do |x|
           id = x['id']
           name = (x['Name'] || "").gsub(/\s+/,' ').gsub(/-/,'_').strip
           name = nil if name.size == 0
-          entity_types <<
-            @by_id[id] =
-              entity_type =
-              @constellation.EntityType(@vocabulary, name, :guid => :new)
-            independent = x['IsIndependent']
-            entity_type.is_independent = true if independent && independent == 'true'
-            personal = x['IsPersonal']
-            entity_type.pronoun = 'personal' if personal && personal == 'true'
+	  entity_type =
+	    @by_id[id] =
+	      debug :orm, "Asserting new EntityType #{name.inspect}" do
+		@vocabulary.valid_entity_type_name(name) ||
+		@constellation.EntityType(@vocabulary, name, :guid => id_of(x))
+	      end
+	  entity_types << entity_type
+	  independent = x['IsIndependent']
+	  entity_type.is_independent = true if independent && independent == 'true'
+	  personal = x['IsPersonal']
+	  entity_type.pronoun = 'personal' if personal && personal == 'true'
   #       x_pref = x.xpath("orm:PreferredIdentifier")[0]
   #       if x_pref
   #         pi_id = x_pref['ref']
   #         @pref_id_for[pi_id] = x
   #       end
-        }
+        end
       end
 
       def read_value_types
@@ -198,7 +205,14 @@ module ActiveFacts
         type_name.sub!(/^orm:/,'')
 
         type_name.sub!(/DataType\Z/,'')
-        type_name = DataTypeMapping[type_name] || type_name
+	if t = DataTypeMapping[type_name]
+	  existing = @constellation.ObjectType[[@vocabulary.identifying_role_values, t]]
+	  if !existing || existing.is_a?(ActiveFacts::Metamodel::ValueType)
+	    # There's no type conflict, so use the mapped name.
+	    type_name = t
+	  end
+	end
+	debug :orm, "Using #{type_name.inspect} as supertype for new #{name}"
         if !length and type_name =~ /\(([0-9]+)\)/
           length = $1.to_i
         end
@@ -216,14 +230,30 @@ module ActiveFacts
           supertype_name = x_supertype['Name']
           raise "Supertype of #{name} is post-defined but recursiving processing failed" unless supertype
           raise "Supertype #{supertype_name} of #{name} is not a value type" unless supertype.kind_of? ActiveFacts::Metamodel::ValueType
-          value_super_type = @constellation.ValueType(@vocabulary, supertype_name, :guid => :new)
+	  debug :orm, "Asserting new ValueType #{supertype_name.inspect} for supertype" do
+	    value_super_type =
+	      @vocabulary.valid_value_type_name(supertype_name) ||
+	      @constellation.ValueType(@vocabulary, supertype_name, :guid => id_of(x_supertype))
+	  end
         else
           # REVISIT: Need to handle standard types better here:
-          value_super_type = type_name != name ? @constellation.ValueType(@vocabulary, type_name, :guid => :new) : nil
+          value_super_type =
+	    if type_name != name
+	      debug :orm, "Asserting new ValueType #{type_name.inspect} for supertype" do
+		@vocabulary.valid_value_type_name(type_name) ||
+		  @constellation.ValueType(@vocabulary.identifying_role_values, type_name, :guid => :new)
+	      end
+	    else
+	      nil
+	    end
         end
 
-        @by_id[id] =
-          vt = @constellation.ValueType(@vocabulary, name, :guid => :new)
+	vt =
+	  debug :orm, "Asserting new ValueType #{name.inspect}" do
+	    @by_id[id] =
+	      @vocabulary.valid_value_type_name(name) ||
+	      @constellation.ValueType(@vocabulary.identifying_role_values, name, :guid => id_of(x))
+	  end
         vt.supertype = value_super_type
         vt.length = length if length
         vt.scale = scale if scale && scale != 0
@@ -236,7 +266,7 @@ module ActiveFacts
         x_vr.each{|vr|
           x_ranges = vr.xpath("orm:ValueRanges/orm:ValueRange")
           next if x_ranges.size == 0
-          vt.value_constraint = @by_id[vr['id']] = @constellation.ValueConstraint(:new)
+          vt.value_constraint = @by_id[vr['id']] = @constellation.ValueConstraint(id_of(vr))
           x_ranges.each{|x_range|
             v_range = value_range(x_range)
             ar = @constellation.AllowedRange(vt.value_constraint, v_range)
@@ -245,16 +275,23 @@ module ActiveFacts
         vt
       end
 
+      def assert_value(val, string)
+	if val
+	  @constellation.Value(val.to_s, string, nil)
+	else
+	  nil
+	end
+      end
+
       def value_range(x_range)
         min = x_range['MinValue']
         max = x_range['MaxValue']
 
-        strings = is_a_string(min) || is_a_string(max)
+        strings = is_literal_string(min) || is_literal_string(max)
         # ValueRange takes a minimum and/or a maximum Bound, each takes value and whether inclusive
-        @constellation.ValueRange(
-            min && min != '' ? [[min, strings, nil], true] : nil,
-            max && max != '' ? [[max, strings, nil], true] : nil
-          )
+	@constellation.ValueRange(
+	  min.length > 0 ? @constellation.Bound(assert_value(min, strings), true) : nil,
+	  max.length > 0 ? @constellation.Bound(assert_value(max, strings), true) : nil)
       end
 
       def read_fact_types
@@ -271,7 +308,7 @@ module ActiveFacts
             next if x.xpath("orm:DerivationRule").size > 0
 
             debug :orm, "FactType #{name || id}"
-            facts << @by_id[id] = fact_type = @constellation.FactType(:new)
+            facts << @by_id[id] = fact_type = @constellation.FactType(id_of(x))
           }
         end
       end
@@ -316,7 +353,7 @@ module ActiveFacts
             next if subtype.kind_of? ActiveFacts::Metamodel::ValueType or
                         supertype.kind_of? ActiveFacts::Metamodel::ValueType
 
-            inheritance_fact = @constellation.TypeInheritance(subtype, supertype, :guid => :new)
+            inheritance_fact = @constellation.TypeInheritance(subtype, supertype, :guid => id_of(x))
             if x["IsPrimary"] == "true" or           # Old way
               x["PreferredIdentificationPath"] == "true"   # Newer
               debug :orm, "#{supertype.name} is primary supertype of #{subtype.name}"
@@ -328,22 +365,22 @@ module ActiveFacts
             facts << @by_id[id] = inheritance_fact
 
             # Create the new Roles so we can find constraints on them:
-            subtype_role = @by_id[subtype_role_id] = @constellation.Role(inheritance_fact, 0, :object_type => subtype, :guid => :new)
-            supertype_role = @by_id[supertype_role_id] = @constellation.Role(inheritance_fact, 1, :object_type => supertype, :guid => :new)
+            subtype_role = @by_id[subtype_role_id] = @constellation.Role(inheritance_fact, 0, :object_type => subtype, :guid => id_of(x_subtype_role))
+            supertype_role = @by_id[supertype_role_id] = @constellation.Role(inheritance_fact, 1, :object_type => supertype, :guid => id_of(x_supertype_role))
 
             # Create readings, so constraints can be verbalised for example:
             rs = @constellation.RoleSequence(:new)
             @constellation.RoleRef(rs, 0, :role => subtype_role)
             @constellation.RoleRef(rs, 1, :role => supertype_role)
-            @constellation.Reading(inheritance_fact, 0, :role_sequence => rs, :text => "{0} is a kind of {1}")
-            @constellation.Reading(inheritance_fact, 1, :role_sequence => rs, :text => "{0} is a subtype of {1}")
+            @constellation.Reading(inheritance_fact, 0, :role_sequence => rs, :text => "{0} is a kind of {1}", :is_negative => false)
+            @constellation.Reading(inheritance_fact, 1, :role_sequence => rs, :text => "{0} is a subtype of {1}", :is_negative => false)
 
             rs2 = @constellation.RoleSequence(:new)
             @constellation.RoleRef(rs2, 0, :role => supertype_role)
             @constellation.RoleRef(rs2, 1, :role => subtype_role)
             n = 'aeiouh'.include?(subtype_role.object_type.name.downcase[0]) ? 1 : 0
-            @constellation.Reading(inheritance_fact, 2+n, :role_sequence => rs2, :text => "{0} is a {1}")
-            @constellation.Reading(inheritance_fact, 3-n, :role_sequence => rs2, :text => "{0} is an {1}")
+            @constellation.Reading(inheritance_fact, 2+n, :role_sequence => rs2, :text => "{0} is a {1}", :is_negative => false)
+            @constellation.Reading(inheritance_fact, 3-n, :role_sequence => rs2, :text => "{0} is an {1}", :is_negative => false)
           }
         end
       end
@@ -366,12 +403,13 @@ module ActiveFacts
             fact_id = x_fact_type['ref']
             fact_type = @by_id[fact_id]
             next if x.xpath("orm:DerivationRule").size > 0
-            throw "Nested fact #{fact_id} not found" if !fact_type
+            next unless fact_type # "Nested fact #{fact_id} not found; objectification of a derived fact type?"
 
             debug :orm, "NestedType #{name} is #{id}, nests #{fact_type.guid}"
             @nested_types <<
               @by_id[id] =
-              nested_type = @constellation.EntityType(@vocabulary, name, :guid => :new)
+		nested_type = @vocabulary.valid_entity_type_name(name) ||
+		  @constellation.EntityType(@vocabulary, name, :guid => id_of(x))
             independent = x['IsIndependent']
             nested_type.is_independent = true if independent && independent == 'true' && !is_implied
             nested_type.is_implied_by_objectification = is_implied
@@ -382,8 +420,8 @@ module ActiveFacts
 
       def complete_nested_types
         @nested_types.each do |nested_type|
-          # Create the phantom roles here. These will be used later when we create objectification joins,
-          # but for now there's nothing we import from NORMA which requires objectification joins.
+          # Create the phantom roles here. These will be used later when we create objectification steps,
+          # but for now there's nothing we import from NORMA which requires objectification steps.
           # Consequently there's no need to index them against NORMA's phantom roles.
           nested_type.create_implicit_fact_types
         end
@@ -400,7 +438,6 @@ module ActiveFacts
             fact_name = nil if fact_name == ''
 
             x_fact_roles = x.xpath('orm:FactRoles/*')
-            x_reading_orders = x.xpath('orm:ReadingOrders/*')
 
             # Deal with FactRoles (Roles):
             debug :orm, "Reading fact roles" do
@@ -438,14 +475,14 @@ module ActiveFacts
                   @by_id.delete(ref)    # and de-index it from our list
                   next
                 end
-                throw "RolePlayer for '#{name}' #{ref} was not found" if !object_type
+                throw "RolePlayer for '#{name}' #{ref} in fact type #{x.parent.parent['_Name']} was not found" if !object_type
 
                 debug :orm, "#{@vocabulary.name}, RoleName=#{x['Name'].inspect} played by object_type=#{object_type.name}"
                 throw "Role is played by #{object_type.class} not ObjectType" if !(@constellation.vocabulary.object_type(:ObjectType) === object_type)
 
                 debug :orm, "Creating role #{name} nr#{fact_type.all_role.size} of #{fact_type.guid} played by #{object_type.name}"
 
-                role = @by_id[id] = @constellation.Role(fact_type, fact_type.all_role.size, :object_type => object_type, :guid => :new)
+                role = @by_id[id] = @constellation.Role(fact_type, fact_type.all_role.size, :object_type => object_type, :guid => id_of(x))
                 role.role_name = name if name && name != object_type.name
                 debug :orm, "Fact #{fact_name} (id #{fact_type.guid.object_id}) role #{x['Name']} is played by #{object_type.name}, role is #{role.object_id}"
 
@@ -453,7 +490,7 @@ module ActiveFacts
                 x_vr.each{|vr|
                   x_ranges = vr.xpath("orm:ValueRanges/orm:ValueRange")
                   next if x_ranges.size == 0
-                  role.role_value_constraint = @by_id[vr['id']] = @constellation.ValueConstraint(:new)
+                  role.role_value_constraint = @by_id[vr['id']] = @constellation.ValueConstraint(id_of(vr))
                   x_ranges.each{|x_range|
                     v_range = value_range(x_range)
                     ar = @constellation.AllowedRange(role.role_value_constraint, v_range)
@@ -468,6 +505,7 @@ module ActiveFacts
 
             # Deal with Readings:
             debug :orm, "Reading fact readings" do
+	      x_reading_orders = x.xpath('orm:ReadingOrders/*')
               x_reading_orders.each{|x|
                 x_role_sequence = x.xpath('orm:RoleSequence/*')
                 x_readings = x.xpath('orm:Readings/orm:Reading/orm:Data')
@@ -483,7 +521,7 @@ module ActiveFacts
                 #  }
 
                 x_readings.each_with_index{|x, i|
-                  reading = @constellation.Reading(fact_type, fact_type.all_reading.size)
+                  reading = @constellation.Reading(fact_type, fact_type.all_reading.size, :is_negative => false)
                   reading.role_sequence = role_sequence
                   # REVISIT: The downcase here only needs to be the initial letter of each word, but be safe:
                   reading.text = extract_adjectives(x.text, role_sequence)
@@ -672,18 +710,18 @@ module ActiveFacts
             #puts "Residual Mandatory #{name}: #{role_sequence.to_s}"
 
             if (players = role_sequence.all_role_ref.map{|rr| rr.role.object_type}).uniq.size > 1
-              join_over, = *ActiveFacts::Metamodel.join_roles_over(role_sequence.all_role_ref.map{|rr| rr.role}, :proximate)
+              join_over, = *ActiveFacts::Metamodel.plays_over(role_sequence.all_role_ref.map{|rr| rr.role}, :proximate)
               raise "Mandatory join constraint #{name} has incompatible players #{players.map{|o| o.name}.inspect}" unless join_over
               if players.detect{|p| p != join_over}
-                debug :join, "subtyping join simple mandatory constraint #{name} over #{join_over.name}"
+                debug :query, "subtyping step simple mandatory constraint #{name} over #{join_over.name}"
                 players.each_with_index do |player, i|
                   next if player != join_over
-                  # REVISIT: We don't need to make a subtyping join here (from join_over to player)
+                  # REVISIT: We don't need to make a subtyping step here (from join_over to player)
                 end
               end
             end
 
-            pc = @constellation.PresenceConstraint(:new)
+            pc = @constellation.PresenceConstraint(id_of(x))
             pc.vocabulary = @vocabulary
             pc.name = name
             pc.role_sequence = role_sequence
@@ -718,15 +756,21 @@ module ActiveFacts
             next if !role_sequence
             #puts "uc: #{role_sequence.all_role_ref.map{|rr|rr.role.fact_type.default_reading}*', '}"
 
-            # Check for a join
+            # Check for a query
             if (fact_types = role_sequence.all_role_ref.map{|rr| rr.role.fact_type}).uniq.size > 1
-              join_over, = *ActiveFacts::Metamodel.join_roles_over(role_sequence.all_role_ref.map{|rr| rr.role}, :counterpart)
+              join_over, = *ActiveFacts::Metamodel.plays_over(role_sequence.all_role_ref.map{|rr| rr.role}, :counterpart)
 
               players = role_sequence.all_role_ref.map{|rr| rr.role.object_type.name}.uniq
-              raise "Uniqueness join constraint #{name} has incompatible players #{players.inspect}" unless join_over
+	      unless join_over
+		if x.xpath("orm:RoleSequence/orm:JoinRule").size > 0
+		  $stderr.puts "Ignoring Join #{name} because its query is not understood"
+		  next
+		end
+		raise "Uniqueness join constraint #{name} has incompatible players #{players.inspect}"
+	      end
               subtyping = players.size > 1 ? 'subtyping ' : ''
-              # REVISIT: Create the Join, the JoinNode for join_over, and steps from each role_ref to join_over
-              debug :join, "#{subtyping}join uniqueness constraint over #{join_over.name} in #{fact_types.map(&:default_reading)*', '}"
+              # REVISIT: Create the Query, the Variable for join_over, and steps from each role_ref to join_over
+              debug :query, "#{subtyping}join uniqueness constraint over #{join_over.name} in #{fact_types.map(&:default_reading)*', '}"
             end
 
             # There is an implicit uniqueness constraint when any object plays a unary. Skip it.
@@ -769,7 +813,7 @@ module ActiveFacts
               role.object_type == fact_type.supertype &&
               fact_type.provides_identification
 
-            pc = @constellation.PresenceConstraint(:new)
+            pc = @constellation.PresenceConstraint(id_of(x))
             pc.vocabulary = @vocabulary
             pc.name = name
             pc.role_sequence = role_sequence
@@ -788,23 +832,23 @@ module ActiveFacts
         end
       end
 
-      def subtype_join_step(join, ti)
-        subtype_node = join.all_join_node.detect{|jn| jn.object_type == ti.subtype } ||
-          @constellation.JoinNode(join, join.all_join_node.size, :object_type => ti.subtype)
-        supertype_node = join.all_join_node.detect{|jn| jn.object_type == ti.supertype } ||
-          @constellation.JoinNode(join, join.all_join_node.size, :object_type => ti.supertype)
+      def subtype_step(query, ti)
+        subtype_node = query.all_variable.detect{|jn| jn.object_type == ti.subtype } ||
+          @constellation.Variable(query, query.all_variable.size, :object_type => ti.subtype)
+        supertype_node = query.all_variable.detect{|jn| jn.object_type == ti.supertype } ||
+          @constellation.Variable(query, query.all_variable.size, :object_type => ti.supertype)
         rs = @constellation.RoleSequence(:new)
         @constellation.RoleRef(rs, 0, :role => ti.subtype_role)
-        sub_jr = @constellation.JoinRole(subtype_node, ti.subtype_role)
+        sub_play = @constellation.Play(subtype_node, ti.subtype_role)
         @constellation.RoleRef(rs, 1, :role => ti.supertype_role)
-        sup_jr = @constellation.JoinRole(supertype_node, ti.supertype_role)
-        js = @constellation.JoinStep(sub_jr, sup_jr, :fact_type => ti)
-        debug :join, "New subtyping join step #{js.describe}"
-        js
+        sup_play = @constellation.Play(supertype_node, ti.supertype_role)
+        step = @constellation.Step(sub_play, sup_play, :fact_type => ti)
+        debug :query, "New subtyping step #{step.describe}"
+        step
       end
 
-      # Make as many join steps as it takes to get from subtype to supertype
-      def subtype_join_steps(join, subtype, supertype)
+      # Make as many steps as it takes to get from subtype to supertype
+      def subtype_steps(query, subtype, supertype)
         primary_ti = nil
         other_ti = nil
         subtype.all_type_inheritance_as_subtype.each do |ti|
@@ -816,24 +860,24 @@ module ActiveFacts
           end
         end
         ti = primary_ti || other_ti
-        # Make supertype join steps first:
-        (ti.supertype == supertype ? [] : subtype_join_steps(join, ti.supertype, supertype)) +
-          [subtype_join_step(join, ti)]
+        # Make supertype steps first:
+        (ti.supertype == supertype ? [] : subtype_steps(query, ti.supertype, supertype)) +
+          [subtype_step(query, ti)]
       end
 
-      # Equality and subset joins involve two or more role sequences,
+      # Equality and subset join constraints involve two or more role sequences,
       # and the respective roles from each sequence must be compatible,
-      # Compatibility might involve subtyping joins but not objectification joins
+      # Compatibility might involve subtyping steps but not objectification steps
       # to the respective end-point (constrained object type).
       # Also, all roles in each sequence constitute a join over a single
-      # object type, which might involve subtyping or objectification joins.
+      # object type, which might involve subtyping or objectification steps.
       #
-      def make_joins(constraint_type, name, role_sequences)
+      def make_queries(constraint_type, name, role_sequences)
         begin
           # Get the object types constrained for each position in the role sequences.
-          # Supertyping joins may be needed to reach them.
+          # Supertyping steps may be needed to reach them.
           end_points = []   # An array of the common supertype for matching role_refs across the sequences
-          end_joins = []    # An array of booleans indicating whether any role_sequence requires a subtyping join
+          end_steps = []    # An array of booleans indicating whether any role_sequence requires subtyping steps
           role_sequences[0].all_role_ref.size.times do |i|
             role_refs = role_sequences.map{|rs| rs.all_role_ref.detect{|rr| rr.ordinal == i}}
             if (fact_types = role_refs.map{|rr| rr.role.fact_type}).uniq.size == 1
@@ -842,9 +886,9 @@ module ActiveFacts
             end
             if (players = role_refs.map{|rr| rr.role.object_type}).uniq.size == 1
               end_point = players[0]
-              end_joins[i] = false
+              end_steps[i] = false
             else
-              # Can the players be joined using a subtyping join?
+              # Can the players be joined using subtyping steps?
               common_supertypes = players[1..-1].
                 inject(players[0].supertypes_transitive) do |remaining, player|
                   remaining & player.supertypes_transitive
@@ -852,33 +896,33 @@ module ActiveFacts
               end_point = common_supertypes[0]
 
               raise "constrained roles of #{constraint_type} #{name} are incompatible (#{players.map(&:name)*', '})" if common_supertypes.size == 0
-              end_joins[i] = true
+              end_steps[i] = true
             end
             end_points[i] = end_point
           end
 
           # For each role_sequence, find the object type over which the join is implied (nil if no join)
           sequence_join_over = []
-          if role_sequences[0].all_role_ref.size > 1    # There are joins within each sequence.
+          if role_sequences[0].all_role_ref.size > 1    # There are queries within each sequence.
             sequence_join_over = []
             sequence_joined_roles = []
             role_sequences.map do |rs|
-              join_over, joined_roles = *ActiveFacts::Metamodel.join_roles_over(rs.all_role_ref.map{|rr| rr.role})
+              join_over, joined_roles = *ActiveFacts::Metamodel.plays_over(rs.all_role_ref.map{|rr| rr.role})
               sequence_join_over << join_over
               sequence_joined_roles << joined_roles
             end
           end
 
-          # If there are no joins, we can drop out here.
-          if sequence_join_over.compact.empty? && !end_joins.detect{|e| true}
+          # If there are no queries, we can drop out here.
+          if sequence_join_over.compact.empty? && !end_steps.detect{|e| true}
             return true
           end
 
-          debug :join, "#{constraint_type} join constraint #{name} over #{role_sequences.map{|rs|rs.describe}*', '}"
+          debug :query, "#{constraint_type} join constraint #{name} over #{role_sequences.map{|rs|rs.describe}*', '}"
 
-          join = nil
-          debug :join, "#{constraint_type} join constraint #{name} constrains #{
-              end_points.zip(end_joins).map{|(p,j)| (p ? p.name : 'NULL')+(j ? ' & subtypes':'')}*', '
+          query = nil
+          debug :query, "#{constraint_type} join constraint #{name} constrains #{
+              end_points.zip(end_steps).map{|(p,j)| (p ? p.name : 'NULL')+(j ? ' & subtypes':'')}*', '
             }#{
             if role_sequences[0].all_role_ref.size > 1
               ", joined over #{
@@ -891,134 +935,136 @@ module ActiveFacts
             end
           }" do
 
-            # There may be one join per role sequence:
+            # There may be one query per role sequence:
             role_sequences.zip(sequence_join_over||[], sequence_joined_roles||[]).map do |role_sequence, join_over, joined_roles|
-              # Skip if there's no join here (sequence join nor end-point subset join)
+              # Skip if there's no query here (sequence join nor end-point subset join)
               role_refs = role_sequence.all_role_ref_in_order
               if !join_over and !role_refs.detect{|rr| rr.role.object_type != end_points[rr.ordinal]}
                 # No sequence join nor end_point join here
                 next
               end
 
-              # A RoleSequence for the actual join end-points
+              # A RoleSequence for the actual query end-points
               replacement_rs = @constellation.RoleSequence(:new)
 
-              join = @constellation.Join(:new)
-              join_node = nil
-              join_role = nil
+              query = @constellation.Query(:new)
+              variable = nil
+              query_role = nil
               role_refs.zip(joined_roles||[]).each_with_index do |(role_ref, joined_role), i|
 
-                # Each role_ref is to an object joined via joined_role to join_node (or which will be the join_node)
+                # Each role_ref is to an object joined via joined_role to variable (or which will be the variable)
 
-                # Create a join node for the actual end-point (supertype of the constrained roles)
+                # Create a variable for the actual end-point (supertype of the constrained roles)
                 end_point = end_points[i]
                 unless end_point
-                  raise "In #{constraint_type} #{name}, there is a faulty or non-translated join"
+                  raise "In #{constraint_type} #{name}, there is a faulty or non-translated query"
                 end
-                debug :join, "Join Node #{join.all_join_node.size} is for #{end_point.name}"
-                end_node = @constellation.JoinNode(join, join.all_join_node.size, :object_type => end_point)
+                debug :query, "Variable #{query.all_variable.size} is for #{end_point.name}"
+                end_node = @constellation.Variable(query, query.all_variable.size, :object_type => end_point)
 
                 # We're going to rewrite the constraint to constrain the supertype roles, but assume they're the same:
                 role_node = end_node
                 end_role = role_ref.role
 
-                # Create subtyping join steps at the end-point, if needed:
-                projecting_jr = nil
-                constrained_join_role = nil
+                # Create subtyping steps at the end-point, if needed:
+                projecting_play = nil
+                constrained_play = nil
                 if (subtype = role_ref.role.object_type) != end_point
-                  debug :join, "Making subtyping join steps from #{subtype.name} to #{end_point.name}" do
+                  debug :query, "Making subtyping steps from #{subtype.name} to #{end_point.name}" do
                     # There may be more than one supertyping level. Make the steps:
-                    subtyping_steps = subtype_join_steps(join, subtype, end_point)
-                    js = subtyping_steps[0]
-                    constrained_join_role = subtyping_steps[-1].input_join_role
+                    subtyping_steps = subtype_steps(query, subtype, end_point)
+                    step = subtyping_steps[0]
+                    constrained_play = subtyping_steps[-1].input_play
 
                     # Replace the constrained role and node with the supertype ones:
-                    end_node = join.all_join_node.detect{|jn| jn.object_type == end_point }
-                    projecting_jr = js.output_join_role
-                    end_role = js.fact_type.all_role.detect{|r| r.object_type == end_point }
-                    role_node = join.all_join_node.detect{|jn| jn.object_type == role_ref.role.object_type }
+                    end_node = query.all_variable.detect{|jn| jn.object_type == end_point }
+                    projecting_play = step.output_play
+                    end_role = step.fact_type.all_role.detect{|r| r.object_type == end_point }
+                    role_node = query.all_variable.detect{|jn| jn.object_type == role_ref.role.object_type }
                   end
                 end
 
-                raise "Internal error in #{constraint_type} #{name}: making illegal reference to join node, end role mismatch" if end_role.object_type != end_node.object_type
+                raise "Internal error in #{constraint_type} #{name}: making illegal reference to variable, end role mismatch" if end_role.object_type != end_node.object_type
                 rr = @constellation.RoleRef(replacement_rs, replacement_rs.all_role_ref.size, :role => end_role)
-                projecting_jr ||= (constrained_join_role = @constellation.JoinRole(end_node, end_role))
-                projecting_jr.role_ref = rr   # Project this RoleRef
+                projecting_play ||= (constrained_play = @constellation.Play(end_node, end_role))
+                projecting_play.role_ref = rr   # Project this RoleRef
+                # projecting_play.variable.projection = rr.role   # REVISIT: The variable should project a role, not the Play a RoleRef
 
                 if join_over
-                  if !join_node     # Create the JoinNode when processing the first role
-                    debug :join, "Join Node #{join.all_join_node.size} is over #{join_over.name}"
-                    join_node = @constellation.JoinNode(join, join.all_join_node.size, :object_type => join_over)
+                  if !variable     # Create the Variable when processing the first role
+                    debug :query, "Variable #{query.all_variable.size} is over #{join_over.name}"
+                    variable = @constellation.Variable(query, query.all_variable.size, :object_type => join_over)
                   end
-                  debug :join, "Making join step from #{end_point.name} to #{join_over.name}" do
+                  debug :query, "Making step from #{end_point.name} to #{join_over.name}" do
                     rs = @constellation.RoleSequence(:new)
-                    # Detect the fact type over which we're joining (may involve objectification)
-                    raise "Internal error in #{constraint_type} #{name}: making illegal reference to join node, object type mismatch" if role_ref.role.object_type != role_node.object_type
+                    # Detect the fact type over which we're stepping (may involve objectification)
+                    raise "Internal error in #{constraint_type} #{name}: making illegal reference to variable, object type mismatch" if role_ref.role.object_type != role_node.object_type
                     @constellation.RoleRef(rs, 0, :role => role_ref.role)
-                    role_jr = @constellation.JoinRole(role_node, role_ref.role)
-                    raise "Internal error in #{constraint_type} #{name}: making illegal reference to join node, joined_role mismatch" if joined_role.object_type != join_node.object_type
+                    role_play = @constellation.Play(role_node, role_ref.role)
+                    raise "Internal error in #{constraint_type} #{name}: making illegal reference to variable, joined_role mismatch" if joined_role.object_type != variable.object_type
                     @constellation.RoleRef(rs, 1, :role => joined_role)
-                    join_jr = @constellation.JoinRole(join_node, joined_role)
+                    join_play = @constellation.Play(variable, joined_role)
 
-                    js = @constellation.JoinStep(role_jr, join_jr, :fact_type => joined_role.fact_type)
-                    debug :join, "New join step #{js.describe}"
+                    step = @constellation.Step(role_play, join_play, :fact_type => joined_role.fact_type)
+                    debug :query, "New step #{step.describe}"
                   end
                 else
-                  debug :join, "Need join step for non-join_over role #{end_point.name} #{role_ref.describe} in #{role_ref.role.fact_type.default_reading}"
+                  debug :query, "Need step for non-join_over role #{end_point.name} #{role_ref.describe} in #{role_ref.role.fact_type.default_reading}"
                   if (roles = role_ref.role.fact_type.all_role.to_a).size > 1
                     # Here we have an end join (step already created) but no sequence join
-                    if join_node
-                      raise "Internal error in #{constraint_type} #{name}: making illegal join step" if role_ref.role.object_type != role_node.object_type
-                      join_jr = @constellation.JoinRole(join_node, join_role)
-                      role_jr = @constellation.JoinRole(role_node, role_ref.role)
-                      js = @constellation.JoinStep(join_jr, role_jr, :fact_type => role_ref.role.fact_type)
-                      roles -= [join_role, role_ref.role]
+                    if variable
+                      raise "Internal error in #{constraint_type} #{name}: making illegal step" if role_ref.role.object_type != role_node.object_type
+                      join_play = @constellation.Play(variable, query_role)
+                      role_play = @constellation.Play(role_node, role_ref.role)
+                      step = @constellation.Step(join_play, role_play, :fact_type => role_ref.role.fact_type)
+                      roles -= [query_role, role_ref.role]
                       roles.each do |incidental_role|
-                        jn = @constellation.JoinNode(join, join.all_join_node.size, :object_type => incidental_role.object_type)
-                        jr = @constellation.JoinRole(jn, incidental_role, :join_step => js)
+                        jn = @constellation.Variable(query, query.all_variable.size, :object_type => incidental_role.object_type)
+                        play = @constellation.Play(jn, incidental_role, :step => step)
                       end
                     else
                       if role_sequence.all_role_ref.size > 1
-                        join_node = role_node
-                        join_role = role_ref.role
+                        variable = role_node
+                        query_role = role_ref.role
                       else
-                        # There's no join in this role sequence, so we'd drop of fthe bottom without doing the right things. Why?
+                        # There's no query in this role sequence, so we'd drop off the bottom without doing the right things. Why?
                         # Without this case, Supervision.orm omits "that runs Company" from the exclusion constraint, and I'm not sure why.
                         # I think the "then" code causes it to drop out the bottom without making the step (which is otherwise made in every case, see CompanyDirectorEmployee for example)
-                        role_jr = @constellation.JoinRole(role_node, role_ref.role)
-                        js = nil
+                        role_play = @constellation.Play(role_node, role_ref.role)
+                        step = nil
                         role_ref.role.fact_type.all_role.each do |role|
-                          next if role == role_jr.role
+                          next if role == role_play.role
                           next if role_sequence.all_role_ref.detect{|rr| rr.role == role}
-                          jn = @constellation.JoinNode(join, join.all_join_node.size, :object_type => role.object_type)
-                          jr = @constellation.JoinRole(jn, role)
-                          if js
-                            jr.join_step = js  # Incidental role
+                          jn = @constellation.Variable(query, query.all_variable.size, :object_type => role.object_type)
+                          play = @constellation.Play(jn, role)
+                          if step
+                            play.step = step  # Incidental role
                           else
-                            js = @constellation.JoinStep(role_jr, jr, :fact_type => role_ref.role.fact_type)
+                            step = @constellation.Step(role_play, play, :fact_type => role_ref.role.fact_type)
                           end
                         end
                       end
                     end
                   else
-                    # Unary fact type, make a Join Step from and to the constrained_join_role
-                    jr = @constellation.JoinRole(constrained_join_role.join_node, role_ref.role)
-                    js = @constellation.JoinStep(jr, jr, :fact_type => role_ref.role.fact_type)
+                    # Unary fact type, make a Step from and to the constrained_play
+                    play = @constellation.Play(constrained_play.variable, role_ref.role)
+                    step = @constellation.Step(play, play, :fact_type => role_ref.role.fact_type)
                   end
                 end
               end
 
-              # Thoroughly check that this is a valid join
-              join.validate
-              debug :join, "Join has projected nodes #{replacement_rs.describe}"
+              # Thoroughly check that this is a valid query
+              query.validate
+              debug :query, "Query has projected nodes #{replacement_rs.describe}"
 
-              # Constrain the replacement role sequence, which has the attached join:
+              # Constrain the replacement role sequence, which has the attached query:
               role_sequences[role_sequences.index(role_sequence)] = replacement_rs
             end
             return true
           end
         rescue => e
-          $stderr.puts '// '+e.to_s
+          debugger if debug :debug
+          $stderr.puts "// #{e.to_s}: #{e.backtrace[0]}"
           return false
         end
 
@@ -1050,9 +1096,9 @@ module ActiveFacts
 
             next if role_sequences.compact.size != role_sequences.size  # Role sequence missing; includes a derived fact type role
 
-            next unless make_joins('exclusion', name+(x_mandatory ? '/'+x_mandatory['Name'] : ''), role_sequences)
+            next unless make_queries('exclusion', name+(x_mandatory ? '/'+x_mandatory['Name'] : ''), role_sequences)
 
-            ec = @constellation.SetExclusionConstraint(:new)
+            ec = @constellation.SetExclusionConstraint(id_of(x))
             ec.vocabulary = @vocabulary
             ec.name = name
             # ec.enforcement = 
@@ -1085,9 +1131,9 @@ module ActiveFacts
             # Role sequence missing; includes a derived fact type role
             next if role_sequences.compact.size != role_sequences.size
 
-            next unless make_joins('equality', name, role_sequences)
+            next unless make_queries('equality', name, role_sequences)
 
-            ec = @constellation.SetEqualityConstraint(:new)
+            ec = @constellation.SetEqualityConstraint(id_of(x))
             ec.vocabulary = @vocabulary
             ec.name = name
             # ec.enforcement = 
@@ -1115,9 +1161,9 @@ module ActiveFacts
                   )
                 }
             next if role_sequences.compact.size != role_sequences.size  # Role sequence missing; includes a derived fact type role
-            next unless make_joins('subset', name, role_sequences)
+            next unless make_queries('subset', name, role_sequences)
 
-            ec = @constellation.SubsetConstraint(:new)
+            ec = @constellation.SubsetConstraint(id_of(x))
             ec.vocabulary = @vocabulary
             ec.name = name
             # ec.enforcement = 
@@ -1143,11 +1189,11 @@ module ActiveFacts
               end
             next unless from && to  # Roles missing; covers a derived fact type
             if from.object_type != to.object_type
-              join_over, = *ActiveFacts::Metamodel.join_roles_over([from, to], :counterpart)
+              join_over, = *ActiveFacts::Metamodel.plays_over([from, to], :counterpart)
               raise "Ring constraint has incompatible players #{from.object_type.name}, #{to.object_type.name}" if !join_over
-              debug :join, "join ring constraint over #{join_over.name}"
+              debug :query, "join ring constraint over #{join_over.name}"
             end
-            rc = @constellation.RingConstraint(:new)
+            rc = @constellation.RingConstraint(id_of(x))
             rc.vocabulary = @vocabulary
             rc.name = name
             # rc.enforcement = 
@@ -1175,7 +1221,7 @@ module ActiveFacts
             next unless role  # Role missing; belongs to a derived fact type
             debug :orm, "FrequencyConstraint(min #{min_frequency.inspect} max #{max_frequency.inspect} over #{role.fact_type.describe(role)} #{id} role ref = #{x_roles[0]["ref"]}"
             @by_id[id] = @constellation.PresenceConstraint(
-                :new,
+                id_of(x_frequency_constraint),
                 :vocabulary => @vocabulary,
                 :name => name = x_frequency_constraint["Name"] || '',
                 :role_sequence => role_sequence,
@@ -1208,7 +1254,7 @@ module ActiveFacts
               vt = @by_id[vt_id]
               throw "ValueType #{vtname} not found" unless vt
 
-              i = @constellation.Instance(:new, :population => population, :object_type => vt, :value => [v.text, is_a_string(v.text), nil])
+              i = @constellation.Instance(id_of(v.parent), :population => population, :object_type => vt, :value => [v.text, is_literal_string(v.text), nil])
               @by_id[id] = i
               # show_xmlobj(v)
             }
@@ -1237,14 +1283,15 @@ module ActiveFacts
                 throw "EntityType #{etname} not found" unless et
               end
 
-              instance = @constellation.Instance(:new, :population => population, :object_type => et, :value => nil)
+              instance = @constellation.Instance(id_of(v), :population => population, :object_type => et, :value => nil)
               @by_id[id] = instance
               debug :orm, "Made new EntityType #{etname}"
             }
           end
 
           # The EntityType instances have implicit facts for the PI facts.
-          # We must create implicit PI facts after all the instances.
+	  # These are in the ORM file, but instead of using those,
+          # We create implicit PI facts after all the instances.
           entity_count = 0
           pi_fact_count = 0
           debug :orm, "Creating identifying facts for entities" do
@@ -1294,6 +1341,7 @@ module ActiveFacts
           # Use the "ref" attribute of FactTypeRoleInstance:
           x_fact_roles = @x_model.xpath("orm:Facts/orm:Fact/orm:Instances/orm:FactTypeInstance/orm:RoleInstances/orm:FactTypeRoleInstance")
 
+	  # REVISIT: This presumably duplicates the identifying fact instances for the above entities. Hmmm.
           last_id = nil
           fact = nil
           fact_roles = []
@@ -1329,7 +1377,7 @@ module ActiveFacts
         debug :orm, "Reading diagrams" do
           x_diagrams.each do |x|
             name = (x["Name"] || '').strip
-            diagram = @constellation.Diagram(@vocabulary, name)
+            diagram = @constellation.ORMDiagram(@vocabulary, name)
             debug :diagram, "Starting to read diagram #{name}"
             shapes = x.xpath("ormDiagram:Shapes/*")
             debug :orm, "Reading shapes" do
@@ -1346,28 +1394,28 @@ module ActiveFacts
                   end
                 when 'ExternalConstraintShape', 'FrequencyConstraintShape'
                   # REVISIT: The offset might depend on the constraint type. This is right for subset and other round ones.
-                  position = convert_position(bounds, Gravity::C)
+                  location = convert_location(bounds, Gravity::C)
                   shape = @constellation.ConstraintShape(
-                      :new, :diagram => diagram, :position => position, :is_expanded => is_expanded,
+                      :guid => id_of(x_shape), :orm_diagram => diagram, :location => location, :is_expanded => is_expanded,
                       :constraint => subject
                     )
                 when 'RingConstraintShape'
                   # REVISIT: The offset might depend on the ring constraint type. This is right for basic round ones.
-                  position = convert_position(bounds, Gravity::C)
+                  location = convert_location(bounds, Gravity::C)
                   shape = @constellation.RingConstraintShape(
-                      :new, :diagram => diagram, :position => position, :is_expanded => is_expanded,
+                      :guid => id_of(x_shape), :orm_diagram => diagram, :location => location, :is_expanded => is_expanded,
                       :constraint => subject
                     )
                   shape.fact_type = subject.role.fact_type
                 when 'ModelNoteShape'
                   # REVISIT: Add model notes
                 when 'ObjectTypeShape'
-                  position = convert_position(bounds, Gravity::C)
-                  # $stderr.puts "#{subject.name}: bounds=#{bounds} -> position = (#{position.x}, #{position.y})"
+                  location = convert_location(bounds, Gravity::C)
+                  # $stderr.puts "#{subject.name}: bounds=#{bounds} -> location = (#{location.x}, #{location.y})"
                   shape = @constellation.ObjectTypeShape(
-                      :new, :diagram => diagram, :position => position, :is_expanded => is_expanded,
+                      :guid => id_of(x_shape), :orm_diagram => diagram, :location => location, :is_expanded => is_expanded,
                       :object_type => subject,
-                      :position => position
+                      :location => location
                     )
                 else
                   raise "Unknown shape #{x_shape.name}"
@@ -1392,7 +1440,7 @@ module ActiveFacts
           else nil
           end
 
-        # Position of a fact type is the centre of the row of role boxes
+        # Location of a fact type is the centre of the row of role boxes
         offs_x = 11
         offs_y = -12
         if fact_type.entity_type
@@ -1400,17 +1448,17 @@ module ActiveFacts
           offs_y -= 9 if !fact_type.entity_type.is_implied_by_objectification
         end
 
-        position = convert_position(bounds, Gravity::S, offs_x, offs_y)
+        location = convert_location(bounds, Gravity::S, offs_x, offs_y)
 
-        # $stderr.puts "#{fact_type.describe}: bounds=#{bounds} -> position = (#{position.x}, #{position.y})"
+        # $stderr.puts "#{fact_type.describe}: bounds=#{bounds} -> location = (#{location.x}, #{location.y})"
 
         debug :orm, "REVISIT: Can't place rotated fact type correctly on diagram yet" if rotation_setting
 
-        debug :orm, "fact type at #{position.x},#{position.y} has display_role_names_setting=#{display_role_names_setting.inspect}, rotation_setting=#{rotation_setting.inspect}"
+        debug :orm, "fact type at #{location.x},#{location.y} has display_role_names_setting=#{display_role_names_setting.inspect}, rotation_setting=#{rotation_setting.inspect}"
         shape = @constellation.FactTypeShape(
-            :new,
-            :diagram => diagram,
-            :position => position,
+            :guid => id_of(x_shape),
+            :orm_diagram => diagram,
+            :location => location,
             :is_expanded => is_expanded,
             :display_role_names_setting => display_role_names_setting,
             :rotation_setting => rotation_setting,
@@ -1433,18 +1481,23 @@ module ActiveFacts
 
         relative_shapes = x_shape.xpath('ormDiagram:RelativeShapes/*')
         relative_shapes.each do |xr_shape|
-          position = convert_position(xr_shape['AbsoluteBounds'])
+          location = convert_location(xr_shape['AbsoluteBounds'])
           case xr_shape.name
           when 'ObjectifiedFactTypeNameShape'
-            @constellation.ObjectifiedFactTypeNameShape(shape, :guid => :new, :diagram => diagram, :position => position, :is_expanded => false)
+            @constellation.ObjectifiedFactTypeNameShape(:guid => id_of(xr_shape), :fact_type_shape => shape, :orm_diagram => diagram, :location => location, :is_expanded => false)
           when 'ReadingShape'
-            @constellation.ReadingShape(shape, :guid => :new, :fact_type_shape=>shape, :diagram => diagram, :position => position, :is_expanded => false, :reading => fact_type.preferred_reading)
+	    begin
+            @constellation.ReadingShape(:guid => id_of(xr_shape), :fact_type_shape => shape, :orm_diagram => diagram, :location => location, :is_expanded => false, :reading => fact_type.preferred_reading)
+	    rescue =>e
+	      debugger
+	      @constellation.ReadingShape(:guid => id_of(xr_shape), :fact_type_shape => shape, :orm_diagram => diagram, :location => location, :is_expanded => false, :reading => fact_type.preferred_reading)
+	    end
           when 'RoleNameShape'
             role = @by_id[xr_shape.xpath("ormDiagram:Subject")[0]['ref']]
             role_display = role_display_for_role(shape, x_role_display, role)
             debug :orm, "Fact type '#{fact_type.preferred_reading.expand}' has #{xr_shape.name}"
             @constellation.RoleNameShape(
-              :new, :diagram => diagram, :position => position, :is_expanded => false,
+              :guid => id_of(xr_shape), :orm_diagram => diagram, :location => location, :is_expanded => false,
               :role_display => role_display
             )
           when 'ValueConstraintShape'
@@ -1455,7 +1508,7 @@ module ActiveFacts
             role_display = role_display_for_role(shape, x_role_display, constraint.role)
             debug :orm, "ValueConstraintShape is on #{role_display.ordinal}'th role (by #{x_role_display.size > 0 ? 'role_display' : 'fact roles'})"
             @constellation.ValueConstraintShape(
-              :new, :diagram => diagram, :position => position, :is_expanded => false,
+              :guid => id_of(xr_shape), :orm_diagram => diagram, :location => location, :is_expanded => false,
               :constraint => constraint,
               :object_type_shape => nil,  # This constraint is relative to a Fact Type, so must be on a role
               :role_display => role_display
@@ -1480,7 +1533,7 @@ module ActiveFacts
       end
 
       DIAGRAM_SCALE = 96*1.5
-      def convert_position(bounds, gravity = Gravity::C, xoffs = 0, yoffs = 0)
+      def convert_location(bounds, gravity = Gravity::C, xoffs = 0, yoffs = 0)
         return nil unless bounds
         # Bounds is top, left, width, height in inches
         bf = bounds.split(/, /).map{|b|b.to_f}
@@ -1492,11 +1545,11 @@ module ActiveFacts
 
         x = (DIAGRAM_SCALE * (bf[0]+bf[2]*sizefrax[gravity][0]/2)).round + xoffs
         y = (DIAGRAM_SCALE * (bf[1]+bf[3]*sizefrax[gravity][1]/2)).round + yoffs
-        @constellation.Position(x, y)
+        @constellation.Location(x, y)
       end
 
       # Detect numeric data and denote it as a string:
-      def is_a_string(value)
+      def is_literal_string(value)
         value =~ /[^ \d.]/
       end