activefacts 0.6.0

data/lib/activefacts/cql/Language/English.treetop

@@ -0,0 +1,92 @@
+module ActiveFacts
+  module CQL
+    grammar Language
+
+      rule subtype_prefix
+        defined_as 'subtype' S 'of' S
+        / 'is' s 'a' s ('kind'/'subtype') s 'of' S
+      end
+
+      rule defined_as
+        s 'is' s 'defined' S as s
+      end
+
+      rule identified_by
+        identified s by s
+      end
+
+      rule quantifier
+        each s                    { def value; [1, nil]; end }
+        / some s                  { def value; nil; end }
+	  # REVISIT: "Some" means that any prior occurrence of this role player is to be ignored; this is a new occurrence
+	  # "that" on the other hand means that this role player was *previously* designated using "some".
+	  # These distinctions are lost here
+        / that s                  { def value; nil; end }
+        / one s                   { def value; [1, 1]; end }
+        / no s                    { def value; [0, 0]; end }
+        / exactly s quantity      { def value; q = quantity.value; [q, q]; end }
+        / at s least s quantity most:( and s at s most s q:quantity )?
+                                  { def value;
+                                      [ quantity.value,
+                                        most.empty? ? nil : most.q.value
+                                      ]
+                                    end
+                                  }
+        / at s most s quantity    { def value; [ nil, quantity.value ]; end }
+        / from s numeric_range s  { def value; numeric_range.value; end }
+        / either_all_or_none s    { def value; [ -1, 1 ]; end }
+      end
+
+      rule quantity
+        one s                     { def value; 1; end }
+        / number s                { def value; number.value; end }
+      end
+
+      rule acyclic 'acyclic' !alphanumeric end
+      rule alias 'alias' !alphanumeric end 
+      rule all 'all' !alphanumeric end
+      rule and 'and' !alphanumeric end
+      rule as 'as' !alphanumeric end
+      rule at 'at' !alphanumeric end
+      rule by 'by' !alphanumeric end 
+      rule definitely 'definitely' !alphanumeric end
+      rule each 'each' !alphanumeric end 
+      rule either 'either' !alphanumeric end 
+      rule entity 'entity' !alphanumeric end 
+      rule exactly 'exactly' !alphanumeric end
+      rule false 'false' !alphanumeric end 
+      rule from  'from' !alphanumeric end
+      rule identified ('known'/'identified') !alphanumeric end 
+      rule if 'if' !alphanumeric end
+      rule import 'import' !alphanumeric end
+      rule includes 'includes' !alphanumeric end
+      rule intransitive 'intransitive' !alphanumeric end
+      rule is 'is' !alphanumeric end 
+      rule its 'its' !alphanumeric end
+      rule least 'least' !alphanumeric end
+      rule matches 'matches' !alphanumeric end
+      rule maybe 'maybe' !alphanumeric end
+      rule most 'most' !alphanumeric end
+      rule no 'no' !alphanumeric end
+      rule none 'none' !alphanumeric end
+      rule not 'not' !alphanumeric end
+      rule either_all_or_none either s all s or s none end
+      rule one 'one' !alphanumeric end
+      rule only 'only' !alphanumeric end
+      rule or 'or' !alphanumeric end 
+      rule restricted 'restricted' !alphanumeric end
+      rule returning 'returning' !alphanumeric end
+      rule some 'some' !alphanumeric end
+      rule static 'static' !alphanumeric end
+      rule symmetric 'symmetric' !alphanumeric end
+      rule that 'that' !alphanumeric end
+      rule to 'to' !alphanumeric end
+      rule transient 'transient' !alphanumeric end
+      rule transitive 'transitive' !alphanumeric end
+      rule true 'true' !alphanumeric end 
+      rule vocabulary 'vocabulary' !alphanumeric end 
+      rule where 'where' !alphanumeric end 
+
+    end
+  end
+end

data/lib/activefacts/cql/LexicalRules.treetop

@@ -0,0 +1,169 @@
+module ActiveFacts
+  module CQL
+    grammar LexicalRules
+
+      rule range
+        numeric_range / string_range
+      end
+
+      rule numeric_range
+        number s tail:( '..' s end:number? s )?
+        {
+          def value
+            if !tail.empty?
+              last = tail.end.value unless tail.end.empty?
+              [ number.value, last ]
+            else
+              number.value
+            end
+          end
+        }
+        / '..' s number s
+        {
+          def value
+            [ nil, number.value ]
+          end
+        }
+      end
+
+      rule string_range
+        string s tail:( '..' s end:string? s )?
+        {
+          # Ranges require the original text of the string, not the content:
+          def value
+            first = string.text_value
+            if !tail.empty?
+              last = tail.end.text_value unless tail.end.empty?
+              [ first, last ]
+            else
+              first
+            end
+          end
+        }
+        / '..' s string s
+        {
+          def value
+            [ nil, string.value ]
+          end
+        }
+      end
+
+      rule literal
+        ( boolean_literal
+        / string
+        / number
+        ) s
+        {
+          def value
+            elements[0].value
+          end
+        }
+      end
+
+      rule boolean_literal
+        ( true { def value; true; end }
+        / false { def value; false; end }
+        ) !alphanumeric
+        {
+          def value; elements[0].value end
+        }
+      end
+
+      rule string
+        "'" (string_char)* "'"
+        {
+          def value
+            text_value
+            eval(text_value.sub(/\A'(.*)'\Z/,'"\1"'))
+          end
+        }
+      end
+
+      rule number
+        ( real /
+          fractional_real /
+          hexnumber /
+          octalnumber
+        ) !alphanumeric
+        {
+          def value
+            eval(text_value)
+          end
+        }
+      end
+
+      # All purely lexical rules from here down, no-one looks at the structure, just the text_value:
+
+      rule string_char
+        ( '\\' [befntr\\']
+        / '\\' [0-7] [0-7] [0-7]
+        / '\\0'
+        / '\\x' [0-9A-Fa-f] [0-9A-Fa-f]
+        / '\\u' [0-9A-Fa-f] [0-9A-Fa-f] [0-9A-Fa-f] [0-9A-Fa-f]
+        / (![\'\\\0-\x07\x0A-\x1F] .)
+        )
+      end
+
+      rule real
+        [-+]? [1-9] [0-9]* fraction? exponent?
+      end
+
+      rule fractional_real
+        [-+]? '0' fraction exponent?
+      end
+
+      rule fraction
+        '.' [0-9]+
+      end
+
+      rule exponent
+        ( [Ee] '-'? [0-9]+ )
+      end
+
+      rule hexnumber
+        '0x' [0-9A-Fa-f]+
+      end
+
+      rule octalnumber
+        '0' [0-7]*
+      end
+
+      rule mul_op
+        '/' / '%' / '*'
+      end
+
+      rule id
+        alpha alphanumeric*
+      end
+
+      rule alpha
+        [A-Za-z_]
+      end
+
+      rule alphanumeric
+        alpha / [0-9]
+      end
+
+      rule s    # Optional space
+        S?
+      end
+
+      rule S    # Mandatory space
+        (white / comment_to_eol / comment_c_style)+
+      end
+
+      rule white
+        [ \t\n\r]+
+      end
+
+      rule comment_to_eol
+        '//' (!"\n" .)+
+      end
+
+      rule comment_c_style
+        '/*' (!'*/' . )* '*/'
+      end
+
+    end
+  end
+end

data/lib/activefacts/cql/Rakefile

@@ -0,0 +1,6 @@
+task :default do
+  pattern = File.dirname(__FILE__) + '**/*.treetop'
+  files = Dir[pattern]
+  # Hopefully this quoting will work where there are spaces in filenames, and even maybe on Windows?
+  exec "tt '#{files*"' '"}'"
+end

data/lib/activefacts/cql/parser.rb

@@ -0,0 +1,88 @@
+#
+# ActiveFacts CQL parser and loader.
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+require 'rubygems'
+require 'treetop'
+
+# These are Treetop files, which it will compile on the fly if precompiled ones aren't found:
+require 'activefacts/cql/LexicalRules'
+require 'activefacts/cql/Language/English'
+require 'activefacts/cql/Expressions'
+require 'activefacts/cql/Concepts'
+require 'activefacts/cql/DataTypes'
+require 'activefacts/cql/FactTypes'
+require 'activefacts/cql/CQLParser'
+
+module ActiveFacts
+  # Extend the generated parser:
+  class CQLParser
+    include ActiveFacts
+
+    # Repeatedly parse rule_name until all input is consumed,
+    # returning an array of syntax trees for each definition.
+    def parse_all(input, rule_name = nil, &block)
+      self.root = rule_name if rule_name
+
+      @index = 0  # Byte offset to start next parse
+      self.consume_all_input = false
+      results = []
+      begin
+        node = parse(input, :index => @index)
+        return nil unless node
+        node = block.call(node) if block
+        results << node if node
+      end until self.index == @input_length
+      results
+    end
+
+    def definition(node)
+      name, ast = *node.value
+      kind, *value = *ast
+
+      begin
+        debug "CQL: Processing definition #{[kind, name].compact*" "}" do
+          case kind
+          when :vocabulary
+            [kind, name]
+          when :data_type
+            data_type(name, value)
+          when :entity_type
+            supertypes = value.shift
+            entity_type(name, supertypes, value)
+          when :fact_type
+            f = fact_type(name, value)
+          when :constraint
+            ast
+          end
+        end
+      end
+    rescue => e
+      raise "in #{kind.to_s.camelcase(true)} definition, #{e.message}:\n\t#{node.text_value}"
+    end
+
+    def data_type(name, value)
+      # REVISIT: Massage/check data type here?
+      [:data_type, name, *value]
+    end
+
+    def entity_type(name, supertypes, value)
+      #print "entity_type parameters for #{name}: "; p value
+      identification, clauses = *value
+      clauses ||= []
+
+      # raise "Entity type clauses must all be fact types" if clauses.detect{|c| c[0] != :fact_clause }
+
+      [:entity_type, name, supertypes, identification, clauses]
+    end
+
+    def fact_type(name, value)
+      defined_readings, *clauses = value
+
+      [:fact_type, name, defined_readings, clauses]
+    end
+
+  end
+
+  Polyglot.register('cql', CQLParser)
+end

data/lib/activefacts/generate/absorption.rb

@@ -0,0 +1,87 @@
+#
+# Generate text output for ActiveFacts vocabularies.
+#
+# Copyright (c) 2007 Clifford Heath. Read the LICENSE file.
+# Author: Clifford Heath.
+#
+require 'activefacts/persistence'
+
+module ActiveFacts
+  module Generate
+    class ABSORPTION
+      include Metamodel
+
+      def initialize(vocabulary, *options)
+        @vocabulary = vocabulary
+        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::Constellation === @vocabulary
+        @no_columns = options.include? "no_columns"
+        @dependent = options.include? "dependent"
+        @paths = options.include? "paths"
+        @no_identifier = options.include? "no_identifier"
+      end
+
+      def generate(out = $>)
+        no_absorption = 0
+        single_absorption_vts = 0
+        single_absorption_ets = 0
+        multi_absorption_vts = 0
+        multi_absorption_ets = 0
+        @vocabulary.tables
+        @vocabulary.all_feature.sort_by{|c| c.name}.each do |o|
+          # Don't dump imported (base) ValueTypes:
+          next if ValueType === o && !o.supertype
+          show(o)
+
+          case o.absorption_paths.size
+          when 0; no_absorption += 1
+          when 1
+            if ValueType === o
+              single_absorption_vts += 1
+            else
+              single_absorption_ets += 1
+            end
+          else
+            if ValueType === o
+              multi_absorption_vts += 1
+            else
+              multi_absorption_ets += 1
+            end
+          end
+
+        end
+        puts "#{no_absorption} concepts have no absorption paths, #{single_absorption_vts}/#{single_absorption_ets} value/entity types have only one path, #{multi_absorption_vts}/#{multi_absorption_ets} have more than one"
+      end
+
+      def show concept
+        return unless concept.independent || @dependent
+
+        print "#{concept.name}"
+        print " (#{concept.tentative ? "tentatively " : ""}#{concept.independent ? "in" : ""}dependent)" if @dependent
+
+        if !@no_identifier && concept.is_a?(EntityType)
+          print " is identified by:\n\t#{
+              concept.absorbed_reference_roles.all_role_ref.map { |rr| rr.column_name(".") } * ",\n\t"
+            }"
+        end
+        print "\n"
+
+        unless @no_columns
+          puts "#{ concept.absorbed_roles.all_role_ref.map do |role_ref|
+              "\t#{role_ref.column_name(".")}\n"
+            end*"" }"
+        end
+
+        if (@paths)
+          ap = concept.absorption_paths
+          puts "#{ ap.map {|role|
+            prr = role.preferred_reference.describe
+            player = role.fact_type.entity_type == concept ? role.concept : (role.fact_type.all_role-[role])[0].concept
+            "\tcan absorb #{prr != role.concept.name ? "(via #{prr}) " : "" }into #{player.name}\n"
+          }*"" }"
+        end
+
+      end
+    end
+  end
+end
+

data/lib/activefacts/generate/cql.rb

@@ -0,0 +1,441 @@
+#
+# Generate CQL from an ActiveFacts vocabulary.
+# Copyright (c) 2008 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/vocabulary'
+require 'activefacts/generate/ordered'
+
+module ActiveFacts
+  module Generate #:nodoc:
+    class CQL < OrderedDumper
+      include Metamodel
+
+      def vocabulary_start(vocabulary)
+        puts "vocabulary #{vocabulary.name};\n\n"
+      end
+
+      def vocabulary_end
+      end
+
+      def value_type_banner
+        puts "/*\n * Value Types\n */"
+      end
+
+      def value_type_end
+        puts "\n"
+      end
+
+      def value_type_dump(o)
+        return unless o.supertype    # An imported type
+        if o.name == o.supertype.name
+            # In ActiveFacts, parameterising a ValueType will create a new datatype
+            # throw Can't handle parameterized value type of same name as its datatype" if ...
+        end
+
+        parameters =
+          [ o.length != 0 || o.scale != 0 ? o.length : nil,
+            o.scale != 0 ? o.scale : nil
+          ].compact
+        parameters = parameters.length > 0 ? "("+parameters.join(",")+")" : "()"
+
+                  #" restricted to {#{(allowed_values.map{|r| r.inspect}*", ").gsub('"',"'")}}")
+
+        puts "#{o.name} is defined as #{o.supertype.name}#{ parameters }#{
+            o.value_restriction ? " restricted to {#{
+              o.value_restriction.all_allowed_range.map{|ar|
+                  # REVISIT: Need to display as string or numeric according to type here...
+                  min = ar.value_range.minimum_bound
+                  max = ar.value_range.maximum_bound
+
+                  (min ? min.value : "") +
+                    (min.value != (max&&max.value) ? (".." + (max ? max.value : "")) : "")
+                }*", "
+            }}" : ""
+          };"
+      end
+
+      def append_ring_to_reading(reading, ring)
+        reading << " [#{(ring.ring_type.scan(/[A-Z][a-z]*/)*", ").downcase}]"
+      end
+
+      def identified_by_roles_and_facts(entity_type, identifying_roles, identifying_facts, preferred_readings)
+        identifying_role_names = identifying_roles.map{|role|
+            preferred_role_ref = preferred_readings[role.fact_type].role_sequence.all_role_ref.detect{|reading_rr|
+                reading_rr.role == role
+              }
+            role_words = []
+            # REVISIT: Consider whether NOT to use the adjective if it's a prefix of the role_name
+
+            role_name = role.role_name
+            role_name = nil if role_name == ""
+            # debug "concept.name=#{preferred_role_ref.role.concept.name}, role_name=#{role_name.inspect}, preferred_role_name=#{preferred_role_ref.role.role_name.inspect}"
+
+            if (role.fact_type.all_role.size == 1)
+              # REVISIT: Guard against unary reading containing the illegal words "and" and "where".
+              role.fact_type.default_reading    # Need whole reading for a unary.
+            elsif (role_name)
+              role_name
+            else
+              role_words << preferred_role_ref.leading_adjective if preferred_role_ref.leading_adjective != ""
+              role_words << preferred_role_ref.role.concept.name
+              role_words << preferred_role_ref.trailing_adjective if preferred_role_ref.trailing_adjective != ""
+              role_words.compact*"-"
+            end
+          }
+
+        # REVISIT: Consider emitting extra fact types here, instead of in entity_type_dump?
+        # Just beware that readings having the same players will be considered to be of the same fact type, even if they're not.
+
+        # Detect standard reference-mode scenarios
+        ft = identifying_facts[0]
+        fact_constraints = nil
+        if identifying_facts.size == 1 and
+          entity_role = ft.all_role[n = (ft.all_role[0].concept == entity_type ? 0 : 1)] and
+          value_role = ft.all_role[1-n] and
+          value_name = value_role.concept.name and
+          residual = value_name.gsub(%r{#{entity_role.concept.name}},'') and
+          residual != '' and
+          residual != value_name
+
+          # The EntityType is identified by its association with a single ValueType
+          # whose name is an extension (the residual) of the EntityType's name.
+
+          # Detect standard reference-mode readings:
+          forward_reading = reverse_reading = nil
+          ft.all_reading.each do |reading|
+            if reading.reading_text =~ /^\{(\d)\} has \{\d\}$/
+              if reading.role_sequence.all_role_ref[$1.to_i].role == entity_role
+                forward_reading = reading
+              else
+                reverse_reading = reading
+              end
+            elsif reading.reading_text =~ /^\{(\d)\} is of \{\d\}$/
+              if reading.role_sequence.all_role_ref[$1.to_i].role == value_role
+                reverse_reading = reading
+              else
+                forward_reading = reading
+              end
+            end
+          end
+
+          debug :mode, "------------------- Didn't find standard forward reading" unless forward_reading
+          debug :mode, "------------------- Didn't find standard reverse reading" unless reverse_reading
+
+          # If we didn't find at least one of the standard readings, don't use a refmode:
+          if (forward_reading || reverse_reading)
+            # Elide the constraints that would have been emitted on those readings.
+            # If there is a UC that's not in the standard form for a reference mode,
+            # we have to emit the standard reading anyhow.
+            fact_constraints = @presence_constraints_by_fact[ft]
+            fact_constraints.each do |pc|
+              if (pc.role_sequence.all_role_ref.size == 1 and pc.max_frequency == 1)
+                # It's a uniqueness constraint, and will be regenerated
+                @constraints_used[pc] = true
+              end
+            end
+
+            @fact_types_dumped[ft] = true
+
+            # Figure out whether any non-standard readings exist:
+            other_readings = ft.all_reading - [forward_reading] - [reverse_reading]
+            debug :mode, "--- other_readings.size now = #{other_readings.size}" if other_readings.size > 0
+
+            fact_text = other_readings.map do |reading|
+              expanded_reading(reading, fact_constraints, true)
+            end*",\n\t"
+            return " identified by its #{residual}" +
+              (fact_text != "" ? " where\n\t" + fact_text : "")
+          end
+        end
+
+        identifying_facts.each{|f| @fact_types_dumped[f] = true }
+        @identifying_fact_text = 
+            identifying_facts.map{|f|
+                fact_readings_with_constraints(f, fact_constraints)
+            }.flatten*",\n\t"
+
+        " identified by #{ identifying_role_names*" and " }" +
+          " where\n\t"+@identifying_fact_text
+      end
+
+      def entity_type_banner
+        puts "/*\n * Entity Types\n */"
+      end
+
+      def entity_type_group_end
+        puts "\n"
+      end
+
+      def fact_readings(fact_type)
+        constrained_fact_readings = fact_readings_with_constraints(fact_type)
+        constrained_fact_readings*",\n\t"
+      end
+
+      def subtype_dump(o, supertypes, pi)
+        print "#{o.name} is a kind of #{ o.supertypes.map(&:name)*", " }"
+        if pi
+          print identified_by(o, pi)
+        end
+        # If there's a preferred_identifier for this subtype, identifying readings were emitted
+        print((pi ? "," : " where") + "\n\t" + fact_readings(o.fact_type)) if o.fact_type
+        puts ";\n"
+      end
+
+      def non_subtype_dump(o, pi)
+        print "#{o.name} is" + identified_by(o, pi)
+        print(" where\n\t"+ fact_readings(o.fact_type)) if o.fact_type
+        puts ";\n"
+      end
+
+      def fact_type_dump(fact_type, name)
+
+        @identifying_fact_text = nil
+        if (o = fact_type.entity_type)
+          print "#{o.name} is"
+          if !o.all_type_inheritance_by_subtype.empty?
+            print " a kind of #{ o.supertypes.map(&:name)*", " }"
+          end
+
+          # Alternate identification of objectified fact type?
+          primary_supertype = o.supertypes[0]
+          pi = fact_type.entity_type.preferred_identifier
+          if pi && primary_supertype && primary_supertype.preferred_identifier != pi
+            print identified_by(o, pi)
+            print ";\n"
+          end
+        end
+
+        unless @identifying_fact_text
+          print " where\n\t" if o
+          puts(fact_readings(fact_type)+";")
+        end
+      end
+
+      def fact_type_banner
+        puts "/*\n * Fact Types\n */"
+      end
+
+      def fact_type_end
+        puts "\n"
+      end
+
+      def constraint_banner
+        puts "/*\n * Constraints:"
+        puts " */"
+      end
+
+      def constraint_end
+      end
+
+      # Of the players of a set of roles, return the one that's a subclass of (or same as) all others, else nil
+      def roleplayer_subclass(roles)
+        roles[1..-1].inject(roles[0].concept){|subclass, role|
+          next nil unless subclass and EntityType === role.concept
+          role.concept.supertypes_transitive.include?(subclass) ? role.concept : nil
+        }
+      end
+
+      def dump_presence_constraint(c)
+        roles = c.role_sequence.all_role_ref.map{|rr| rr.role }
+
+        # REVISIT: If only one role is covered and it's mandatory >=1 constraint, use SOME/THAT form:
+        # each Bug SOME Tester logged THAT Bug;
+        players = c.role_sequence.all_role_ref.map{|rr| rr.role.concept.name}.uniq
+
+        fact_types = c.role_sequence.all_role_ref.map{|rr| rr.role.fact_type}.uniq
+        puts \
+          "each #{players.size > 1 ? "combination " : ""}#{players*", "} occurs #{c.frequency} time in\n\t"+
+          "#{fact_types.map{|ft| ft.default_reading([], nil)}*",\n\t"}" +
+            ";"
+
+=begin
+          # More than one fact type involved, an external constraint.
+            fact_type = rr.role.fact_type
+          # or all facts are binary and the counterparts of the roles are.
+          puts "// REVISIT: " +
+          if (player = roleplayer_subclass(roles))
+            "#{player.name} must play #{c.frequency} of "
+          else
+            counterparts = roles.map{|r|
+                r.fact_type.all_role[r.fact_type.all_role[0] != r ? 0 : -1]
+              }
+            player = roleplayer_subclass(counterparts)
+            "#{c.frequency} #{player ? player.name : "UNKNOWN" } exists for each "
+          end +
+          "#{
+              c.role_sequence.all_role_ref.map{|rr|
+                "'#{rr.role.fact_type.default_reading([], nil)}'"
+              }*", "
+            }"
+=end
+
+=begin
+        puts \
+          "FOR each #{players*", "}" +
+          (c.role_sequence.all_role_ref.size > 1 ? " "+c.frequency+" of these holds" : "") + "\n\t"+
+          "#{c.role_sequence.all_role_ref.map{|rr|
+            role = rr.role
+            fact_type = role.fact_type
+            some_that = Array.new(fact_type.all_role.size, "some")
+            c.role_sequence.all_role_ref.each{|rr2|
+              next if rr2.role.fact_type != fact_type
+              some_that[fact_type.all_role.index(role)] = "that"
+            }
+            rr.role.fact_type.default_reading(some_that, nil)
+          }*",\n\t"}" +
+          ";"
+=end
+      end
+
+      # Find the common supertype of these concepts.
+      # N.B. This will only work if all concepts are on the direct path to the deepest.
+      def common_supertype(concepts)
+        players_differ = false
+        common =
+          concepts[1..-1].inject(concepts[0]) do |supertype, concept|
+            if !supertype || concept == supertype
+              concept   # Most common case
+            elsif concept.supertypes_transitive.include?(supertype)
+              players_differ = true
+              supertype
+            elsif supertype.supertypes_transitive.include?(concept)
+              players_differ = true
+              concept
+            else
+              return nil  # No common supertype
+            end
+          end
+        return common, players_differ
+      end
+
+      def dump_set_constraint(c)
+        # REVISIT exclusion: every <player-list> must<?> either reading1, reading2, ...
+
+        # Each constraint involves two or more occurrences of one or more players.
+        # For each player, a subtype may be involved in the occurrences.
+        # Find the common supertype of each player.
+        scrs = c.all_set_comparison_roles
+        player_count = scrs[0].role_sequence.all_role_ref.size
+        role_seq_count = scrs.size
+
+        #raise "Can't verbalise constraint over many players and facts" if player_count > 1 and role_seq_count > 1
+
+        # puts "#{c.class.basename} has #{role_seq_count} scr's: #{scrs.map{|scr| "("+scr.role_sequence.all_role_ref.map{|rr| rr.role.concept.name}*", "+")"}*", "}"
+
+        players_differ = []   # Record which players are also played by subclasses
+        players = (0...player_count).map do |pi|
+          # Find the common supertype of the players of the pi'th role in each sequence
+          concepts = scrs.map{|r| r.role_sequence.all_role_ref[pi].role.concept }
+          player, players_differ[pi] = common_supertype(concepts)
+          raise "Role sequences of #{c.class.basename} must have concepts matching #{concept.name} in position #{pi}" unless player
+          player
+        end
+        #puts "#{c.class.basename} has players #{players.map{|p| p.name}*", "}"
+
+        if (SetEqualityConstraint === c)
+          # REVISIT: Need a proper approach to some/that and adjective disambiguation:
+          puts \
+            scrs.map{|scr|
+              scr.role_sequence.all_role_ref.map{|rr| rr.role.fact_type.default_reading([], nil) }*" and "
+            } * "\n\tif and only if\n\t" + ";"
+          return
+        end
+
+        mode = c.is_mandatory ? "exactly one" : "at most one"
+        puts "for each #{players.map{|p| p.name}*", "} #{mode} of these holds:\n\t" +
+          (scrs.map do |scr|
+            constrained_roles = scr.role_sequence.all_role_ref.map{|rr| rr.role }
+            fact_types = constrained_roles.map{|r| r.fact_type }.uniq
+
+            fact_types.map do |fact_type|
+              # REVISIT: future: Use "THAT" and "SOME" only when:
+              # - the role player occurs twice in the reading, or
+              # - is a subclass of the constrained concept, or
+              reading = fact_type.preferred_reading
+              expand_constrained(reading, constrained_roles, players, players_differ)
+            end * " and "
+
+          end*",\n\t"
+          )+';'
+      end
+
+      # Expand this reading using (in)definite articles where needed
+      # Handle any roles in constrained_roles specially.
+      def expand_constrained(reading, constrained_roles, players, players_differ)
+        frequency_constraints = reading.role_sequence.all_role_ref.map {|role_ref|
+            i = constrained_roles.index(role_ref.role)
+            if !i
+              [ "some", role_ref.role.concept.name]
+            elsif players_differ[i]
+              [ "that", players[i].name ]   # Make sure to use the superclass name
+            else
+              if reading.fact_type.all_role.select{|r| r.concept == role_ref.role.concept }.size > 1
+                [ "that", role_ref.role.concept.name ]
+              else
+                [ "some", role_ref.role.concept.name ]
+              end
+            end
+          }
+        frequency_constraints = [] unless frequency_constraints.detect{|fc| fc[0] != "some" }
+
+        #$stderr.puts "fact_type roles (#{fact_type.all_role.map{|r| r.concept.name}*","}) default_reading '#{fact_type.preferred_reading.reading_text}' roles (#{fact_type.preferred_reading.role_sequence.all_role_ref.map{|rr| rr.role.concept.name}*","}) #{frequency_constraints.inspect}"
+
+        # REVISIT: Make sure that we refer to the constrained players by their common supertype
+
+        reading.expand(frequency_constraints, nil)
+      end
+
+      def dump_subset_constraint(c)
+        # If the role players are identical and not duplicated, we can simply say "reading1 only if reading2"
+        subset_roles = c.subset_role_sequence.all_role_ref.map{|rr| rr.role}
+        superset_roles = c.superset_role_sequence.all_role_ref.map{|rr| rr.role}
+
+        subset_players = subset_roles.map(&:concept)
+        superset_players = superset_roles.map(&:concept)
+
+        subset_fact_types = c.subset_role_sequence.all_role_ref.map{|rr| rr.role.fact_type }.uniq
+        superset_fact_types = c.superset_role_sequence.all_role_ref.map{|rr| rr.role.fact_type }.uniq
+
+        # We need to ensure that if the player of any constrained role also exists
+        # as the player of a role that's not a constrained role, there are different
+        # adjectives or other qualifiers qualifier applied to distinguish that role.
+        fact_type_roles = (subset_fact_types+superset_fact_types).map{|ft| ft.all_role }.flatten
+        non_constrained_roles = fact_type_roles - subset_roles - superset_roles
+        if (r = non_constrained_roles.detect{|r| (subset_roles+superset_roles).include?(r) })
+          # REVISIT: Find a way to deal with this problem, should it arise.
+
+          # It would help, but not entirely fix it, to use SOME/THAT to identify the constrained roles.
+          # See ServiceDirector's DataStore<->Client fact types for example
+          # Use SOME on the subset, THAT on the superset.
+          raise "Critical ambiguity, #{r.concept.name} occurs both constrained and unconstrained in #{c.name}"
+        end
+
+        puts \
+          "#{subset_fact_types.map{|ft| ft.default_reading([], nil)}*" and "}" +
+          "\n\tonly if " +
+          "#{superset_fact_types.map{|ft| ft.default_reading([], nil)}*" and "}" +
+          ";"
+      end
+
+      def dump_ring_constraint(c)
+        # At present, no ring constraint can be missed to be handled in this pass
+        puts "// #{c.ring_type} ring over #{c.role.fact_type.default_reading([], nil)}"
+      end
+
+      def constraint_dump(c)
+          case c
+          when PresenceConstraint
+            dump_presence_constraint(c)
+          when RingConstraint
+            dump_ring_constraint(c)
+          when SetComparisonConstraint # includes SetExclusionConstraint, SetEqualityConstraint
+            dump_set_constraint(c)
+          when SubsetConstraint
+            dump_subset_constraint(c)
+          else
+            "#{c.class.basename} #{c.name}: unhandled constraint type"
+          end
+      end
+    end
+  end
+end