activefacts 0.8.9 → 0.8.10

data/lib/activefacts/input/orm.rb

@@ -177,6 +177,8 @@ module ActiveFacts
           name = (x['Name'] || "").gsub(/\s+/,' ').gsub(/-/,'_').strip
           name = nil if name.size == 0
 
+          next if x['IsImplicitBooleanValue']
+
           cdt = x.xpath('orm:ConceptualDataType')[0]
           scale = cdt['Scale']
           scale = scale != "" && scale.to_i
@@ -244,6 +246,7 @@ module ActiveFacts
             name = "<unnamed>" if !name
             name = "" if !name || name.size == 0
             # Note that the new metamodel doesn't have a name for a facttype unless it's objectified
+            next if x.xpath("orm:DerivationRule").size > 0
 
             debug :orm, "FactType #{name || id}"
             facts << @by_id[id] = fact_type = @constellation.FactType(:new)
@@ -284,8 +287,7 @@ module ActiveFacts
             throw "For Subtype fact #{name}, the subtype #{subtype_id} was not found" if !subtype
             debug :orm, "#{subtype.name} is a subtype of #{supertype.name}"
 
-            inheritance_fact = @constellation.TypeInheritance(subtype, supertype)
-            inheritance_fact.fact_type_id = :new
+            inheritance_fact = @constellation.TypeInheritance(subtype, supertype, :fact_type_id => :new)
             if x["IsPrimary"] == "true" or           # Old way
               x["PreferredIdentificationPath"] == "true"   # Newer
               debug :orm, "#{supertype.name} is primary supertype of #{subtype.name}"
@@ -297,8 +299,8 @@ 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, :concept => subtype)
-            supertype_role = @by_id[supertype_role_id] = @constellation.Role(inheritance_fact, 1, :concept => supertype)
+            subtype_role = @by_id[subtype_role_id] = @constellation.Role(inheritance_fact, 0, :object_type => subtype)
+            supertype_role = @by_id[supertype_role_id] = @constellation.Role(inheritance_fact, 1, :object_type => supertype)
 
             # Create readings, so constraints can be verbalised for example:
             rs = @constellation.RoleSequence(:new)
@@ -310,7 +312,7 @@ module ActiveFacts
             rs2 = @constellation.RoleSequence(:new)
             @constellation.RoleRef(rs2, 0, :role => supertype_role)
             @constellation.RoleRef(rs2, 1, :role => subtype_role)
-            n = 'aeiouh'.include?(subtype_role.concept.name.downcase[0]) ? 1 : 0
+            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}")
           }
@@ -334,6 +336,7 @@ 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
 
             #if is_implied
@@ -345,6 +348,8 @@ module ActiveFacts
               @nested_types <<
                 @by_id[id] =
                 nested_type = @constellation.EntityType(@vocabulary, name)
+              independent = x['IsIndependent']
+              nested_type.is_independent = true if independent && independent == 'true' && !is_implied
               nested_type.fact_type = fact_type
             end
           }
@@ -364,6 +369,7 @@ module ActiveFacts
         debug :orm, "Reading roles and readings" do
           @x_facts.each{|x|
             id = x['id']
+            next if x.xpath("orm:DerivationRule").size > 0
             fact_type = @by_id[id]
             fact_name = x['Name'] || x['_Name'] || ''
             #fact_name.gsub!(/\s/,'')
@@ -385,9 +391,8 @@ module ActiveFacts
                 raise "Invalid ORM file; fact has missing player (RolePlayer id=#{id})" unless rp
                 ref = rp['ref']
 
-                # Find the concept that plays the role:
-                concept = @by_id[ref]
-                throw "RolePlayer for '#{name}' #{ref} was not found" if !concept
+                # Find the object_type that plays the role:
+                object_type = @by_id[ref]
 
                 # Skip implicit roles added by NORMA to make unaries into binaries.
                 # This would make constraints over the deleted roles impossible,
@@ -406,19 +411,19 @@ module ActiveFacts
                   role_name = x['Name']
                   other_role.role_name = role_name if role_name && role_name != ''
 
-                  concept.retract       # Delete our object for the implicit boolean ValueType
                   @by_id.delete(ref)    # and de-index it from our list
                   next
                 end
+                throw "RolePlayer for '#{name}' #{ref} was not found" if !object_type
 
-                debug :orm, "#{@vocabulary.name}, RoleName=#{x['Name'].inspect} played by concept=#{concept.name}"
-                throw "Role is played by #{concept.class} not Concept" if !(@constellation.vocabulary.concept(:Concept) === concept)
+                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.fact_type_id} played by #{concept.name}"
+                debug :orm, "Creating role #{name} nr#{fact_type.all_role.size} of #{fact_type.fact_type_id} played by #{object_type.name}"
 
-                role = @by_id[id] = @constellation.Role(fact_type, fact_type.all_role.size, :concept => concept)
-                role.role_name = name if name && name != concept.name
-                debug :orm, "Fact #{fact_name} (id #{fact_type.fact_type_id.object_id}) role #{x['Name']} is played by #{concept.name}, role is #{role.object_id}"
+                role = @by_id[id] = @constellation.Role(fact_type, fact_type.all_role.size, :object_type => object_type)
+                role.role_name = name if name && name != object_type.name
+                debug :orm, "Fact #{fact_name} (id #{fact_type.fact_type_id.object_id}) role #{x['Name']} is played by #{object_type.name}, role is #{role.object_id}"
 
                 x_vr = x.xpath("orm:ValueRestriction/orm:RoleValueConstraint")
                 x_vr.each{|vr|
@@ -431,7 +436,7 @@ module ActiveFacts
                   }
                 }
 
-                debug :orm, "Adding Role #{role.role_name || role.concept.name} to #{fact_type.describe}"
+                debug :orm, "Adding Role #{role.role_name || role.object_type.name} to #{fact_type.describe}"
                 #fact_type.add_role(role)
                 debug :orm, "Role #{role} is #{id}"
               }
@@ -482,7 +487,7 @@ module ActiveFacts
             #puts "text=#{text.inspect}, la=#{$1.inspect}, ta=#{$2.inspect}" if $1 || $2
             la = ($1||'').gsub(/\s+/,' ').sub(/-/,'').strip
             ta = ($2||'').gsub(/\s+/,' ').sub(/-/,'').strip
-            #puts "Setting leading adj #{la.inspect} from #{text.inspect} for #{role_ref.role.concept.name}" if la != ""
+            #puts "Setting leading adj #{la.inspect} from #{text.inspect} for #{role_ref.role.object_type.name}" if la != ""
             # REVISIT: Dunno what's up here, but removing the "if" test makes this chuck exceptions:
             role_ref.leading_adjective = la if la != ""
             role_ref.trailing_adjective = ta if ta != ""
@@ -502,7 +507,7 @@ module ActiveFacts
             if RESERVED_WORDS.include?(w)
               $stderr.puts "Masking reserved word '#{w}' in reading '#{text}'"
               next "_#{w}"
-            elsif @constellation.Concept[[[@vocabulary.name], w]]
+            elsif @constellation.ObjectType[[[@vocabulary.name], w]]
               $stderr.puts "Masking object type name '#{w}' in reading '#{text}'"
               next "_#{w}"
             elsif all_role_refs.detect{|rr| rr.role.role_name == w}
@@ -519,17 +524,17 @@ module ActiveFacts
             next ''
           end
         end
-        $stderr.puts "Elided illegal characters '#{elided}' from reading" unless elided.empty?
+        $stderr.puts "Elided illegal characters '#{elided}' from reading #{text.inspect}" unless elided.empty?
         text
       end
 
       def get_role_sequence(role_array)
-        # puts "Getting RoleSequence [#{role_array.map{|r| "#{r.concept.name} (role #{r.object_id})" }*", "}]"
+        # puts "Getting RoleSequence [#{role_array.map{|r| "#{r.object_type.name} (role #{r.object_id})" }*", "}]"
 
         # Look for an existing RoleSequence
         # REVISIT: This searches all role sequences. Perhaps we could narrow it down first instead?
         role_sequence = @constellation.RoleSequence.values.detect{|c|
-          #puts "Checking RoleSequence [#{c.all_role_ref.map{|rr| rr.role.concept.name}*", "}]"
+          #puts "Checking RoleSequence [#{c.all_role_ref.map{|rr| rr.role.object_type.name}*", "}]"
           role_array == c.all_role_ref.sort_by{|rr| rr.ordinal}.map{|rr| rr.role }
           }
         # puts "Found matching RoleSequence!" if role_sequence
@@ -558,12 +563,15 @@ module ActiveFacts
             if (x_object.name.to_s == 'ObjectifiedType')
               x_nests = x_object.xpath('orm:NestedPredicate')[0]
               implied = x_nests['IsImplied']
+              # x_fact is the fact of which the role player is an objectification, not the fact this role belongs to
               x_fact = @x_by_id[x_nests['ref']]
             end
 
             # This might have been a role of an ImpliedFact, which makes it safe to ignore.
             next if 'ImpliedFact' == x_role.parent.parent.name
 
+            next if x_role.parent.parent.xpath('orm:DerivationRule').size > 0
+
             # Talk about why this wasn't found - this shouldn't happen.
             if (!x_nests || !implied)
               #puts "="*60
@@ -629,7 +637,7 @@ module ActiveFacts
             name = nil if name.size == 0
             #puts "Residual Mandatory #{name}: #{role_sequence.to_s}"
 
-            if (players = role_sequence.all_role_ref.map{|rr| rr.role.concept}).uniq.size > 1
+            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)
               raise "Mandatory join constraint #{name} has incompatible players #{players.map{|o| o.name}.inspect}" unless join_over
               if players.detect{|p| p != join_over}
@@ -666,7 +674,7 @@ module ActiveFacts
             x_pi = x.xpath("orm:PreferredIdentifierFor")[0]
             pi = x_pi ? @by_id[eref = x_pi['ref']] : nil
 
-            # Skip uniqueness constraints on implied concepts
+            # Skip uniqueness constraints on implied object_types
             next if x_pi && !pi
 
             # Get the RoleSequence:
@@ -680,7 +688,7 @@ module ActiveFacts
             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)
 
-              players = role_sequence.all_role_ref.map{|rr| rr.role.concept.name}.uniq
+              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
               subtyping = players.size > 1 ? 'subtyping ' : ''
               # REVISIT: Create the Join, the JoinNode for join_over, and steps from each role_ref to join_over
@@ -724,7 +732,7 @@ module ActiveFacts
               (role = rr.role) &&
               (fact_type = role.fact_type) &&
               fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) &&
-              role.concept == fact_type.supertype &&
+              role.object_type == fact_type.supertype &&
               fact_type.provides_identification
 
             pc = @constellation.PresenceConstraint(:new)
@@ -747,10 +755,10 @@ module ActiveFacts
       end
 
       def subtype_join_step(join, ti)
-        subtype_node = join.all_join_node.detect{|jn| jn.concept == ti.subtype } ||
-          @constellation.JoinNode(join, join.all_join_node.size, :concept => ti.subtype)
-        supertype_node = join.all_join_node.detect{|jn| jn.concept == ti.supertype } ||
-          @constellation.JoinNode(join, join.all_join_node.size, :concept => ti.supertype)
+        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)
         rs = @constellation.RoleSequence(:new)
         @constellation.RoleRef(rs, 0, :role => ti.subtype_role)
         sub_jr = @constellation.JoinRole(subtype_node, ti.subtype_role)
@@ -793,8 +801,11 @@ module ActiveFacts
         end_joins = []    # An array of booleans indicating whether any role_sequence requires a subtyping join
         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}}
-          next if (fact_types = role_refs.map{|rr| rr.role.fact_type}).uniq.size == 1
-          if (players = role_refs.map{|rr| rr.role.concept}).uniq.size == 1
+          if (fact_types = role_refs.map{|rr| rr.role.fact_type}).uniq.size == 1
+            raise "In #{constraint_type} #{name}, there is a faulty join"
+            next
+          end
+          if (players = role_refs.map{|rr| rr.role.object_type}).uniq.size == 1
             end_point = players[0]
             end_joins[i] = false
           else
@@ -805,7 +816,7 @@ module ActiveFacts
               end
             end_point = common_supertypes[0]
 
-            raise "constrained roles of #{constraint_type} constraint #{name} are incompatible (#{names*', '})" if common_supertypes.size == 0
+            raise "constrained roles of #{constraint_type} constraint #{name} are incompatible (#{players.map(&:name)*', '})" if common_supertypes.size == 0
             end_joins[i] = true
           end
           end_points[i] = end_point
@@ -849,7 +860,7 @@ module ActiveFacts
           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)
             role_refs = role_sequence.all_role_ref_in_order
-            if !join_over and !role_refs.detect{|rr| rr.role.concept != end_points[rr.ordinal]}
+            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
@@ -866,8 +877,9 @@ module ActiveFacts
 
               # Create a join node for the actual end-point (supertype of the constrained roles)
               end_point = end_points[i]
+              raise "In #{constraint_type} #{name}, there is a faulty join" unless end_point
               debug :join, "Join Node #{join.all_join_node.size} is for #{end_point.name}"
-              end_node = @constellation.JoinNode(join, join.all_join_node.size, :concept => end_point)
+              end_node = @constellation.JoinNode(join, join.all_join_node.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
@@ -876,7 +888,7 @@ module ActiveFacts
               # Create subtyping join steps at the end-point, if needed:
               projecting_jr = nil
               constrained_join_role = nil
-              if (subtype = role_ref.role.concept) != end_point
+              if (subtype = role_ref.role.object_type) != end_point
                 debug :join, "Making subtyping join 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)
@@ -884,14 +896,14 @@ module ActiveFacts
                   constrained_join_role = subtyping_steps[-1].input_join_role
 
                   # Replace the constrained role and node with the supertype ones:
-                  end_node = join.all_join_node.detect{|jn| jn.concept == end_point }
+                  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.concept == end_point }
-                  role_node = join.all_join_node.detect{|jn| jn.concept == role_ref.role.concept }
+                  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
               end
 
-              raise "Internal error: making illegal reference to join node" if end_role.concept != end_node.concept
+              raise "Internal error: making illegal reference to join node" 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
@@ -899,15 +911,15 @@ module ActiveFacts
               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, :concept => join_over)
+                  join_node = @constellation.JoinNode(join, join.all_join_node.size, :object_type => join_over)
                 end
                 debug :join, "Making join 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: making illegal reference to join node" if role_ref.role.concept != role_node.concept
+                  raise "Internal error: making illegal reference to join node" 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: making illegal reference to join node" if joined_role.concept != join_node.concept
+                  raise "Internal error: making illegal reference to join node" if joined_role.object_type != join_node.object_type
                   @constellation.RoleRef(rs, 1, :role => joined_role)
                   join_jr = @constellation.JoinRole(join_node, joined_role)
 
@@ -919,13 +931,13 @@ module ActiveFacts
                 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: making illegal join step" if role_ref.role.concept != role_node.concept
+                    raise "Internal error: 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]
                     roles.each do |incidental_role|
-                      jn = @constellation.JoinNode(join, join.all_join_node.size, :concept => incidental_role.concept)
+                      jn = @constellation.JoinNode(join, join.all_join_node.size, :object_type => incidental_role.object_type)
                       jr = @constellation.JoinRole(jn, incidental_role, :join_step => js)
                     end
                   else
@@ -941,7 +953,7 @@ module ActiveFacts
                       role_ref.role.fact_type.all_role.each do |role|
                         next if role == role_jr.role
                         next if role_sequence.all_role_ref.detect{|rr| rr.role == role}
-                        jn = @constellation.JoinNode(join, join.all_join_node.size, :concept => role.concept)
+                        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
@@ -994,6 +1006,8 @@ module ActiveFacts
               @mandatory_constraints_by_rs.delete(mc_rs)
             end
 
+            next if role_sequences.compact.size != role_sequences.size  # Role sequence missing; includes a derived fact type role
+
             make_joins('exclusion', name+(x_mandatory ? '/'+x_mandatory['Name'] : ''), role_sequences)
 
             ec = @constellation.SetExclusionConstraint(:new)
@@ -1026,6 +1040,7 @@ module ActiveFacts
                   )
                 }
 
+            next if role_sequences.compact.size != role_sequences.size  # Role sequence missing; includes a derived fact type role
             make_joins('equality', name, role_sequences)
 
             ec = @constellation.SetEqualityConstraint(:new)
@@ -1055,6 +1070,7 @@ module ActiveFacts
                     "equality constraint #{name}"
                   )
                 }
+            next if role_sequences.compact.size != role_sequences.size  # Role sequence missing; includes a derived fact type role
             make_joins('subset', name, role_sequences)
 
             ec = @constellation.SubsetConstraint(:new)
@@ -1081,9 +1097,10 @@ module ActiveFacts
               map do |xr|
                 @by_id[xr['ref']]
               end
-            if from.concept != to.concept
+            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)
-              raise "Ring constraint has incompatible players #{from.concept.name}, #{to.concept.name}" if !join_over
+              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}"
             end
             rc = @constellation.RingConstraint(:new)
@@ -1111,6 +1128,7 @@ module ActiveFacts
             role = @by_id[x_roles[0]["ref"]]
             role_sequence = @constellation.RoleSequence(:new)
             role_ref = @constellation.RoleRef(role_sequence, 0, :role => role)
+            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,
@@ -1146,7 +1164,7 @@ module ActiveFacts
               vt = @by_id[vt_id]
               throw "ValueType #{vtname} not found" unless vt
 
-              i = @constellation.Instance(:new, :population => population, :concept => vt, :value => [v.text, is_a_string(v.text), nil])
+              i = @constellation.Instance(:new, :population => population, :object_type => vt, :value => [v.text, is_a_string(v.text), nil])
               @by_id[id] = i
               # show_xmlobj(v)
             }
@@ -1175,7 +1193,7 @@ module ActiveFacts
                 throw "EntityType #{etname} not found" unless et
               end
 
-              instance = @constellation.Instance(:new, :population => population, :concept => et, :value => nil)
+              instance = @constellation.Instance(:new, :population => population, :object_type => et, :value => nil)
               @by_id[id] = instance
               debug :orm, "Made new EntityType #{etname}"
             }
@@ -1212,7 +1230,7 @@ module ActiveFacts
                   debug :orm, "For FactType #{ft}" do
                     fact = @constellation.Fact(:new, :population => population, :fact_type => ft)
                     fact_roles = ft.all_role.map do |role|
-                      if role.concept == et
+                      if role.object_type == et
                         object = instance
                       else
                         object = role_instances[role]
@@ -1299,7 +1317,7 @@ module ActiveFacts
                 when 'ObjectTypeShape'
                   shape = @constellation.ObjectTypeShape(
                       :new, :diagram => diagram, :position => position, :is_expanded => is_expanded,
-                      :concept => subject,
+                      :object_type => subject,
                       :has_expanded_reference_mode => false # REVISIT
                     )
                 else
@@ -1350,9 +1368,9 @@ module ActiveFacts
           )
         # Create RoleDisplay objects if necessary
         x_role_display = x_shape.xpath("ormDiagram:RoleDisplayOrder/ormDiagram:Role")
-        # print "Fact type '#{fact_type.preferred_reading.expand}' (#{fact_type.all_role.map{|r|r.concept.name}*' '})"
+        # print "Fact type '#{fact_type.preferred_reading.expand}' (#{fact_type.all_role.map{|r|r.object_type.name}*' '})"
         if x_role_display.size > 0
-          debug :orm, " has roleDisplay (#{x_role_display.map{|rd| @by_id[rd['ref']].concept.name}*','})'"
+          debug :orm, " has roleDisplay (#{x_role_display.map{|rd| @by_id[rd['ref']].object_type.name}*','})'"
           x_role_display.each_with_index do |rd, ordinal|
             role_display = @constellation.RoleDisplay(shape, ordinal, :role => @by_id[rd['ref']])
           end

data/lib/activefacts/persistence.rb

@@ -12,4 +12,4 @@ require 'activefacts/persistence/foreignkey'
 require 'activefacts/persistence/index'
 
 # These extend the API classes with relational awareness:
-require 'activefacts/persistence/concept'
+require 'activefacts/persistence/object_type'

data/lib/activefacts/persistence/columns.rb

@@ -4,12 +4,12 @@
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
-# Each Reference from a Concept creates one or more Columns.
+# Each Reference from a ObjectType creates one or more Columns.
 # A reference to a simple valuetype creates a single column, as
 # does a reference to a table entity identified by a single value.
 #
-# When referring to a concept that doesn't have its own table,
-# all references from that concept are absorbed into this one.
+# When referring to a object_type that doesn't have its own table,
+# all references from that object_type are absorbed into this one.
 #
 # When multiple values identify an entity that does have its own
 # table, a reference to that entity creates multiple columns,
@@ -63,12 +63,16 @@ module ActiveFacts
       # * If the names retained so far end in XYZ and the to_names start with XYZ, remove the duplication
       # * If we have retained the name of an entity, and this reference is the sole identifying role of an entity, and the identifying object has a name that is prefixed by the name of the object it identifies, remove the prefix and use just the suffix.
       def name(joiner = "")
+        self.class.name(@references, joiner)
+      end
+
+      def self.name(refs, joiner = "")
         last_names = []
-        names = @references.
+        names = refs.
           inject([]) do |a, ref|
 
             # Skip any object after the first which is identified by this reference
-            if ref != @references[0] and
+            if ref != refs[0] and
                 !ref.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) and
                 ref.to and
                 ref.to.is_a?(ActiveFacts::Metamodel::EntityType) and
@@ -99,8 +103,8 @@ module ActiveFacts
               names.shift
             end
 
-            # If the reference is to the single identifying role of the concept making the reference,
-            # strip the concept name from the start of the reference role
+            # If the reference is to the single identifying role of the object_type making the reference,
+            # strip the object_type name from the start of the reference role
             if a.size > 0 and
                 (et = ref.from).is_a?(ActiveFacts::Metamodel::EntityType) and
                 # This instead of the next 2 would apply to all identifying roles, but breaks some examples:
@@ -209,10 +213,10 @@ module ActiveFacts
   end
 
   module Metamodel    #:nodoc:
-    # The Concept class is defined in the metamodel; full documentation is not generated.
+    # The ObjectType class is defined in the metamodel; full documentation is not generated.
     # This section shows the features relevant to relational Persistence.
-    class Concept
-      # The array of columns for this Concept's table
+    class ObjectType
+      # The array of columns for this ObjectType's table
       def columns
         @columns
       end
@@ -225,7 +229,7 @@ module ActiveFacts
 
     # The ValueType class is defined in the metamodel; full documentation is not generated.
     # This section shows the features relevant to relational Persistence.
-    class ValueType < Concept
+    class ValueType < ObjectType
       # The identifier_columns for a ValueType can only ever be the self-value role that was injected
       def identifier_columns
         debug :columns, "Identifier Columns for #{name}" do
@@ -274,7 +278,7 @@ module ActiveFacts
 
     # The EntityType class is defined in the metamodel; full documentation is not generated.
     # This section shows the features relevant to relational Persistence.
-    class EntityType < Concept
+    class EntityType < ObjectType
       # The identifier_columns for an EntityType are the columns that result from the identifying roles
       def identifier_columns
         debug :columns, "Identifier Columns for #{name}" do
@@ -303,7 +307,7 @@ module ActiveFacts
             (all_type_inheritance_as_subtype.size == 0 ||
               all_type_inheritance_as_subtype.detect{|ti| ti.provides_identification })
             rc = absorbed_via.from.reference_columns(excluded_supertypes)
-            # The absorbed_via reference gets skipped here, ans also in concept.rb
+            # The absorbed_via reference gets skipped here, ans also in object_type.rb
             debug :columns, "Skipping #{absorbed_via}"
             #rc.each{|col| col.prepend(absorbed_via)}
             return rc
@@ -363,8 +367,8 @@ module ActiveFacts
       # Make schema transformations like adding ValueType self-value columns (and later, Rails-friendly ID fields).
       # Override this method to change the transformations
       def finish_schema
-        all_concept.each do |concept|
-          concept.self_value_reference if concept.is_a?(ActiveFacts::Metamodel::ValueType) && concept.is_table
+        all_object_type.each do |object_type|
+          object_type.self_value_reference if object_type.is_a?(ActiveFacts::Metamodel::ValueType) && object_type.is_table
         end
       end
 
@@ -373,18 +377,18 @@ module ActiveFacts
         finish_schema
 
         debug :columns, "Populating all columns" do
-          all_concept.each do |concept|
-            next if !concept.is_table
-            debug :columns, "Populating columns for table #{concept.name}" do
-              concept.populate_columns
+          all_object_type.each do |object_type|
+            next if !object_type.is_table
+            debug :columns, "Populating columns for table #{object_type.name}" do
+              object_type.populate_columns
             end
           end
         end
         debug :columns, "Finished columns" do
-          all_concept.each do |concept|
-            next if !concept.is_table
-            debug :columns, "Finished columns for table #{concept.name}" do
-              concept.columns.each do |column|
+          all_object_type.each do |object_type|
+            next if !object_type.is_table
+            debug :columns, "Finished columns for table #{object_type.name}" do
+              object_type.columns.each do |column|
                 debug :columns, "#{column}"
               end
             end