activefacts 0.8.18 → 1.0.0

data/lib/activefacts/generate/helpers/ordered.rb

@@ -52,7 +52,7 @@ module ActiveFacts
               when ActiveFacts::Metamodel::PresenceConstraint
                 fact_types = c.role_sequence.all_role_ref.map{|rr| rr.role.fact_type}.uniq  # All fact types spanned by this constraint
                 if fact_types.size == 1     # There's only one, save it:
-                  # debug "Single-fact constraint on #{fact_types[0].guid}: #{c.name}"
+                  # debug "Single-fact constraint on #{fact_types[0].concept.guid}: #{c.name}"
                   (@presence_constraints_by_fact[fact_types[0]] ||= []) << c
                 end
               when ActiveFacts::Metamodel::RingConstraint
@@ -93,6 +93,26 @@ module ActiveFacts
           units_end if done_banner
         end
 
+        def value_type_fork(o)
+	  if o.name == "_ImplicitBooleanValueType"
+	    # do nothing
+	  elsif
+	      !o.supertype                      # No supertype, i.e. a base type
+	      o.all_role.size == 0 &&           # No roles
+	      !o.is_independent &&              # not independent
+	      !o.value_constraint &&		# No value constraints
+	      o.concept.all_context_note_as_relevant_concept.size == 0 &&	# No context notes
+	      o.all_instance.size == 0          # No instances
+	    data_type_dump(o)
+	  else
+	    super_type_name = o.supertype ? o.supertype.name : o.name
+	    length = (l = o.length) && l > 0 ? "#{l}" : nil
+	    scale = (s = o.scale) && s > 0 ? "#{s}" : nil
+	    facets = { :length => length, :scale => scale }
+	    value_type_dump(o, super_type_name, facets)
+	  end
+	end
+
         def value_types_dump
           done_banner = false
           @value_type_dumped = {}
@@ -112,7 +132,7 @@ module ActiveFacts
         def value_type_chain_dump(o)
           return if @value_type_dumped[o]
           value_type_chain_dump(o.supertype) if (o.supertype && !@value_type_dumped[o.supertype])
-          value_type_dump(o) if o.name != "_ImplicitBooleanValueType"
+          value_type_fork(o)
           @value_type_dumped[o] = true
         end
 
@@ -306,11 +326,13 @@ module ActiveFacts
         end
 
         def skip_fact_type(f)
+          return true if f.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+          return false if f.entity_type && !@object_types_dumped[f.entity_type]
+
           # REVISIT: There might be constraints we have to merge into the nested entity or subtype. 
           # These will come up as un-handled constraints:
+	  # Dump this fact type only if it contains a presence constraint we've missed:
           pcs = @presence_constraints_by_fact[f]
-          return true if f.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-          return false if f.entity_type && !@object_types_dumped[f.entity_type]
           pcs && pcs.size > 0 && !pcs.detect{|c| !@constraints_used[c] }
         end
 
@@ -334,7 +356,7 @@ module ActiveFacts
 
           # debug "for fact type #{fact_type.to_s}, considering\n\t#{fact_constraints.map(&:to_s)*",\n\t"}"
           # debug "#{fact_type.name} has readings:\n\t#{fact_type.readings.map(&:name)*"\n\t"}"
-          # debug "Dumping #{fact_type.guid} as a fact type"
+          # debug "Dumping #{fact_type.concept.guid} as a fact type"
 
           # Fact types that aren't nested have no names
           name = fact_type.entity_type && fact_type.entity_type.name
@@ -531,7 +553,11 @@ module ActiveFacts
           debug "Should override value_type_end"
         end
 
-        def value_type_dump(o)
+        def data_type_dump(o)
+          debug "Should override data_type_dump"
+        end
+
+	def value_type_dump(o, super_type_name, facets)
           debug "Should override value_type_dump"
         end
 

data/lib/activefacts/generate/json.rb

@@ -72,7 +72,7 @@ module ActiveFacts
               if o.fact_type
                 uuid = (uuids[o.fact_type] ||= uuid_from_id(o.fact_type))
                 j[:objectifies] = uuid
-                j[:implicit] = true if o.is_implied_by_objectification
+                j[:implicit] = true if o.concept.implication_rule
               end
               if o.all_type_inheritance_as_subtype.size > 0
                 j[:supertypes] = o.
@@ -248,7 +248,7 @@ module ActiveFacts
             if (c.enforcement)
               # REVISIT: Deontic constraint
             end
-            if (c.all_context_note_as_relevant_concept.size > 0)
+            if (c.concept.all_context_note_as_relevant_concept.size > 0)
               # REVISIT: Context Notes
             end
 

data/lib/activefacts/generate/ruby.rb

@@ -59,25 +59,17 @@ module ActiveFacts
         end
       end
 
-      def value_type_dump(o)
+      def data_type_dump(o)
+	value_type_dump(o, o.name, {}) if o.all_role.size > 0
+      end
+
+      def value_type_dump(o, super_type_name, facets)
         length = (l = o.length) && l > 0 ? ":length => #{l}" : nil
         scale = (s = o.scale) && s > 0 ? ":scale => #{s}" : nil
         params = [length,scale].compact * ", "
 
-        return if
-          !o.supertype &&                   # No supertype, i.e. a base type
-          o.all_role.size == 0 &&           # No roles
-          !o.is_independent &&              # not independent
-          o.all_instance.size == 0          # No instances
-
-        name = o.name
-        ruby_type_name =
-            if o.supertype
-              o.supertype.name.gsub(/ /,'')
-            else
-              o.name.gsub(/ /,'')
-            end
-        name = name.sub(/^[a-z]/) {|i| i.upcase}.gsub(/ /,'')
+        ruby_type_name = super_type_name.gsub(/ /,'')
+        name = o.name.sub(/^[a-z]/) {|i| i.upcase}.gsub(/ /,'')
         if ruby_type_name == name
           ruby_type_name = '::'+ruby_type_name
         end

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

@@ -14,18 +14,18 @@ module ActiveFacts
       def add_surrogate type_name = 'Auto Counter', suffix = 'ID'
 	# Find or assert the surrogate value type
 	auto_counter = vocabulary.valid_value_type_name(type_name) ||
-	  constellation.ValueType(:vocabulary => vocabulary, :name => type_name, :guid => :new)
+	  constellation.ValueType(:vocabulary => vocabulary, :name => type_name, :concept => :new)
 
 	# Create a subtype to identify this entity type:
 	vt_name = self.name + ' '+suffix
 	my_id = @vocabulary.valid_value_type_name(vt_name) ||
-	  constellation.ValueType(:vocabulary => vocabulary, :name => vt_name, :guid => :new, :supertype => auto_counter)
+	  constellation.ValueType(:vocabulary => vocabulary, :name => vt_name, :concept => :new, :supertype => auto_counter)
 
 	# Create a fact type
-	identifying_fact_type = constellation.FactType(:guid => :new)
-	my_role = constellation.Role(:guid => :new, :fact_type => identifying_fact_type, :ordinal => 0, :object_type => self)
+	identifying_fact_type = constellation.FactType(:concept => :new)
+	my_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 0, :object_type => self)
 	@injected_surrogate_role = my_role
-	id_role = constellation.Role(:guid => :new, :fact_type => identifying_fact_type, :ordinal => 1, :object_type => my_id)
+	id_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 1, :object_type => my_id)
 
 	# Create a reading (which needs a RoleSequence)
 	reading = constellation.Reading(
@@ -39,7 +39,7 @@ module ActiveFacts
 
 	# Create two uniqueness constraints for the one-to-one. Each needs a RoleSequence (two RoleRefs)
 	one_id = constellation.PresenceConstraint(
-	    :guid => :new,
+	    :concept => :new,
 	    :vocabulary => vocabulary,
 	    :name => self.name+'HasOne'+suffix,
 	    :role_sequence => [:new],
@@ -51,7 +51,7 @@ module ActiveFacts
 	@constellation.RoleRef(:role_sequence => one_id.role_sequence, :ordinal => 0, :role => my_role)
 
 	one_me = constellation.PresenceConstraint(
-	    :guid => :new,
+	    :concept => :new,
 	    :vocabulary => vocabulary,
 	    :name => self.name+suffix+'IsOfOne'+self.name,
 	    :role_sequence => [:new],

data/lib/activefacts/input/orm.rb

@@ -48,8 +48,8 @@ module ActiveFacts
         "UnsignedLargeIntegerNumeric" => "Unsigned Integer(64)",
         "AutoCounterNumeric" => "Auto Counter",
         "FloatingPointNumeric" => "Real(64)",
-        "SinglePrecisionFloatingPointNumeric" => " Real(32)",
-        "DoublePrecisionFloatingPointNumeric" => " Real(32)",
+        "SinglePrecisionFloatingPointNumeric" => "Real(32)",
+        "DoublePrecisionFloatingPointNumeric" => "Real(32)",
         "DecimalNumeric" => "Decimal",
         "MoneyNumeric" => "Money",
         "FixedLengthRawData" => "Blob",
@@ -160,7 +160,7 @@ module ActiveFacts
 	    @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))
+		@constellation.EntityType(@vocabulary, name, :concept => id_of(x))
 	      end
 	  entity_types << entity_type
 	  independent = x['IsIndependent']
@@ -233,7 +233,7 @@ module ActiveFacts
 	  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))
+	      @constellation.ValueType(@vocabulary, supertype_name, :concept => id_of(x_supertype))
 	  end
         else
           # REVISIT: Need to handle standard types better here:
@@ -241,7 +241,7 @@ module ActiveFacts
 	    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)
+		  @constellation.ValueType(@vocabulary.identifying_role_values, type_name, :concept => :new)
 	      end
 	    else
 	      nil
@@ -252,7 +252,7 @@ module ActiveFacts
 	  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))
+	      @constellation.ValueType(@vocabulary.identifying_role_values, name, :concept => id_of(x))
 	  end
         vt.supertype = value_super_type
         vt.length = length if length
@@ -305,7 +305,6 @@ 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(id_of(x))
@@ -353,7 +352,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 => id_of(x))
+            inheritance_fact = @constellation.TypeInheritance(subtype, supertype, :concept => id_of(x))
             if x["IsPrimary"] == "true" or           # Old way
               x["PreferredIdentificationPath"] == "true"   # Newer
               debug :orm, "#{supertype.name} is primary supertype of #{subtype.name}"
@@ -365,8 +364,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, :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))
+            subtype_role = @by_id[subtype_role_id] = @constellation.Role(inheritance_fact, 0, :object_type => subtype, :concept => id_of(x_subtype_role))
+            supertype_role = @by_id[supertype_role_id] = @constellation.Role(inheritance_fact, 1, :object_type => supertype, :concept => id_of(x_supertype_role))
 
             # Create readings, so constraints can be verbalised for example:
             rs = @constellation.RoleSequence(:new)
@@ -402,17 +401,16 @@ module ActiveFacts
 
             fact_id = x_fact_type['ref']
             fact_type = @by_id[fact_id]
-            next if x.xpath("orm:DerivationRule").size > 0
             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}"
+            debug :orm, "NestedType #{name} is #{id}, nests #{fact_type.concept.guid}"
             @nested_types <<
               @by_id[id] =
 		nested_type = @vocabulary.valid_entity_type_name(name) ||
-		  @constellation.EntityType(@vocabulary, name, :guid => id_of(x))
+		  @constellation.EntityType(@vocabulary, name, :concept => 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
+            nested_type.concept.implication_rule = 'objectification' if is_implied
             nested_type.fact_type = fact_type
           }
         end
@@ -431,7 +429,6 @@ 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/,'')
@@ -475,16 +472,18 @@ module ActiveFacts
                   @by_id.delete(ref)    # and de-index it from our list
                   next
                 end
-                throw "RolePlayer for '#{name}' #{ref} in fact type #{x.parent.parent['_Name']} was not found" if !object_type
+		if !object_type
+		  throw "RolePlayer for '#{name}' #{ref} in fact type #{x.parent.parent['_Name']} was not found"
+		end
 
                 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}"
+                debug :orm, "Creating role #{name} nr#{fact_type.all_role.size} of #{fact_type.concept.guid} played by #{object_type.name}"
 
-                role = @by_id[id] = @constellation.Role(fact_type, fact_type.all_role.size, :object_type => object_type, :guid => id_of(x))
+                role = @by_id[id] = @constellation.Role(fact_type, fact_type.all_role.size, :object_type => object_type, :concept => 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}"
+                debug :orm, "Fact #{fact_name} (id #{fact_type.concept.guid}) role #{x['Name']} is played by #{object_type.name}, role is #{role.concept.guid}"
 
                 x_vr = x.xpath("orm:ValueRestriction/orm:RoleValueConstraint")
                 x_vr.each{|vr|
@@ -571,7 +570,7 @@ module ActiveFacts
         text.strip!
         text.downcase!    # Check for reserved words and object type names *after* downcasing
         elided = ''
-        text.gsub!(/( |-?\b[A-Za-z_][A-Za-z0-9_]*\b-?|\{\d\})|./) do |w|
+        text.gsub!(/( |[a-z]+(-[a-z]+)+|-?\b[A-Za-z_][A-Za-z0-9_]*\b-?|\{\d\})|./) do |w|
           case w
           when /[A-Za-z]/
             if RESERVED_WORDS.include?(w)
@@ -599,7 +598,7 @@ module ActiveFacts
       end
 
       def get_role_sequence(role_array)
-        # puts "Getting RoleSequence [#{role_array.map{|r| "#{r.object_type.name} (role #{r.object_id})" }*", "}]"
+        # puts "Getting RoleSequence [#{role_array.map{|r| "#{r.object_type.name} (role #{r.concept.guid})" }*", "}]"
 
         # Look for an existing RoleSequence
         # REVISIT: This searches all role sequences. Perhaps we could narrow it down first instead?
@@ -640,8 +639,6 @@ module ActiveFacts
             # 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
@@ -1236,7 +1233,7 @@ module ActiveFacts
 
       def read_instances
         debug :orm, "Reading sample data" do
-          population = @constellation.Population(@vocabulary, "sample", :guid => :new)
+          population = @constellation.Population(@vocabulary, "sample", :concept => :new)
 
           # Value instances first, then entities then facts:
 
@@ -1406,7 +1403,7 @@ module ActiveFacts
                       :guid => id_of(x_shape), :orm_diagram => diagram, :location => location, :is_expanded => is_expanded,
                       :constraint => subject
                     )
-                  shape.fact_type = subject.role.fact_type
+                  shape.fact_type_shape = subject.role.fact_type.all_fact_type_shape.to_a[0]
                 when 'ModelNoteShape'
                   # REVISIT: Add model notes
                 when 'ObjectTypeShape'
@@ -1445,7 +1442,7 @@ module ActiveFacts
         offs_y = -12
         if fact_type.entity_type
           offs_x -= 12
-          offs_y -= 9 if !fact_type.entity_type.is_implied_by_objectification
+          offs_y -= 9 if !fact_type.entity_type.concept.implication_rule # .implication_rule_name == 'objectification'
         end
 
         location = convert_location(bounds, Gravity::S, offs_x, offs_y)

data/lib/activefacts/persistence/index.rb

@@ -173,7 +173,7 @@ module ActiveFacts
 
         debug :index, "All Indices in #{name}:" do
           @indices = columns_by_unique_constraint.map do |uc, columns_with_ordinal|
-            debug :index, "Index due to uc #{uc.guid} on #{name} over (#{columns_with_ordinal.sort_by{|onc|onc[0]}.map{|ca| ca[2].name}.inspect})"
+            debug :index, "Index due to uc #{uc.concept.guid} on #{name} over (#{columns_with_ordinal.sort_by{|onc|onc[0]}.map{|ca| ca[2].name}.inspect})"
             columns = columns_with_ordinal.sort_by{|ca| [ca[0,2], ca[2].name]}.map{|ca| ca[2]}
             absorption_level = columns.map(&:absorption_level).min
             over = columns[0].references[absorption_level].from

data/lib/activefacts/persistence/reference.rb

@@ -217,7 +217,7 @@ module ActiveFacts
   end
 
   module Metamodel          #:nodoc:
-    class ObjectType < Concept
+    class ObjectType
       # Say whether the independence of this object is still under consideration
       # This is used in detecting dependency cycles, such as occurs in the Metamodel
       attr_accessor :tentative          #:nodoc:
@@ -273,7 +273,10 @@ module ActiveFacts
         all_role.each do |role|
           # It's possible that this role is in an implicit or derived fact type. Skip it if so.
           next if role.fact_type.is_a?(LinkFactType) or
-            role.fact_type.preferred_reading.role_sequence.all_role_ref.to_a[0].play
+	    # REVISIT: dafuq? Is this looking for a constraint over a derivation? This looks wrong.
+            role.fact_type.preferred_reading.role_sequence.all_role_ref.to_a[0].play or
+	    # This is not yet actually set, and wouldn't handle constraint derivations anyhow:
+	    role.variable_as_projection
           
           populate_reference role
         end

data/lib/activefacts/version.rb

@@ -6,9 +6,9 @@
 #
 module ActiveFacts
   module Version
-    MAJOR = 0
-    MINOR = 8
-    PATCH = 18
+    MAJOR = 1
+    MINOR = 0
+    PATCH = 0
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end

data/lib/activefacts/vocabulary/extensions.rb

@@ -88,6 +88,18 @@ module ActiveFacts
         preferred_reading.expand(frequency_constraints, define_role_names)
       end
 
+      # Does any role of this fact type participate in a preferred identifier?
+      def is_existential
+	return false if all_role.size > 2
+	all_role.detect do |role|
+	  role.all_role_ref.detect do |rr|
+	    rr.role_sequence.all_presence_constraint.detect do |pc|
+	      pc.is_preferred_identifier
+	    end
+	  end
+	end
+      end
+
       def internal_presence_constraints
         all_role.map do |r|
           r.all_role_ref.map do |rr|
@@ -100,7 +112,7 @@ module ActiveFacts
 
       def implicit_boolean_type vocabulary
         @constellation.ImplicitBooleanValueType[[vocabulary.identifying_role_values, "_ImplicitBooleanValueType"]] ||
-        @constellation.ImplicitBooleanValueType(vocabulary.identifying_role_values, "_ImplicitBooleanValueType", :guid => :new)
+        @constellation.ImplicitBooleanValueType(vocabulary.identifying_role_values, "_ImplicitBooleanValueType", :concept => :new)
       end
 
       # This entity type has just objectified a fact type. Create the necessary ImplicitFactTypes with phantom roles
@@ -111,7 +123,7 @@ module ActiveFacts
         # We only do it when the unary fact type is not objectified
         link_fact_type = @constellation.LinkFactType(:new, :implying_role => role)
         entity_type = @entity_type || implicit_boolean_type(role.object_type.vocabulary)
-        phantom_role = @constellation.Role(link_fact_type, 0, :object_type => entity_type, :guid => :new)
+        phantom_role = @constellation.Role(link_fact_type, 0, :object_type => entity_type, :concept => :new)
       end
 
       def reading_preferably_starting_with_role role, negated = false
@@ -125,6 +137,16 @@ module ActiveFacts
       def all_role_in_order
         all_role.sort_by{|r| r.ordinal}
       end
+
+      def compatible_readings types_array
+	all_reading.select do |reading|
+	  ok = true
+	  reading.role_sequence.all_role_ref_in_order.each_with_index do |rr, i|
+	    ok = false unless types_array[i].include?(rr.role.object_type)
+	  end
+	  ok
+	end
+      end
     end
 
     class Role
@@ -183,6 +205,7 @@ module ActiveFacts
       end
 
       def role_name(separator = "-")
+	return 'UNKNOWN' unless role
         name_array =
           if role.fact_type.all_role.size == 1
             if role.fact_type.is_a?(LinkFactType)
@@ -380,12 +403,15 @@ module ActiveFacts
               #pi = supertype.preferred_identifier
               #return nil
             elsif fact_type
+	      possible_pi = nil
               fact_type.all_role.each{|role|
                 role.all_role_ref.each{|role_ref|
                   # Discount role sequences that contain roles not in this fact type:
                   next if role_ref.role_sequence.all_role_ref.detect{|rr| rr.role.fact_type != fact_type }
                   role_ref.role_sequence.all_presence_constraint.each{|pc|
-                    next unless pc.is_preferred_identifier and pc.max_frequency == 1
+		    next unless pc.max_frequency == 1
+		    possible_pi = pc
+                    next unless pc.is_preferred_identifier
                     pi = pc
                     break
                   }
@@ -393,6 +419,10 @@ module ActiveFacts
                 }
                 break if pi
               }
+	      if !pi && possible_pi
+		debug :pi, "Using existing PC as PI for #{name}"
+		pi = possible_pi
+	      end
             else
               debug :pi, "No PI found for #{name}"
             end
@@ -450,7 +480,7 @@ module ActiveFacts
         fact_type.all_role.map do |role|
           next if role.link_fact_type     # Already exists
           link_fact_type = @constellation.LinkFactType(:new, :implying_role => role)
-          phantom_role = @constellation.Role(link_fact_type, 0, :object_type => self, :guid => :new)
+          phantom_role = @constellation.Role(link_fact_type, 0, :object_type => self, :concept => :new)
           # We could create a copy of the visible external role here, but there's no need yet...
           # Nor is there a need for a presence constraint, readings, etc.
 	  link_fact_type
@@ -482,26 +512,35 @@ module ActiveFacts
 
             expanded.gsub!(/\{#{i}\}/) do
                 role_ref = role_refs[i]
-                player = role_ref.role.object_type
-                role_name = role.role_name
-                role_name = nil if role_name == ""
-                if role_name && define_role_names == false
-                  l_adj = t_adj = nil   # When using role names, don't add adjectives
-                end
-                freq_con = frequency_constraints[i]
-                freq_con = freq_con.frequency if freq_con && freq_con.is_a?(ActiveFacts::Metamodel::PresenceConstraint)
-                if freq_con.is_a?(Array)
-                  freq_con, player_name = *freq_con
-                else
-                  player_name = player.name
-                end
+		if role_ref.role
+		  player = role_ref.role.object_type
+		  role_name = role.role_name
+		  role_name = nil if role_name == ""
+		  if role_name && define_role_names == false
+		    l_adj = t_adj = nil   # When using role names, don't add adjectives
+		  end
+
+		  freq_con = frequency_constraints[i]
+		  freq_con = freq_con.frequency if freq_con && freq_con.is_a?(ActiveFacts::Metamodel::PresenceConstraint)
+		  if freq_con.is_a?(Array)
+		    freq_con, player_name = *freq_con
+		  else
+		    player_name = player.name
+		  end
+		else
+		  # We have an unknown role. The reading cannot be correctly expanded
+		  player_name = "UNKNOWN"
+		  role_name = nil
+		  freq_con = nil
+		end
+
                 literal = literals[i]
                 words = [
                   freq_con ? freq_con : nil,
                   l_adj,
                   define_role_names == false && role_name ? role_name : player_name,
                   t_adj,
-                  define_role_names && role_name && player.name != role_name ? "(as #{role_name})" : nil,
+                  define_role_names && role_name && player_name != role_name ? "(as #{role_name})" : nil,
                   # Can't have both a literal and a value constraint, but we don't enforce that here:
                   literal ? literal : nil
                 ]
@@ -738,7 +777,7 @@ module ActiveFacts
     class Query
       def show
         steps_shown = {}
-        debug :query, "Displaying full contents of Query #{guid}" do
+        debug :query, "Displaying full contents of Query #{concept.guid}" do
           all_variable.sort_by{|jn| jn.ordinal}.each do |variable|
             debug :query, "#{variable.describe}" do
               variable.all_step.
@@ -820,6 +859,7 @@ module ActiveFacts
       # This is only used for debugging, from RoleRef#describe
       class ImplicitReading
         attr_accessor :fact_type, :text
+	attr_reader :is_negative  # Never true
 
         def initialize(fact_type, text)
           @fact_type = fact_type