activefacts 0.8.6 → 0.8.8

data/lib/activefacts/persistence/columns.rb

@@ -143,13 +143,13 @@ module ActiveFacts
       # What's the underlying SQL data type of this column?
       def type
         params = {}
-        restrictions = []
-        return ["BIT", params, restrictions] if references[-1].is_unary   # It's a unary
+        constraints = []
+        return ["BIT", params, constraints] if references[-1].is_unary   # It's a unary
 
-        # Add a role value restriction
-        # REVISIT: Can add join-role-value-restrictions here, if we ever provide a way to define them
-        if references[-1].to_role && references[-1].to_role.role_value_restriction
-          restrictions << references[-1].to_role.role_value_restriction
+        # Add a role value constraint
+        # REVISIT: Can add join-role-value-constraints here, if we ever provide a way to define them
+        if references[-1].to_role && references[-1].to_role.role_value_constraint
+          constraints << references[-1].to_role.role_value_constraint
         end
 
         vt = references[-1].is_self_value ? references[-1].from : references[-1].to
@@ -158,10 +158,10 @@ module ActiveFacts
         while vt.supertype
           params[:length] ||= vt.length if vt.length.to_i != 0
           params[:scale] ||= vt.scale if vt.scale.to_i != 0
-          restrictions << vt.value_restriction if vt.value_restriction
+          constraints << vt.value_constraint if vt.value_constraint
           vt = vt.supertype
         end
-        return [vt.name, params, restrictions]
+        return [vt.name, params, constraints]
       end
 
       # The comment is the readings from the References expressed as a join
@@ -327,11 +327,15 @@ module ActiveFacts
         debug :columns, "All Columns for #{name}" do
           columns = []
           sups = supertypes
+          pi_roles = preferred_identifier.role_sequence.all_role_ref.map{|rr| rr.role}
           references_from.sort_by do |ref|
-            # Put supertypes first, in order, then non-subtype references, then subtypes, otherwise retaining their order:
-            sups.index(ref.to) ||
-              (!ref.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) && references_from.size+references_from.index(ref)) ||
-              references_from.size*2+references_from.index(ref)
+            # Put supertypes first, in order, then PI roles, non-subtype references by name, then subtypes by name:
+            next [0, p] if p = sups.index(ref.to)
+            if !ref.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+              next [1, p] if p = pi_roles.index(ref.to_role)
+              next [2, ref.to_names]
+            end
+            [3, ref.to_names]
           end.each do |ref|
             debug :columns, "Columns absorbed via #{ref}" do
               if (ref.role_type == :supertype)

data/lib/activefacts/persistence/foreignkey.rb

@@ -35,11 +35,14 @@ module ActiveFacts
       # Return an Array of Reference paths for such absorbed FKs
       def all_absorbed_foreign_key_reference_path
         references_from.inject([]) do |array, ref|
-
           if ref.is_simple_reference
-            # This catches references that would be created to secondary supertypes, when absorption is through primary.
-            # There might be other cases where an exclusion like this is needed, but I can't reason it out.
-            next array if TypeInheritance === ref.fact_type && absorbed_via && TypeInheritance === absorbed_via.fact_type
+            if TypeInheritance === ref.fact_type
+              # Ignore references to secondary supertypes, when absorption is through primary.
+              next array if absorbed_via && TypeInheritance === absorbed_via.fact_type
+              # Ignore the case where a subtype is absorbed elsewhere:
+              # REVISIT: Disabled, as this should never happen.
+              # next array if ref.to.absorbed_via != ref.fact_type
+            end
             array << [ref]
           elsif ref.is_absorbing
             ref.to.all_absorbed_foreign_key_reference_path.each{|aref|

data/lib/activefacts/persistence/index.rb

@@ -40,7 +40,7 @@ module ActiveFacts
 
       # The name that was assigned (perhaps implicitly by NORMA)
       def real_name
-        @uniqueness_constraint.name && @uniqueness_constraint.name != '' ? @uniqueness_constraint.name : nil
+        @uniqueness_constraint.name && @uniqueness_constraint.name != '' ? @uniqueness_constraint.name.gsub(' ','') : nil
       end
 
       # This name is either the name explicitly assigned (if any) or is constructed to form a unique index name.
@@ -65,7 +65,7 @@ module ActiveFacts
 
       # The name of a view that can be created to enforce uniqueness over non-null key values
       def view_name
-        "#{over.name}#{on == over ? "" : "In"+on.name}"
+        "#{over.name.gsub(' ','')}#{on == over ? "" : "In"+on.name.gsub(' ','')}"
       end
 
       def to_s  #:nodoc:
@@ -119,7 +119,6 @@ module ActiveFacts
               ref_path.each do |ref|
                 next unless ref.to_role
                 #debug :index2, "Considering #{ref_path.map(&:to_s)*" and "} yielding columns #{all_column_by_ref_path[ref_path].map{|c| c.name(".")}*", "}"
-                #debugger if name == 'VehicleIncident' && ref.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
                 ref.to_role.all_role_ref.each do |role_ref|
                   all_pcs = role_ref.role_sequence.all_presence_constraint
     #puts "pcs over #{ref_path.map{|r| r.to_names}.flatten*"."}: #{role_ref.role_sequence.all_presence_constraint.map(&:describe)*"; "}" if all_pcs.size > 0
@@ -173,7 +172,7 @@ module ActiveFacts
           compact.
           sort_by do |index|
             # Put the indices in a defined order:
-            index.columns.map(&:name)
+            index.columns.map(&:name)+['', index.over.name]
           end
         end
       end

data/lib/activefacts/persistence/reference.rb

@@ -172,7 +172,7 @@ module ActiveFacts
 
       # The reading for the fact type underlying this Reference
       def reading
-        is_self_value ? "#{from.name} has value" : @fact_type.default_reading
+        is_self_value ? "#{from.name} has value" : @fact_type.default_reading([], true) # Include role name defn's
       end
 
       def inspect #:nodoc:
@@ -236,7 +236,7 @@ module ActiveFacts
 
       def populate_references           #:nodoc:
         all_role.each do |role|
-          populate_reference role
+          populate_reference role unless role.fact_type.is_a?(ImplicitFactType)
         end
       end
 
@@ -305,6 +305,9 @@ module ActiveFacts
             if r.to.preferred_identifier.role_sequence.all_role_ref.detect{|rr| rr.role == role}
               debug :references, "EntityType #{name} identifies EntityType #{r.to.name}, so absorbs it"
               r.to.absorbed_via = r
+              # We can't be absorbed into our supertype!
+              # REVISIT: We might need to flip all one-to-ones as well
+              r.to.references_to.clone.map{|q|q.flip if q.to_role.role_type == :subtype }
               r.tabulate
               return
             end

data/lib/activefacts/support.rb

@@ -10,13 +10,26 @@
   $debug_nested = false
   $debug_keys = nil
   $debug_available = {}
+
+  def debug_enabled(args)
+    # Figure out whether this trace is enabled and nests:
+    control = (!args.empty? && Symbol === args[0]) ? args.shift : :all
+    key = control.to_s.sub(/_\Z/, '').to_sym
+    $debug_available[key] ||= key
+    enabled = $debug_nested || $debug_keys[key] || $debug_keys[:all]
+    nesting = control.to_s =~ /_\Z/
+    old_nested = $debug_nested
+    $debug_nested = nesting
+    [(enabled ? 1 : 0), $debug_keys[:all] ? " %-15s"%control : nil, old_nested]
+  end
+
   def debug(*args, &block)
     unless $debug_indent
       # First time, initialise the tracing environment
       $debug_indent = 0
       $debug_keys = {}
       if (e = ENV["DEBUG"])
-        e.split(/[^a-zA-Z0-9]/).each{|k| $debug_keys[k.to_sym] = true }
+        e.split(/[^_a-zA-Z0-9]/).each{|k| $debug_keys[k.to_sym] = true }
         if $debug_keys[:help]
           at_exit {
             $stderr.puts "---\nDebugging keys available: #{$debug_available.keys.map{|s| s.to_s}.sort*", "}"
@@ -25,28 +38,21 @@
       end
     end
 
-    # Figure out whether this trace is enabled and nests:
-    control = (!args.empty? && Symbol === args[0]) ? args.shift : :all
-    key = control.to_s.sub(/_\Z/, '').to_sym
-    $debug_available[key] ||= key
-    enabled = $debug_nested || $debug_keys[key]
-    nesting = control.to_s =~ /_\Z/
-    old_nested = $debug_nested
-    $debug_nested = nesting
+    enabled, show_key, old_nested = debug_enabled(args)
 
     # Emit the message if enabled or a parent is:
-    puts "# "+"  "*$debug_indent + args.join(' ') if args.size > 0 && enabled
+    puts "\##{show_key} "+"  "*$debug_indent + args.join(' ') if args.size > 0 && enabled == 1
 
     if block
       begin
-        $debug_indent += 1 if enabled
-        r = yield       # Return the value of the block
+        $debug_indent += enabled
+        return yield       # Return the value of the block
       ensure
-        $debug_indent -= 1 if enabled
+        $debug_indent -= enabled
         $debug_nesting = old_nested
       end
     else
-      r = enabled     # Return whether enabled
+      r = enabled == 1     # If no block, return whether enabled
     end
     r
   end

data/lib/activefacts/version.rb

@@ -5,5 +5,5 @@
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
 module ActiveFacts
-  VERSION = '0.8.6'
+  VERSION = '0.8.8'
 end

data/lib/activefacts/vocabulary.rb

@@ -6,3 +6,4 @@
 #
 require 'activefacts/vocabulary/metamodel'
 require 'activefacts/vocabulary/extensions'
+require 'activefacts/vocabulary/verbaliser'

data/lib/activefacts/vocabulary/extensions.rb

@@ -23,9 +23,36 @@ module ActiveFacts
         '('+all_role.map{|role| role.describe(highlight) }*", "+')'
       end
 
-      def default_reading(frequency_constraints = [], define_role_names = false)
+      def default_reading(frequency_constraints = [], define_role_names = nil)
         preferred_reading.expand(frequency_constraints, define_role_names)
       end
+
+      def internal_presence_constraints
+        all_role.map do |r|
+          r.all_role_ref.map do |rr|
+            !rr.role_sequence.all_role_ref.detect{|rr1| rr1.role.fact_type != self } ?
+              rr.role_sequence.all_presence_constraint.to_a :
+              []
+          end
+        end.flatten.compact.uniq
+      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
+        next if role.implicit_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
+        implicit_fact_type = @constellation.ImplicitFactType(:new, :role => role)
+        entity_type = @entity_type || @constellation.ImplicitBooleanValueType(role.concept.vocabulary, "_ImplicitBooleanValueType")
+        phantom_role = @constellation.Role(implicit_fact_type, 0, :concept => entity_type)
+      end
+
+      def reading_preferably_starting_with_role role
+        all_reading_by_ordinal.detect do |reading|
+          reading.text =~ /\{\d\}/ and reading.role_sequence.all_role_ref_in_order[$1.to_i].role == role
+        end || preferred_reading
+      end
     end
 
     class Role
@@ -60,54 +87,36 @@ module ActiveFacts
       end
     end
 
-    class Join
-      def column_name(joiner = '-')
-        concept == input_role.concept ? input_role.preferred_reference.role_name(joiner) : Array(concept.name)
-      end
-
-      def describe
-        "#{input_role.fact_type.describe(input_role)}->" +
-          concept.name +
-          (output_role ? "->#{output_role.fact_type.describe(output_role)}":"")
-      end
-    end
-
     class RoleRef
       def describe
-        # The reference traverses the Joins in sequence to the final role:
-        all_join.sort_by{|jp| jp.join_step}.map{ |jp| jp.describe + "." }*"" + role_name
+        role_name + (join_node ? " JN#{join_node.ordinal}" : '')
       end
 
       def role_name(joiner = "-")
         name_array =
           if role.fact_type.all_role.size == 1
-            role.fact_type.preferred_reading.text.gsub(/\{[0-9]\}/,'').strip.split(/\s/)
+            if role.fact_type.is_a?(ImplicitFactType)
+              "#{role.concept.name} phantom for #{role.fact_type.role.concept.name}"
+            else
+              role.fact_type.preferred_reading.text.gsub(/\{[0-9]\}/,'').strip.split(/\s/)
+            end
           else
             role.role_name || [leading_adjective, role.concept.name, trailing_adjective].compact.map{|w| w.split(/\s/)}.flatten
           end
         return joiner ? Array(name_array)*joiner : Array(name_array)
       end
-
-      # Two RoleRefs are equal if they have the same role and Joins with matching roles
-      def ==(role_ref)
-        role_ref.is_a?(ActiveFacts::Metamodel::RoleRef) &&
-        role_ref.role == role &&
-        all_join.size == role_ref.all_join.size &&
-        !all_join.sort_by{|j|j.join_step}.
-          zip(role_ref.all_join.sort_by{|j|j.join_step}).
-          detect{|j1,j2|
-            j1.input_role != j2.input_role ||
-            j1.output_role != j2.output_role
-          }
-      end
     end
 
     class RoleSequence
-      def describe
+      def describe(highlighted_role_ref = nil)
         "("+
-          all_role_ref.sort_by{|rr| rr.ordinal}.map{|rr| rr.describe }*", "+
+          all_role_ref.sort_by{|rr| rr.ordinal}.map{|rr| rr.describe + (highlighted_role_ref == rr ? '*' : '') }*", "+
         ")"
       end
+
+      def all_role_ref_in_order
+        all_role_ref.sort_by{|rr| rr.ordinal}
+      end
     end
 
     class ValueType
@@ -118,6 +127,10 @@ module ActiveFacts
       def subtypes
         all_value_type_as_supertype
       end
+
+      def subtypes_transitive
+        [self] + subtypes.map{|st| st.subtypes_transitive}.flatten
+      end
     end
 
     class EntityType
@@ -268,6 +281,10 @@ module ActiveFacts
         all_type_inheritance_as_supertype.map{|ti| ti.subtype }
       end
 
+      def subtypes_transitive
+        [self] + subtypes.map{|st| st.subtypes_transitive}.flatten.uniq
+      end
+
       def all_supertype_inheritance
         all_type_inheritance_as_subtype.sort_by{|ti|
             [ti.provides_identification ? 0 : 1, ti.supertype.name]
@@ -284,7 +301,6 @@ module ActiveFacts
       # An array of self followed by all supertypes in order:
       def supertypes_transitive
         ([self] + all_type_inheritance_as_subtype.map{|ti|
-            # debug ti.class.roles.verbalise; exit
             ti.supertype.supertypes_transitive
           }).flatten.uniq
       end
@@ -301,6 +317,17 @@ module ActiveFacts
         debug "Failed to find identifying supertype of #{name}"
         return nil
       end
+
+      # This entity type has just objectified a fact type. Create the necessary ImplicitFactTypes with phantom roles
+      def create_implicit_fact_types
+        fact_type.all_role.each do |role|
+          next if role.implicit_fact_type     # Already exists
+          implicit_fact_type = @constellation.ImplicitFactType(:new, :role => role)
+          phantom_role = @constellation.Role(implicit_fact_type, 0, :concept => self)
+          # 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.
+        end
+      end
     end
 
     class Reading
@@ -312,21 +339,21 @@ module ActiveFacts
       # REVISIT: This should probably be changed to be the fact role sequence.
       #
       # define_role_names here is false (use defined names), true (define names) or nil (neither)
-      def expand(frequency_constraints = [], define_role_names = false, literals = [])
+      def expand(frequency_constraints = [], define_role_names = nil, literals = [], &subscript_block)
         expanded = "#{text}"
         role_refs = role_sequence.all_role_ref.sort_by{|role_ref| role_ref.ordinal}
         (0...role_refs.size).each{|i|
             role_ref = role_refs[i]
             role = role_ref.role
-            la = "#{role_ref.leading_adjective}"
-            la.sub!(/(.\b|.\Z)/, '\1-')
+            la = "#{role_ref.leading_adjective}".sub(/(.\b|.\Z)/, '\1-').sub(/- /,'-  ')
             la = nil if la == ""
-            ta = "#{role_ref.trailing_adjective}"
-            ta.sub!(/(\b.|\A.)/, '-\1')
+            # Double the space to compensate for space removed below
+            ta = "#{role_ref.trailing_adjective}".sub(/(\b.|\A.)/, '-\1').sub(/ -/,'  -')
             ta = nil if ta == ""
 
             expanded.gsub!(/\{#{i}\}/) {
-                player = role_refs[i].role.concept
+                role_ref = role_refs[i]
+                player = role_ref.role.concept
                 role_name = role.role_name
                 role_name = nil if role_name == ""
                 if role_name && define_role_names == false
@@ -346,12 +373,13 @@ module ActiveFacts
                   define_role_names == false && role_name ? role_name : player_name,
                   ta,
                   define_role_names && role_name && player.name != role_name ? "(as #{role_name})" : nil,
-                  # Can't have both a literal and a restriction, but we don't enforce that here:
+                  # Can't have both a literal and a value constraint, but we don't enforce that here:
                   literal ? literal : nil
-                ].compact*" "
+                ].compact*" " +
+                  (subscript_block ? subscript_block.call(role_ref) : "")
             }
         }
-        expanded.gsub!(/ *- */, '-')      # Remove spaces around adjectives
+        expanded.gsub!(/ ?- ?/, '-')        # Remove single spaces around adjectives
         #debug "Expanded '#{expanded}' using #{frequency_constraints.inspect}"
         expanded
       end
@@ -370,7 +398,7 @@ module ActiveFacts
       end
     end
 
-    class ValueRestriction
+    class ValueConstraint
       def describe
         "restricted to {"+
           all_allowed_range_sorted.map{|ar| ar.to_s(false) }*", "+
@@ -444,11 +472,13 @@ module ActiveFacts
             ((min && min > 0 && min != max) ? "at least #{min == 1 ? "one" : min.to_s}" : nil),
             ((max && min != max) ? "at most #{max == 1 ? "one" : max.to_s}" : nil),
             ((max && min == max) ? "#{max == 1 ? "one" : max.to_s}" : nil)
-        ].compact * " and"
+        ].compact * " and "
       end
 
       def describe
-        role_sequence.describe + " occurs " + frequency + " time"
+        min = min_frequency
+        max = max_frequency
+        role_sequence.describe + " occurs " + frequency + " time#{(min&&min>1)||(max&&max>1) ? 's' : ''}"
       end
     end
 
@@ -458,5 +488,259 @@ module ActiveFacts
       end
     end
 
+    class JoinStep
+      def describe
+        input_role_ref = input_join_node.all_role_ref.detect{|rr| rr.role.fact_type == fact_type}
+        output_role_ref = output_join_node.all_role_ref.detect{|rr| rr.role.fact_type == fact_type}
+        "from node #{input_join_node.ordinal} #{input_role_ref ? input_role_ref.role.concept.name : input_join_node.concept.name}"+
+        " to node #{output_join_node.ordinal} #{output_role_ref ? output_role_ref.role.concept.name : output_join_node.concept.name}"+
+        ": #{is_anti && 'not '}#{is_outer && 'maybe '}#{fact_type.default_reading}"
+      end
+
+      def is_unary_step
+        # Preserve this in case we have to use a real join_node for the phantom
+        # input_join_node.all_role_ref.detect{|rr| rr.role.fact_type.is_a?(ImplicitFactType) && rr.role.fact_type.role.fact_type.all_role.size == 1 }
+        input_join_node == output_join_node
+      end
+
+      def is_objectification_step
+        fact_type.is_a?(ImplicitFactType)
+      end
+    end
+
+    class JoinNode
+      def describe
+        concept.name
+      end
+    end
+
+    class Join
+      def show
+        debug :join, "Displaying full contents of Join #{join_id}" do
+          all_join_node.sort_by{|jn| jn.ordinal}.each do |join_node|
+            debug :join, "Node #{join_node.ordinal} for #{join_node.concept.name}" do
+              (join_node.all_join_step_as_input_join_node.to_a +
+                join_node.all_join_step_as_output_join_node.to_a).
+                uniq.
+                each do |join_step|
+                  debug :join, "#{
+                      join_step.is_unary_step ? 'unary ' : ''
+                    }#{
+                      join_step.is_objectification_step ? 'objectification ' : ''
+                    }step #{join_step.describe}"
+                end
+              join_node.all_role_ref.each do |role_ref|
+                debug :join, "reference #{role_ref.describe} in '#{role_ref.role.fact_type.default_reading}' over #{role_ref.role_sequence.describe}#{role_ref.role_sequence == role_sequence ? ' (projected)' : ''}"
+              end
+            end
+          end
+        end
+      end
+
+      def validate
+        show
+        return
+
+        # Check all parts of this join for validity
+        jns = all_join_node.sort_by{|jn| jn.ordinal}
+        jns.each_with_index do |jn, i|
+          raise "Join node #{i} should have ordinal #{jn.ordinal}" unless jn.ordinal == i
+        end
+
+        # Check the join nodes:
+        steps = []
+        jns.each_with_index do |join_node, i|
+          raise "Join Node #{i} has missing concept" unless join_node.concept
+          if join_node.all_role_ref.detect{|rr| rr.role.concept != join_node.concept }
+            raise "All role references for join node #{join_node.ordinal} should be for #{
+                join_node.concept.name
+              } but we have #{
+                (join_node.all_role_ref.map{|rr| rr.role.concept.name}-[join_node.concept.name]).uniq*', '
+              }"
+          end
+          steps += join_node.all_join_step_as_input_join_node.to_a
+          steps += join_node.all_join_step_as_output_join_node.to_a
+
+          # REVISIT: All Role References must be in a role sequence that covers one fact type exactly (why?)
+          # REVISIT: All such role references must have a join node in this join. (why?)
+        end
+
+        # Check the join steps:
+        steps.uniq!
+        steps.each_with_index do |join_step, i|
+          raise "Join Step #{i} has missing fact type" unless join_step.fact_type
+          raise "Join Step #{i} has missing input node" unless join_step.input_join_node
+          raise "Join Step #{i} has missing output node" unless join_step.output_join_node
+          debugger
+          p join_step.fact_type.default_reading
+          p join_step.input_join_node.all_role_ref.map(&:describe)
+          p join_step.output_join_node.all_role_ref.map(&:describe)
+=begin
+          unless join_step.input_join_node.all_role_ref.
+              detect do |rr|
+                rr.role.fact_type == join_step.fact_type
+                or rr.role.fact_type.is_a?(ImplicitFactType) && rr.role.fact_type.role.fact_type == rr.join_step.concept
+              end
+            raise "Join Step #{join_step.describe} has nodes not matching its fact type"
+          end
+=end
+        end
+
+        # REVISIT: Do a connectivity check
+      end
+    end
+
+    class ImplicitFactType
+      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 ImplicitFactType for the objectification is asserted
+        if objectification = role.fact_type.entity_type
+          "#{objectification.name} involves #{role.concept.name}"
+        else
+          role.fact_type.default_reading+" Boolean"  # Must be a unary FT
+        end
+      end
+
+      # This is only used for debugging, from RoleRef#describe
+      class ImplicitReading
+        attr_accessor :fact_type, :text
+
+        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 join_node; nil; end
+            def leading_adjective; nil; end
+            def trailing_adjective; nil; end
+            def describe
+              @role.concept.name
+            end
+          end
+
+          def initialize roles
+            @role_refs = roles.map{|role| ImplicitReadingRoleRef.new(role, self) }
+          end
+
+          def all_role_ref
+            @role_refs
+          end
+          def describe
+            '('+@role_refs.map(&:describe)*', '+')'
+          end
+          def all_reading
+            []
+          end
+        end
+
+        def role_sequence
+          ImplicitReadingRoleSequence.new([@fact_type.role, @fact_type.all_role.single])
+        end
+
+        def ordinal; 0; end
+      end
+
+      def all_reading
+        [@reading ||= ImplicitReading.new(
+          self,
+          role.fact_type.entity_type ? "{0} involves {1}" : role.fact_type.default_reading+" Boolean"
+        )]
+      end
+    end
+
+    # Some joins 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.join_roles_over roles, options = :both   # Or :proximate, :counterpart
+      # If we can stay inside this objectified FT, there's no join:
+      roles = Array(roles)  # To be safe, in case we get a role collection proxy
+      return nil if roles.size == 1 or
+        options != :counterpart && roles.map{|role| role.fact_type}.uniq.size == 1
+      proximate_sups, counterpart_sups, obj_sups, counterpart_roles, objectification_roles =
+        *roles.inject(nil) do |d_c_o, role|
+          concept = role.concept
+          fact_type = role.fact_type
+
+          proximate_role_supertypes = concept.supertypes_transitive
+
+          # A role in an objectified fact type may indicate either the objectification or the counterpart player.
+          # This could be ambiguous. Figure out both and prefer the counterpart over the objectification.
+          counterpart_role_supertypes =
+            if fact_type.all_role.size > 2
+              possible_roles = fact_type.all_role.select{|r| d_c_o && d_c_o[1].include?(r.concept) }
+              if possible_roles.size == 1 # Only one candidate matches the types of the possible join nodes
+                counterpart_role = possible_roles[0]
+                d_c_o[1]  # No change
+              else
+                # puts "#{constraint_type} #{name}: Awkward, try counterpart-role join on a >2ary '#{fact_type.default_reading}'"
+                # Try all roles; hopefully we don't have two roles with a matching candidate here:
+                # Find which role is compatible with the existing supertypes, if any
+                if d_c_o
+                  st = nil
+                  counterpart_role =
+                    fact_type.all_role.detect{|r| ((st = r.concept.supertypes_transitive) & d_c_o[1]).size > 0}
+                  st
+                else
+                  counterpart_role = nil  # This can't work, we don't have any basis for a decision (must be objectification)
+                  []
+                end
+                #fact_type.all_role.map{|r| r.concept.supertypes_transitive}.flatten.uniq
+              end
+            else
+              # Get the supertypes of the counterpart role (care with unaries):
+              ftr = role.fact_type.all_role.to_a
+              (counterpart_role = ftr[0] == role ? ftr[-1] : ftr[0]).concept.supertypes_transitive
+            end
+
+          if fact_type.entity_type
+            objectification_role_supertypes =
+              fact_type.entity_type.supertypes_transitive+concept.supertypes_transitive
+            objectification_role = role.implicit_fact_type.all_role.single # Find the phantom role here
+          else
+            objectification_role_supertypes = counterpart_role_supertypes
+            objectification_role = nil
+          end
+
+          if !d_c_o
+            d_c_o = [proximate_role_supertypes, counterpart_role_supertypes, objectification_role_supertypes, [counterpart_role], [objectification_role]]
+            #puts "role player supertypes starts #{d_c_o.map{|dco| dco.map(&:name).inspect}*' or '}"
+          else
+            #puts "continues #{[proximate_role_supertypes, counterpart_role_supertypes, objectification_role_supertypes]map{|dco| dco.map(&:name).inspect}*' or '}"
+            d_c_o[0] &= proximate_role_supertypes
+            d_c_o[1] &= counterpart_role_supertypes
+            d_c_o[2] &= objectification_role_supertypes
+            d_c_o[3] << (counterpart_role || objectification_role)
+            d_c_o[4] << (objectification_role || counterpart_role)
+          end
+          d_c_o
+        end # inject
+
+      # Discount a subtype join over an object type that's not a player here,
+      # if we can use an objectification join to an object type that is:
+      if counterpart_sups.size > 0 && obj_sups.size > 0 && counterpart_sups[0] != obj_sups[0]
+        debug :join, "ambiguous join, could be over #{counterpart_sups[0].name} or #{obj_sups[0].name}"
+        if !roles.detect{|r| r.concept == counterpart_sups[0]} and roles.detect{|r| r.concept == obj_sups[0]}
+          debug :join, "discounting #{counterpart_sups[0].name} in favour of direct objectification"
+          counterpart_sups = []
+        end
+      end
+
+      # Choose the first entry in the first non-empty supertypes list:
+      if options != :counterpart
+        [ proximate_sups[0], roles ]
+      elsif !counterpart_sups.empty?
+        [ counterpart_sups[0], counterpart_roles ]
+      else
+        [ obj_sups[0], objectification_roles ]
+      end
+    end
+
   end
 end