activefacts-metamodel 1.7.2 → 1.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 255af1969756fd0c43b4a96ff9696734df2f73b0
-  data.tar.gz: 8a46b3345d01ad3ed385fc86721a11304a814715
+  metadata.gz: e18edf07c9d30ebe02c45d63b87d1dabc328bcc0
+  data.tar.gz: 775315e7031db7f4b6f30cdf0efbac0cef5e2547
 SHA512:
-  metadata.gz: 2b253061160435d1a1f87795abe35051b3fae10ecd3d8649782aa2e3be2778c3ecddc8d8dddca3fc90d79ffa56a2b25c0767dd904abc1192bacc524bcc07603f
-  data.tar.gz: f3cdadbe305c6aadbbc92952f88ac46014e0216fb9032f7d6bac33928d9925d553f342b019d46847f9b5db8d7e3c0e176619cb699a3df3ff96d72c979f96608a
+  metadata.gz: 37f78ca38e9bfa027e90114db134f23b022ae0bb6d8b45f28460cb63ce4d728a54df61f9d0fe104ad55a5b80a8b8c776fd4dd70b24e863144c55f3911d0c519c
+  data.tar.gz: 1efd187a64997af03320b3efb48e068f4ea7ac037bffcf5765e92eded11b88ff1ba136fd196cd6cdf78d0a89b382f6a89485189d2c24e3198a6f2d8a70f9d341

data/.gitignore

@@ -9,3 +9,7 @@
 /tmp/
 bin
 *.swp
+.DS_Store
+*.rej
+*.orig
+*.diff

data/Gemfile

@@ -1,8 +1,9 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in activefacts-metamodel.gemspec
 gemspec
-if ENV['PWD'] =~ %r{\A/Users/cjh/work/activefacts}
+
+if ENV['PWD'] =~ %r{\A#{ENV['HOME']}/work}
+  $stdout.puts "Using work area gems for #{File.basename(File.dirname(__FILE__))} from activefacts-metamodel"
   gem 'activefacts-api', path: '/Users/cjh/work/activefacts/api'
   # gem 'activefacts-api', git: 'git://github.com/cjheath/activefacts-api.git'
 end

data/Rakefile

@@ -1,6 +1,23 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "pp"
 
 RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
+
+task :bump do
+  path = File.expand_path('../lib/activefacts/metamodel/version.rb', __FILE__)
+  lines = File.open(path) do |fp| fp.readlines; end
+  File.open(path, "w") do |fp|
+    fp.write(
+      lines.map do |line|
+	line.gsub(/(VERSION *= *"[0-9.]*\.)([0-9]+)"\n/) do
+	  version = "#{$1}#{$2.to_i+1}"
+	  puts "Version bumped to #{version}\""
+	  version+"\"\n"
+	end
+      end*''
+    )
+  end
+end

data/activefacts-metamodel.gemspec

@@ -20,9 +20,9 @@ This gem provides the core representations for the Fact Modeling tools of Active
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.10.a"
+  spec.add_development_dependency "bundler", ">= 1.10", "~> 1.10.6"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec", "~> 3.3"
 
-  spec.add_runtime_dependency "activefacts-api"
+  spec.add_runtime_dependency "activefacts-api", ">= 1.8", "~> 1.8.4"
 end

data/cql/Metamodel.cql

@@ -53,6 +53,17 @@ Coefficient is identified by Numerator and Denominator and Coefficient is precis
 	Coefficient has one Denominator,
 	Coefficient is precise;
 
+Component is identified by Guid where
+	Component has one Guid,
+	Guid is of at most one Component;
+Component projects at most one Name;
+
+Composition is identified by Guid where
+	Composition has one Guid,
+	Guid is of at most one Composition;
+Composition is called one Name,
+	Name is of at most one Composition;
+
 Concept is identified by Guid where
 	Concept has one Guid,
 	Guid is of at most one Concept;
@@ -75,6 +86,8 @@ Context Note has one Discussion,
 Context Note applies to at most one relevant-Concept,
 	Concept has Context Note;
 
+Discriminator is a kind of Component;
+
 Enforcement is identified by Constraint where
 	Constraint requires at most one Enforcement,
 	Enforcement applies to one Constraint;
@@ -92,6 +105,8 @@ Fact is of one Fact Type;
 Implication Rule is identified by its Name;
 Concept is implied by at most one Implication Rule;
 
+Indicator is a kind of Component;
+
 Instance is identified by Concept where
 	Instance is an instance of one Concept;
 Instance objectifies at most one Fact,
@@ -103,6 +118,10 @@ Location is identified by X and Y where
 	Location is at one X,
 	Location is at one Y;
 
+Mapping is a kind of Component;
+Mapping (as Parent) contains Component (as Member) [acyclic, stronglyintransitive],
+	Member belongs to at most one Parent;
+
 Presence Constraint is a kind of Constraint;
 Presence Constraint has at most one max-Frequency restricted to {1..};
 Presence Constraint has at most one min-Frequency restricted to {2..};
@@ -128,6 +147,7 @@ Role is identified by Fact Type and Ordinal where
 	Fact Type contains Role,
 	Role fills one Ordinal,
 	Ordinal applies to Role;
+Indicator indicates one Role played;
 Link Fact Type has one implying-Role,
 	implying-Role implies at most one Link Fact Type;
 Ring Constraint has at most one other-Role,
@@ -154,6 +174,8 @@ Role Value is identified by Fact and Role where
 Instance plays Role Value,
 	Role Value is of one Instance;
 
+Scoping is a kind of Mapping;
+
 Set Constraint is a kind of Constraint;
 
 Shape is identified by Guid where
@@ -229,6 +251,12 @@ Vocabulary contains Constraint,
 Vocabulary includes Unit,
 	Unit is in one Vocabulary;
 
+Absorption is a kind of Mapping;
+Absorption traverses to one child-Role;
+Absorption traverses from one parent-Role;
+Absorption is matched by at most one reverse-Absorption;
+Absorption flattens;
+
 Aggregation is where
 	Variable is bound to Aggregate over aggregated-Variable,
 	Aggregate of aggregated-Variable is bound as one Variable;
@@ -244,6 +272,12 @@ Bound is identified by Value and Bound is inclusive where
 	Value is of at least one Bound,
 	Bound is inclusive;
 
+Composite is identified by Mapping where
+	Mapping projects at most one Composite,
+	Composite consists of one Mapping;
+Composition contains Composite,
+	Composite belongs to one Composition;
+
 Constraint Shape is a kind of Shape;
 Constraint Shape is for one Constraint;
 
@@ -266,15 +300,30 @@ Diagram is identified by Vocabulary and Name where
 	Diagram is called one Name,
 	Name is of Diagram;
 
+Discriminated Role is where
+	Discriminator distinguishes Role using one Value,
+	Role is indicated by Value for Discriminator;
+
 Fact Type Shape is a kind of Shape;
 Fact Type Shape has at most one Display Role Names Setting;
 Fact Type Shape is for one Fact Type,
 	Fact Type has Fact Type Shape;
 Fact Type Shape has at most one Rotation Setting;
 
+Injection is a kind of Mapping;
+
+Mirror Role is a kind of Role;
+Mirror Role is for at most one Role (as Base Role),
+	Base Role implies at most one Mirror Role;
+
 Model Note Shape is a kind of Shape;
 Model Note Shape is for one Context Note;
 
+Nesting is where
+	Absorption is nested under index-Role in Ordinal position,
+	Absorption in Ordinal position is nested under one Role,
+	Role keys nesting of Absorption at Ordinal priority;
+
 ORM Diagram is a kind of Diagram;
 Shape is in one ORM Diagram,
 	ORM Diagram includes Shape;
@@ -283,6 +332,7 @@ Object Type is identified by Vocabulary and Name where
 	Object Type belongs to one Vocabulary,
 	Object Type is called one Name;
 Instance is of one Object Type;
+Mapping represents one Object Type;
 Object Type is an instance of one Concept;
 Object Type uses at most one Pronoun;
 Object Type plays Role,
@@ -374,8 +424,8 @@ Allowed Range is where
 Domain Object Type is a kind of Object Type;
 
 Entity Type is a kind of Domain Object Type;
-Entity Type nests at most one Fact Type,
-	Fact Type is nested as at most one Entity Type;
+Entity Type objectifies at most one Fact Type,
+	Fact Type is objectified as at most one Entity Type;
 
 Type Inheritance is a kind of Fact Type identified by Subtype and Supertype where
 	Entity Type (as Subtype) is subtype of super-Entity Type (as Supertype) [acyclic, intransitive],
@@ -408,11 +458,14 @@ Value Type Parameter Restriction is where
 	Value Type Parameter applies to Value Type;
 Value Type Parameter Restriction has one Value;
 
-Implicit Boolean Value Type is a kind of Value Type;
-
 /*
  * Constraints:
  */
+either Component belongs to Mapping(1) or Component is a Mapping(2) that projects Composite but not both;
+for each Component exactly one of these holds:
+	Component is a Mapping,
+	Component is an Indicator,
+	Component is a Discriminator;
 for each Concept exactly one of these holds:
 	Object Type is an instance of Concept,
 	Fact Type is an instance of Concept,
@@ -424,12 +477,18 @@ for each Concept exactly one of these holds:
 	Fact is an instance of Concept,
 	Population is an instance of Concept,
 	Query is an instance of Concept;
+either Constraint Shape is a Ring Constraint Shape or Constraint Shape is a Value Constraint Shape but not both;
 for each Constraint exactly one of these holds:
 	Constraint is a Set Constraint,
 	Constraint is a Presence Constraint,
 	Constraint is a Ring Constraint,
 	Constraint is a Value Constraint;
 either Domain Object Type is a Value Type or Domain Object Type is an Entity Type but not both;
+for each Mapping exactly one of these holds:
+	Mapping is an Absorption,
+	Mapping is an Injection,
+	Mapping is a Scoping,
+	Mapping projects Composite;
 for each Role Sequence exactly one of these holds:
 	Role Sequence is for Reading,
 	Presence Constraint covers Role Sequence,
@@ -451,6 +510,9 @@ either Unit is fundamental or Unit is derived from base-Unit but not both;
 either Value Constraint Shape is for Object Type Shape or Value Constraint Shape is for Role Display but not both;
 either Value Constraint allows Value Range or Value Constraint requires matching Regular Expression but not both;
 either Value Constraint constrains Value Type or Value Constraint applies to Role but not both;
+for each Mapping at most one of these holds:
+	Mapping is an Absorption that flattens,
+	Mapping projects Composite;
 for each Instance at most one of these holds:
 	Instance has Value,
 	Instance objectifies Fact;
@@ -466,19 +528,32 @@ Step specifies Fact Type that contains Role
 Variable is for Object Type that plays Role
 	if and only if
 	Variable is restricted by Role of Step;
+/*
+Absorption traverses from parent Role that is played by Object Type and Mapping(1) is a kind of Component(2) and Mapping(1) is an Absorption
+	only if Member belongs to Mapping(2) that represents Object Type;
+Absorption traverses to child Role that is played by Object Type and Absorption is a kind of Mapping(2)
+	only if Mapping(1) represents Object Type;
+*/
 Presence Constraint is preferred identifier
 	only if Presence Constraint has max Frequency;
 Value Type has Scale
 	only if Value Type has Length;
 Variable matches nesting over Step
 	only if Variable is for Object Type and Step specifies Fact Type;
+each Absorption(1) occurs at most one time in
+	Absorption(2) is matched by reverse Absorption(1);
 either Agreement was reached by Agent or Agreement was on Date;
+// either Component projects Name or Component is some Absorption that flattens;
 each Concept occurs at most one time in
 	Object Type is an instance of Concept;
 each Concept occurs at most one time in
 	Population is an instance of Concept;
 each Concept occurs at most one time in
 	Role is an instance of Concept;
+each Discriminator occurs at least 2 times in
+	Discriminator distinguishes Role using Value;
+each combination Discriminator, Value occurs one time in
+	Discriminator distinguishes Role using Value;
 each combination Entity Type(1), Type Inheritance occurs at most one time in
 	Entity Type(1) is subtype of super Entity Type(2),
 	Type Inheritance provides identification;
@@ -500,68 +575,3 @@ each combination Vocabulary, Name occurs at most one time in
 each combination Vocabulary, Name occurs at most one time in
 	Unit is in Vocabulary,
 	Unit is called Name;
-
-/*
- * Compositions
- */
-Component is identified by Guid where
-	Component has one Guid,
-	Guid is of at most one Component;
-Component projects at most one Name;
-
-Composition is identified by Guid where
-	Composition has one Guid,
-	Guid is of at most one Composition;
-Composition is called one Name,
-	Name is of at most one Composition;
-
-Discriminator is a kind of Component;
-
-Indicator is a kind of Component;
-Indicator indicates one Role played;
-
-Mapping is a kind of Component;
-Mapping contains Component (as Member) [acyclic, stronglyintransitive],
-	Member belongs to at most one parent-Mapping;
-Mapping represents one Object Type;
-
-Nesting is a kind of Mapping;
-
-Absorption is a kind of Mapping;
-Absorption traverses to one child-Role;
-Absorption is nested under at most one index-Role;
-Absorption traverses from one parent-Role;
-Absorption flattens;
-
-Composite is identified by Mapping where
-	Mapping projects at most one Composite,
-	Composite consists of one Mapping;
-Composition contains Composite,
-	Composite belongs to one Composition;
-
-Discriminated Role is where
-	Discriminator distinguishes Role using one Value,
-	Role is indicated by Value for Discriminator;
-
-Injection is a kind of Mapping;
-for each Component exactly one of these holds:
-	that Component is a Mapping,
-	that Component is an Indicator,
-	that Component is a Discriminator;
-either Component is a Mapping(2) that projects some Composite or Component belongs to parent Mapping(1) but not both;
-for each Mapping exactly one of these holds:
-	that Mapping is an Absorption,
-	that Mapping is an Injection,
-	that Mapping is a Nesting,
-	that Mapping projects some Composite;
-for each Mapping at most one of these holds:
-	that Mapping projects some Composite,
-	that Mapping is an Absorption and that Absorption flattens;
-some Mapping represents some Object Type
-	if and only if
-	that Mapping is an Absorption that traverses to some child- Role and that Role is played by that Object Type;
-either Component projects some Name or that Component flattens;
-each Discriminator occurs at least 2 times in
-	Discriminator distinguishes Role using Value;
-each combination Discriminator, Value occurs one time in
-	Discriminator distinguishes Role using Value;

data/lib/activefacts/metamodel/extensions.rb

@@ -232,27 +232,10 @@ module ActiveFacts
         end.flatten.compact.uniq
       end
 
-      def implicit_boolean_type vocabulary
-        @constellation.ImplicitBooleanValueType[[vocabulary.identifying_role_values, "_ImplicitBooleanValueType"]] or
-        @constellation.ImplicitBooleanValueType(vocabulary.identifying_role_values, "_ImplicitBooleanValueType", :concept => [:new, :implication_rule => 'unary'])
-      end
-
-      # This entity type has just objectified a fact type. Create the necessary ImplicitFactTypes with phantom roles
-      def create_implicit_fact_type_for_unary
-        role = all_role.single
-        return if role.link_fact_type     # Already exists
-        # NORMA doesn't create an implicit fact type here, rather the fact type has an implicit extra role, so looks like a binary
-        # We only do it when the unary fact type is not objectified
-        link_fact_type = @constellation.LinkFactType(:new, :implying_role => role)
-        link_fact_type.concept.implication_rule = 'unary'
-        entity_type = @entity_type || implicit_boolean_type(role.object_type.vocabulary)
-        phantom_role = @constellation.Role(link_fact_type, 0, :object_type => entity_type, :concept => :new)
-      end
-
       def reading_preferably_starting_with_role role, negated = false
         all_reading_by_ordinal.detect do |reading|
-          reading.text =~ /\{\d\}/ and
-            reading.role_sequence.all_role_ref_in_order[$1.to_i].role == role and
+          reading.text =~ /\{(\d+)\}/ and
+            reading.role_sequence.all_role_ref_in_order[$1.to_i].role.base_role == role and
             reading.is_negative == !!negated
         end || preferred_reading(negated)
       end
@@ -273,28 +256,19 @@ module ActiveFacts
     end
 
     class Role
-      def describe(highlight = nil)
-        object_type.name + (self == highlight ? "*" : "")
+      # Mirror Role defines this, but it's more convenient not to have to type-check.
+      # A Role that's not a Mirror Role is its own base role.
+      def base_role
+	self
       end
 
-      # Find any internal uniqueness constraint on this role only
-      def uniqueness_constraint
-        all_role_ref.detect{|rr|
-          rs = rr.role_sequence
-          rs.all_role_ref.size == 1 and
-          rs.all_presence_constraint.each{|pc|
-            return pc if pc.max_frequency == 1
-          }
-        }
-	nil
-      end
-
-      # Is there are internal uniqueness constraint on this role only?
-      def unique
-	uniqueness_constraint ? true : false
+      def describe(highlight = nil)
+        object_type.name + (self == highlight ? "*" : "")
       end
 
       def is_mandatory
+	# REVISIT: An objectification role is always mandatory
+	# REVISIT: Handle mirror roles
         return fact_type.implying_role.is_mandatory if fact_type.is_a?(LinkFactType)
         all_role_ref.detect{|rr|
           rs = rr.role_sequence
@@ -312,18 +286,31 @@ module ActiveFacts
       # Return true if this role is functional (has only one instance wrt its player)
       # A role in an objectified fact type is deemed to refer to the implicit role of the objectification.
       def is_functional
+	# REVISIT: Handle mirror and objectification roles
         fact_type.entity_type or
         fact_type.all_role.size != 2 or
-        is_unique
+        uniqueness_constraint
       end
 
-      def is_unique
-        all_role_ref.detect do |rr|
-          rr.role_sequence.all_role_ref.size == 1 and
-            rr.role_sequence.all_presence_constraint.detect do |pc|
+      # Find any internal uniqueness constraint on this role only
+      def uniqueness_constraint
+        base_role.all_role_ref.detect{|rr|
+          rs = rr.role_sequence
+          rs.all_role_ref.size == 1 and
+            rs.all_presence_constraint.detect do |pc|
               pc.max_frequency == 1 and !pc.enforcement   # Alethic uniqueness constraint
             end
-        end
+        }
+      end
+
+      # Is there are internal uniqueness constraint on this role only?
+      def is_unique
+	# REVISIT: Handle objectification roles
+	uniqueness_constraint ? true : false
+      end
+
+      def unique
+	raise "REVISIT: unique is deprecated. Call is_unique instead"
       end
 
       def name
@@ -346,7 +333,7 @@ module ActiveFacts
         name_array =
           if role.fact_type.all_role.size == 1
             if role.fact_type.is_a?(LinkFactType)
-              "#{role.object_type.name} phantom for #{role.fact_type.role.object_type.name}"
+              "#{role.object_type.name} objectification role for #{role.fact_type.role.object_type.name}"
             else
               role.fact_type.preferred_reading.text.gsub(/\{[0-9]\}/,'').strip.split(/\s/)
             end
@@ -516,7 +503,7 @@ module ActiveFacts
               all_supertypes = supertypes_transitive
               trace :pi, "PI roles must be played by one of #{all_supertypes.map(&:name)*", "}" if all_supertypes.size > 1
               all_role.each{|role|
-                  next unless role.unique || fact_type
+                  next unless role.is_unique || fact_type
                   ftroles = Array(role.fact_type.all_role)
 
                   # Skip roles in ternary and higher fact types, they're objectified, and in unaries, they can't identify us.
@@ -604,7 +591,7 @@ module ActiveFacts
                 pi = possible_pi
               end
             else
-              byebug
+              debugger
               trace :pi, "No PI found for #{name}"
             end
           end
@@ -663,15 +650,69 @@ module ActiveFacts
         candidates[0] # REVISIT: This might not be the closest supertype
       end
 
-      # This entity type has just objectified a fact type. Create the necessary ImplicitFactTypes with phantom roles
-      def create_implicit_fact_types
+      def add_supertype(supertype, is_identifying_supertype, assimilation)
+	inheritance_fact = constellation.TypeInheritance(self, supertype, :concept => :new)
+
+	inheritance_fact.assimilation = assimilation
+
+	# Create a reading:
+	sub_role = constellation.Role(inheritance_fact, 0, :object_type => self, :concept => :new)
+	super_role = constellation.Role(inheritance_fact, 1, :object_type => supertype, :concept => :new)
+
+	rs = constellation.RoleSequence(:new)
+	constellation.RoleRef(rs, 0, :role => sub_role)
+	constellation.RoleRef(rs, 1, :role => super_role)
+	constellation.Reading(inheritance_fact, 0, :role_sequence => rs, :text => "{0} is a kind of {1}", :is_negative => false)
+
+	rs2 = constellation.RoleSequence(:new)
+	constellation.RoleRef(rs2, 0, :role => super_role)
+	constellation.RoleRef(rs2, 1, :role => sub_role)
+	# Decide in which order to include is a/is an. Provide both, but in order.
+	n = 'aeioh'.include?(sub_role.object_type.name.downcase[0]) ? 'n' : ''
+	constellation.Reading(inheritance_fact, 2, :role_sequence => rs2, :text => "{0} is a#{n} {1}", :is_negative => false)
+
+	if is_identifying_supertype
+	  inheritance_fact.provides_identification = true
+	end
+
+	# Create uniqueness constraints over the subtyping fact type.
+	p1rs = constellation.RoleSequence(:new)
+	constellation.RoleRef(p1rs, 0).role = sub_role
+	pc1 = constellation.PresenceConstraint(:new, :vocabulary => vocabulary)
+	pc1.name = "#{name}MustHaveSupertype#{supertype.name}"
+	pc1.role_sequence = p1rs
+	pc1.is_mandatory = true   # A subtype instance must have a supertype instance
+	pc1.min_frequency = 1
+	pc1.max_frequency = 1
+	pc1.is_preferred_identifier = false
+	trace :constraint, "Made new subtype PC GUID=#{pc1.concept.guid} min=1 max=1 over #{p1rs.describe}"
+
+	p2rs = constellation.RoleSequence(:new)
+	constellation.RoleRef(p2rs, 0).role = super_role
+	pc2 = constellation.PresenceConstraint(:new, :vocabulary => vocabulary)
+	pc2.name = "#{supertype.name}MayBeA#{name}"
+	pc2.role_sequence = p2rs
+	pc2.is_mandatory = false
+	pc2.min_frequency = 0
+	pc2.max_frequency = 1
+	# The supertype role often identifies the subtype:
+	pc2.is_preferred_identifier = inheritance_fact.provides_identification
+	trace :supertype, "identification of #{name} via supertype #{supertype.name} was #{inheritance_fact.provides_identification ? '' : 'not '}added"
+	trace :constraint, "Made new supertype PC GUID=#{pc2.concept.guid} min=1 max=1 over #{p2rs.describe}"
+      end
+
+      # This entity type has just objectified a fact type.
+      # Create the necessary ImplicitFactTypes with objectification and mirror roles
+      def create_link_fact_types
         fact_type.all_role.map do |role|
-          next if role.link_fact_type     # Already exists
+          next if role.mirror_role_as_base_role     # Already exists
           link_fact_type = @constellation.LinkFactType(:new, :implying_role => role)
-          link_fact_type.concept.implication_rule = 'objectification'
-          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.
+          objectification_role = @constellation.Role(link_fact_type, 0, :object_type => self, :concept => :new)
+          mirror_role = @constellation.MirrorRole(link_fact_type, 1, :concept => :new, :object_type => role.object_type, :base_role => role)
+
+          link_fact_type.concept.implication_rule =
+          objectification_role.concept.implication_rule =
+          mirror_role.concept.implication_rule = 'objectification'
           link_fact_type
         end
       end
@@ -968,10 +1009,6 @@ module ActiveFacts
       def is_objectification_step
         !!objectification_variable
       end
-
-      def external_fact_type
-        fact_type.is_a?(LinkFactType) ? fact_type.role.fact_type : fact_type
-      end
     end
 
     class Variable
@@ -1066,99 +1103,50 @@ module ActiveFacts
     end
 
     class LinkFactType
-      def default_reading
-        # There are two cases, where role is in a unary fact type, and where the fact type is objectified
-        # If a unary fact type is objectified, only the LinkFactType for the objectification is asserted
-        if objectification = implying_role.fact_type.entity_type
-          "#{objectification.name} involves #{implying_role.object_type.name}"
-        else
-          implying_role.fact_type.default_reading+" Boolean"  # Must be a unary FT
-        end
+      def all_reading
+	if super.size == 0
+	  # REVISIT: Should we create reading orders independently?
+	  # No user-defined readings have been defined, so it's time to stop being lazy:
+	  objectification_role, mirror_role = *all_role_in_order
+	  rs = constellation.RoleSequence(:new)
+	  rr0 = constellation.RoleRef(rs, 0, :role => objectification_role)
+	  rr1 = constellation.RoleRef(rs, 1, :role => mirror_role)
+	  r0 = constellation.Reading(self, 0, :role_sequence => rs, :text => "{0} involves {1}", :is_negative => false)  # REVISIT: This assumes English!
+	  r1 = constellation.Reading(self, 1, :role_sequence => rs, :text => "{1} is involved in {0}", :is_negative => false)
+	end
+	@all_reading
       end
+    end
 
-      def add_reading implicit_reading
-        @readings ||= []
-        @readings << implicit_reading
+    class MirrorRole
+      def is_mandatory
+	true  # An objectified fact type must have a player for each role
       end
 
-      def all_reading
-        @readings ||=
-          [ ImplicitReading.new(
-              self,
-              implying_role.fact_type.entity_type ? "{0} involves {1}" : implying_role.fact_type.default_reading+" Boolean"
-            )
-          ] +
-          Array(implying_role.fact_type.entity_type ? ImplicitReading.new(self, "{1} is involved in {0}") : nil)
+      def is_unique
+	true  # A mirror role exists is played exactly once for each objectification
       end
 
-      def reading_preferably_starting_with_role role, negated = false
-        all_reading[role == implying_role ? 1 : 0]
+      def is_functional
+	true
       end
 
-      # 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
-          @text = text
-        end
-
-        class ImplicitReadingRoleSequence
-          class ImplicitReadingRoleRef
-            attr_reader :role
-            attr_reader :role_sequence
-            def initialize(role, role_sequence)
-              @role = role
-              @role_sequence = role_sequence
-            end
-            def variable; nil; end
-            def play; nil; end
-            def leading_adjective; nil; end
-            def trailing_adjective; nil; end
-            def describe
-              @role.object_type.name
-            end
-          end
-
-          def initialize roles
-            @role_refs = roles.map{|role| ImplicitReadingRoleRef.new(role, self) }
-          end
-
-          def all_role_ref
-            @role_refs
-          end
-          def all_role_ref_in_order
-            @role_refs
-          end
-          def describe
-            '('+@role_refs.map(&:describe)*', '+')'
-          end
-          def all_reading
-            []
-          end
-        end
-
-        def role_sequence
-          ImplicitReadingRoleSequence.new([@fact_type.implying_role, @fact_type.all_role.single])
-        end
-
-        def ordinal; 0; end
+      def uniqueness_constraint
+	raise "A MirrorRole should not be asked for its uniqueness constraints"
+      end
 
-        def expand
-          text.gsub(/\{([01])\}/) do
-            if $1 == '0'
-              fact_type.all_role[0].object_type.name
-            else
-              fact_type.implying_role.object_type.name
-            end
-          end
-        end
+      %w{all_ring_constraint_as_other_role all_ring_constraint all_role_value role_value_constraint mirror_role_as_base_role
+      }.each do |accessor|
+	define_method(accessor.to_sym) do
+	  base_role.send(accessor.to_sym)
+	end
+	define_method("#{accessor}=".to_sym) do |*a|
+	  raise "REVISIT: It's a bad idea to try to set #{accessor} for a MirrorRole"
+	end
       end
     end
 
-    # Some queries must be over the proximate roles, some over the counterpart roles.
+    # Some queries in constraints must be over the proximate roles, some over the counterpart roles.
     # Return the common superclass of the appropriate roles, and the actual roles
     def self.plays_over roles, options = :both   # Or :proximate, :counterpart
       # If we can stay inside this objectified FT, there's no query:
@@ -1204,7 +1192,8 @@ module ActiveFacts
           if fact_type.entity_type
             objectification_role_supertypes =
               fact_type.entity_type.supertypes_transitive+object_type.supertypes_transitive
-            objectification_role = role.link_fact_type.all_role.single # Find the phantom role here
+	    # Find the objectification role here:
+            objectification_role = role.link_fact_type.all_role.detect{|r| !r.is_a?(MirrorRole)}
           else
             objectification_role_supertypes = counterpart_role_supertypes
             objectification_role = counterpart_role