activefacts 1.6.0 → 1.7.1

data/lib/activefacts/dependency_analyser.rb

@@ -1,182 +0,0 @@
-module ActiveFacts
-  class DependencyAnalyser
-    def initialize enumerable, &block
-      @enumerable = enumerable
-      analyse_precursors &block
-    end
-
-    def analyse_precursors &block
-      @precursors = {}
-      @enumerable.each do |item|
-	@precursors[item] = block.call(item)
-      end
-    end
-
-    def analyse_precursors_transitive
-      all_precursors = proc do |item|
-	  p = @precursors[item]
-	  all =
-	    p + p.map do |precursor|
-	      p.include?(precursor) ? [] : all_precursors.call(precursor)
-	    end.flatten
-	  all.uniq
-	end
-
-      @precursors_transitive = {}
-      @enumerable.each do |item|
-	@precursors_transitive[item] = all_precursors.call(item)
-      end
-    end
-
-    def analyse_followers
-      @followers = Hash.new{|h, k| h[k] = [] }
-      @enumerable.each do |item|
-	@precursors[item].each do |precursor|
-	  @followers[precursor] << item
-	end
-      end
-    end
-
-    def analyse_chasers
-      analyse_precursors_transitive unless @precursors_transitive
-      analyse_followers unless @followers
-
-      # A follower is an object with us as a precursor, that has no new precursors of its own
-      @chasers = {}
-      @enumerable.each do |item|
-	@chasers[item] =
-	  @enumerable.select do |follower|
-	    @precursors[follower].include?(item) and
-	    (@precursors_transitive[follower] - @precursors_transitive[item] - [item]).size == 0
-	  end
-      end
-    end
-
-    def tsort &block
-      analyse_precursors unless @precursors
-      emitted = {}
-      pass = 0
-      until emitted.size == @enumerable.size
-	next_items = []
-	blocked =
-	  @enumerable.inject({}) do |hash, item|
-	    next hash if emitted[item]
-	    blockers = item.precursors.select{|precursor| !emitted[precursor]}
-	    if blockers.size > 0
-	      hash[item] = blockers
-	    else
-	      next_items << item
-	    end
-	    hash
-	  end
-	return blocked if next_items.size == 0	# Cannot make progress
-	# puts "PASS #{pass += 1}"
-	next_items.each do |item|
-	  block.call(item)
-	  emitted[item] = true
-	end
-      end
-      nil
-    end
-
-    def each &b
-      if block_given?
-	@enumerable.each { |item| yield item}
-      else
-	@enumerable
-      end
-    end
-
-    def precursors item = nil, &b
-      analyse_precursors unless @precursors
-      if item
-	if block_given?
-	  Array(@precursors[item]).each { |precursor| yield precursor, item }
-	else
-	  Array(@precursors[item])
-	end
-      else
-	@enumerable.each do |item|
-	  precursors(item, &b)
-	end
-      end
-    end
-
-    def precursors_transitive item, &b
-      analyse_precursors_transitive unless @precursors_transitive
-      if item
-	if block_given?
-	  Array(@precursors_transitive[item]).each { |precursor| yield precursor, item }
-	else
-	  Array(@precursors_transitive[item])
-	end
-      else
-	@enumerable.each do |item|
-	  precursors_transitive(item, &b)
-	end
-      end
-    end
-
-    def followers item = nil, &b
-      analyse_followers unless @followers
-      if item
-	if block_given?
-	  Array(@followers[item]).each { |follower| yield follower, item }
-	else
-	  Array(@followers[item])
-	end
-      else
-	@enumerable.each do |item|
-	  followers(item, &b)
-	end
-      end
-    end
-
-    def chasers item, &b
-      analyse_chasers unless @chasers
-      if item
-	if block_given?
-	  Array(@chasers[item]).each { |follower| yield follower, item }
-	else
-	  Array(@chasers[item])
-	end
-      else
-	@enumerable.each do |item|
-	  follower(item, &b)
-	end
-      end
-    end
-
-    # Compute the page rank of the objects
-    # If used, the block shold return the starting weight
-    def page_rank damping = 0.85, &weight
-      weight ||= proc {|item| 1.0}
-
-      @total = 0
-      @rank = {}
-      @enumerable.each do |item|
-	@total += 
-	  (@rank[item] = weight.call(item) * 1.0)
-      end
-      # Normalize:
-      @enumerable.each do |item|
-	@rank[item] /= @total
-      end
-
-      50.times do |iteration|
-	@enumerable.each do |item|
-	  links = (precursors(item) + followers(item)).uniq
-	  linked_rank = links.map do |l|
-	      onward_links = (precursors(l) + followers(l)).uniq || @enumerable.size
-	      @rank[l] / onward_links.size
-	    end.inject(&:+) || 0
-	  @rank[item] = (1.0-damping) + damping*linked_rank
-	end
-      end
-
-      @rank
-    end
-
-  end
-end
-

data/lib/activefacts/generate/absorption.rb

@@ -1,70 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Absorption generator.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'activefacts/vocabulary'
-require 'activefacts/persistence'
-
-module ActiveFacts
-  module Generate
-    # Emit the absorption (Relational summary) for vocabulary.
-    # Not currently working, it relies on the old relational composition code.
-    # Invoke as
-    #   afgen --absorption[=options] <file>.cql"
-    # Options are comma or space separated:
-    # * no_columns Don't emit the columns
-    # * all Show ObjectTypes that are not tables as well
-    # * paths Show the references paths through which each column was defined
-    # * no_identifier Don't show the identified_by columns for an EntityType
-
-    class Absorption
-      def initialize(vocabulary, *options)  #:nodoc:
-        @vocabulary = vocabulary
-        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
-        @no_columns = options.include? "no_columns"
-        @paths = options.include? "paths"
-        @no_identifier = options.include? "no_identifier"
-      end
-
-      def generate(out = $>)  #:nodoc:
-	@out = out
-        no_absorption = 0
-        single_absorption_vts = 0
-        single_absorption_ets = 0
-        multi_absorption_vts = 0
-        multi_absorption_ets = 0
-        @vocabulary.tables
-        @vocabulary.all_object_type.sort_by{|c| c.name}.each do |o|
-          next if !o.is_table
-          show(o)
-        end
-      end
-
-      def show object_type        #:nodoc:
-        indices = object_type.indices
-        pk = indices.select(&:is_primary)[0]
-        indices = indices.clone
-        indices.delete pk
-        @out.puts "#{object_type.name}: #{
-#            "[#{object_type.indices.size} indices] "
-#          } #{
-            object_type.columns.sort_by do |column|
-              column.name(nil)
-            end.map do |column|
-              index_nrs =
-                [pk && pk.columns.include?(column) ? "*" : nil] +
-                (0...indices.size).select{|i| indices[i].columns.include?(column)}.map{|i| (i+1).to_i }
-              index_nrs.compact!
-              (@paths ? column.references.map{|r| r.to_names}.flatten : column.name(nil)) * '.' +
-                (index_nrs.empty? ? "" : "["+index_nrs*""+"]")
-            end*", "
-          }"
-
-      end
-    end
-  end
-end
-
-ActiveFacts::Registry.generator('absorption', ActiveFacts::Generate::Absorption)

data/lib/activefacts/generate/composition.rb

@@ -1,118 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Generate a Relational Composition (for activefacts/composition).
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'activefacts/vocabulary'
-require 'activefacts/generate/helpers/inject'
-require 'activefacts/persistence'
-require 'activefacts/generate/traits/ruby'
-
-module ActiveFacts
-  module Generate
-    #   afgen --composition[=options] <file>.cql
-    # Options are comma or space separated:
-    class Composition #:nodoc:
-    private
-      include Persistence
-
-      def initialize(vocabulary, *options)
-	@vocabulary = vocabulary
-	@vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
-	@underscore = options.include?("underscore") ? "_" : ""
-      end
-
-      def puts s
-	@out.puts s
-      end
-
-    public
-      def generate(out = $>)      #:nodoc:
-	@out = out
-
-	tables_emitted = {}
-
-	puts "require '#{@vocabulary.name}'"
-	puts "require 'activefacts/composition'"
-	puts "\n#{@vocabulary.name}_ER = ActiveFacts::Composition.new(#{@vocabulary.name}) do"
-	@vocabulary.tables.each do |table|
-	  puts "  composite :\"#{table.name.gsub(' ',@underscore)}\" do"
-
-	  pk = table.identifier_columns
-	  identity_column = pk[0] if pk[0].is_auto_assigned
-
-	  fk_refs = table.references_from.select{|ref| ref.is_simple_reference }
-	  fk_columns = table.columns.select do |column|
-	    column.references[0].is_simple_reference
-	  end
-
-	  columns =
-	    table.columns.map do |column|
-	      [column, column.references.map{|r| r.to_names }]
-	    end.sort_by do |column, refnames|
-	      refnames
-	    end
-	  previous_flattening = []
-	  ref_prefix = []
-	  columns.each do |column, refnames|
-	    ref_prefix = column.references[0...previous_flattening.size]
-	    # Pop back. Not a succinct algorithm, but easy to check
-	    while previous_flattening.size > ref_prefix.size
-	      previous_flattening.pop
-	      puts '    '+'  '*previous_flattening.size+"end\n"
-	    end
-	    while ref_prefix.size > 0 and previous_flattening != ref_prefix
-	      previous_flattening.pop
-	      ref_prefix.pop
-	      puts '    '+'  '*previous_flattening.size+"end\n"
-	    end
-	    loop do
-	      ref = column.references[ref_prefix.size]
-	      if ref.is_self_value
-		# REVISIT: I think these should be 'insert :value, :as => "XYZ"'
-		role_name = "value".snakecase
-		reading = "Intrinsic value of #{role_name}"
-	      elsif ref.is_to_objectified_fact
-		# REVISIT: It's ugly to have to handle these special cases here
-		role_name = ref.to.name.words.snakecase
-		reading = ref.from_role.link_fact_type.default_reading
-	      else
-		if ref.is_unary && ref.is_from_objectified_fact && ref != column.references.last
-		  # Use the name of the objectification on the path to other absorbed fact types:
-		  role_name = ref.to_role.fact_type.entity_type.name.words.snakecase
-		else
-		  role_name = ref.to_role.preferred_role_name
-		end
-		# puts ">>>>> #{ref.inspect}: #{role_name} <<<<<<"
-		reading = ref.fact_type.default_reading
-	      end
-	      if ref == column.references.last
-		# REVISIT: Avoid the "as" here when the value is implied by the role_name:
-		puts '    '+'  '*ref_prefix.size+"nest :#{role_name}, :as => \"#{column.name}\"\t\t# #{reading}"
-		break
-	      else
-		puts '    '+'  '*ref_prefix.size+"flatten :#{role_name} do\t\t# #{reading}"
-		ref_prefix.push ref
-	      end
-	    end
-	    previous_flattening = ref_prefix
-	  end
-
-	  while previous_flattening.size > 0
-	    previous_flattening.pop
-	    puts '    '+'  '*previous_flattening.size+"end\n"
-	  end
-	  puts "  end\n\n"
-
-	  tables_emitted[table] = true
-
-	end
-	puts "end\n"
-      end
-
-    end
-  end
-end
-
-ActiveFacts::Registry.generator('composition', ActiveFacts::Generate::Composition)

data/lib/activefacts/generate/cql.rb

@@ -1,714 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Generate CQL from an ActiveFacts vocabulary.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'activefacts/vocabulary'
-require 'activefacts/registry'
-require 'activefacts/generate/helpers/ordered'
-
-module ActiveFacts
-  module Generate #:nodoc:
-    # Generate CQL for an ActiveFacts vocabulary.
-    # Invoke as
-    #   afgen --cql <file>.cql
-    class CQL < Helpers::OrderedDumper
-    private
-      def vocabulary_start
-        puts "vocabulary #{@vocabulary.name};\n\n"
-	build_indices
-      end
-
-      def vocabulary_end
-      end
-
-      def units_banner
-        puts "/*\n * Units\n */"
-      end
-
-      def unit_dump unit
-	puts unit.as_cql
-      end
-
-      def units_end
-        puts "\n"
-      end
-
-      def value_type_banner
-        puts "/*\n * Value Types\n */"
-      end
-
-      def value_type_end
-        puts "\n"
-      end
-
-      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)
-        # No need to dump it if the only thing it does is be a supertype; it'll be created automatically
-        # return if o.all_value_type_as_supertype.size == 0
-
-        # REVISIT: A ValueType that is only used as a reference mode need not be emitted here.
-
-	puts o.as_cql
-      end
-
-      def entity_type_dump(o)
-	o.ordered_dumped!
-	pi = o.preferred_identifier
-
-	supers = o.supertypes
-	if (supers.size > 0)
-	  # Ignore identification by a supertype:
-	  pi = nil if pi && pi.role_sequence.all_role_ref.detect{|rr| rr.role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) }
-	  subtype_dump(o, supers, pi)
-	else
-	  non_subtype_dump(o, pi)
-	end
-	pi.ordered_dumped! if pi
-      end
-
-      def append_ring_to_reading(reading, ring)
-        reading << " [#{(ring.ring_type.scan(/StronglyIntransitive|[A-Z][a-z]*/)*", ").downcase}]"
-      end
-
-      def mapping_pragma(entity_type, ignore_independence = false)
-        ti = entity_type.all_type_inheritance_as_subtype
-        assimilation = ti.map{|t| t.assimilation }.compact[0]
-        return "" unless (entity_type.is_independent && !ignore_independence) || assimilation
-        " [" +
-          [
-            entity_type.is_independent && !ignore_independence ? "independent" : nil,
-            assimilation || nil
-          ].compact*", " +
-        "]"
-      end
-
-      # If this entity_type is identified by a single value, return four relevant objects:
-      def value_role_identification(entity_type, identifying_facts)
-        external_identifying_facts = identifying_facts - [entity_type.fact_type]
-        fact_type = external_identifying_facts[0]
-        ftr = fact_type && fact_type.all_role.sort_by{|role| role.ordinal}
-        if external_identifying_facts.size == 1 and
-            entity_role = ftr[n = (ftr[0].object_type == entity_type ? 0 : 1)] and
-            value_role = ftr[1-n] and
-            value_player = value_role.object_type and
-            value_player.is_a?(ActiveFacts::Metamodel::ValueType) and
-            value_name = value_player.name and
-            value_residual = value_name.sub(%r{^#{entity_role.object_type.name} ?},'') and
-            value_residual != '' and
-            value_residual != value_name
-          [fact_type, entity_role, value_role, value_residual]
-        else
-          []
-        end
-      end
-
-      # This entity is identified by a single value, so find whether standard refmode readings were used
-      def detect_standard_refmode_readings fact_type, entity_role, value_role
-        forward_reading = reverse_reading = nil
-        fact_type.all_reading.each do |reading|
-          if reading.text =~ /^\{(\d)\} has \{\d\}$/
-            if reading.role_sequence.all_role_ref.detect{|rr| rr.ordinal == $1.to_i}.role == entity_role
-              forward_reading = reading
-            else
-              reverse_reading = reading
-            end
-          elsif reading.text =~ /^\{(\d)\} is of \{\d\}$/
-            if reading.role_sequence.all_role_ref.detect{|rr| rr.ordinal == $1.to_i}.role == value_role
-              reverse_reading = reading
-            else
-              forward_reading = reading
-            end
-          end
-        end
-        trace :mode, "Didn't find standard forward reading" unless forward_reading
-        trace :mode, "Didn't find standard reverse reading" unless reverse_reading
-        [forward_reading, reverse_reading]
-      end
-
-      # If this entity_type is identified by a reference mode, return the verbalisation
-      def identified_by_ref_mode(entity_type, identifying_facts)
-        fact_type, entity_role, value_role, value_residual =
-          *value_role_identification(entity_type, identifying_facts)
-        return nil unless fact_type
-
-        # This EntityType is identified by its association with a single ValueType
-        # whose name is an extension (the value_residual) of the EntityType's name.
-        # If we have at least one of the standard refmode readings, dump it that way,
-        # else exit and use the long-hand verbalisation instead.
-
-        forward_reading, reverse_reading =
-          *detect_standard_refmode_readings(fact_type, entity_role, value_role)
-        return nil unless (forward_reading || reverse_reading)
-
-        # We can't subscript reference modes.
-        # If an objectified fact type has a role played by its identifying player, go long-hand.
-        return nil if entity_type.fact_type and
-          entity_type.fact_type.all_role.detect{|role| role.object_type == value_role.object_type }
-
-        fact_type.ordered_dumped!  # We've covered this fact type
-
-        # Elide the constraints that would have been emitted on the standard 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[fact_type]
-        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
-            pc.ordered_dumped!
-          end
-        end
-
-        # Figure out which non-standard readings exist, if any:
-        nonstandard_readings = fact_type.all_reading - [forward_reading, reverse_reading]
-        trace :mode, "--- nonstandard_readings.size now = #{nonstandard_readings.size}" if nonstandard_readings.size > 0
-
-        verbaliser = ActiveFacts::Metamodel::Verbaliser.new
-
-        # The verbaliser needs to have a Player for the roles of entity_type, so it doesn't get subscripted.
-        entity_roles =
-          nonstandard_readings.map{|r| r.role_sequence.all_role_ref.detect{|rr| rr.role.object_type == entity_type}}.compact
-        verbaliser.role_refs_have_same_player entity_roles
-
-        verbaliser.alternate_readings nonstandard_readings
-        if entity_type.fact_type
-          verbaliser.alternate_readings entity_type.fact_type.all_reading
-        end
-
-        verbaliser.create_subscripts(:rolenames)      # Ok, the Verbaliser is ready to fly
-
-        fact_readings =
-          nonstandard_readings.map { |reading| expanded_reading(verbaliser, reading, fact_constraints, true) }
-        fact_readings +=
-          fact_readings_with_constraints(verbaliser, entity_type.fact_type) if entity_type.fact_type
-
-        # If we emitted a reading for the refmode, it'll include any role_value_constraint already
-        if nonstandard_readings.size == 0 and c = value_role.role_value_constraint
-          constraint_text = " "+c.as_cql
-        end
-        (entity_type.is_independent ? ' independent' : '') +
-          " identified by its #{value_residual}#{constraint_text}#{mapping_pragma(entity_type, true)}" +
-	  entity_type.concept.all_context_note_as_relevant_concept.map do |cn|
-	    cn.verbalise
-	  end.join("\n") +
-          (fact_readings.size > 0 ? " where\n\t" : "") +
-          fact_readings*",\n\t"
-      end
-
-      def identified_by_roles_and_facts(entity_type, identifying_role_refs, identifying_facts)
-        # Detect standard reference-mode scenarios:
-        if srm = identified_by_ref_mode(entity_type, identifying_facts)
-          return srm
-        end
-
-        verbaliser = ActiveFacts::Metamodel::Verbaliser.new
-
-        # Announce all the identifying fact roles to the verbaliser so it can decide on any necessary subscripting.
-        # The verbaliser needs to have a Player for the roles of entity_type, so it doesn't get subscripted.
-        entity_roles =
-          identifying_facts.map{|ft| ft.preferred_reading.role_sequence.all_role_ref.detect{|rr| rr.role.object_type == entity_type}}.compact
-        verbaliser.role_refs_have_same_player entity_roles
-        identifying_facts.each do |fact_type|
-          # The RoleRefs for corresponding roles across all readings are for the same player.
-          verbaliser.alternate_readings fact_type.all_reading
-          fact_type.ordered_dumped! unless fact_type.entity_type # Must dump objectification still!
-        end
-        verbaliser.create_subscripts(:rolenames)
-
-        irn = verbaliser.identifying_role_names identifying_role_refs
-
-        identifying_fact_text = 
-            identifying_facts.map{|f|
-                fact_readings_with_constraints(verbaliser, f)
-            }.flatten*",\n\t"
-
-        (entity_type.is_independent ? ' independent' : '') +
-          " identified by #{ irn*" and " }" +
-          mapping_pragma(entity_type, true) +
-	  entity_type.concept.all_context_note_as_relevant_concept.map do |cn|
-	    cn.verbalise
-	  end.join("\n") +
-          " 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 subtype_dump(o, supertypes, pi)
-        print "#{o.name} is a kind of #{
-            o.is_independent ? 'independent ' : ''
-          }#{ o.supertypes.map(&:name)*", " }"
-        if pi
-          puts identified_by(o, pi)+';'
-          return
-        end
-
-        print mapping_pragma(o, true)
-
-        if o.fact_type
-          verbaliser = ActiveFacts::Metamodel::Verbaliser.new
-          # Announce all the objectified fact roles to the verbaliser so it can decide on any necessary subscripting.
-          # The RoleRefs for corresponding roles across all readings are for the same player.
-          verbaliser.alternate_readings o.fact_type.all_reading
-          verbaliser.create_subscripts(:rolenames)
-
-          print " where\n\t" + fact_readings_with_constraints(verbaliser, o.fact_type)*",\n\t"
-        end
-        puts ";\n"
-      end
-
-      def non_subtype_dump(o, pi)
-        puts "#{o.name} is" + identified_by(o, pi) + ';'
-      end
-
-      def naiive_expand(reading)
-        role_refs = reading.role_sequence.all_role_ref_in_order
-        reading.text.gsub(/\{(\d+)\}/) do
-          role_refs[$1.to_i].role.object_type.name
-        end
-      end
-
-      def fact_type_dump(fact_type, name)
-
-        if (o = fact_type.entity_type)
-          print "#{o.name} is"
-          supertypes = o.supertypes
-          if supertypes.empty?
-            print ' independent' if o.is_independent
-          else
-            print " a kind of#{
-                o.is_independent ? ' independent' : ''
-              } #{ supertypes.map(&:name)*', ' }"
-          end
-
-          # Alternate identification of objectified fact type?
-          primary_supertype = supertypes[0]
-          pi = fact_type.entity_type.preferred_identifier
-          if pi && primary_supertype && primary_supertype.preferred_identifier != pi
-            puts identified_by(o, pi) + ';'
-            return
-          end
-          print " where\n\t"
-        end
-
-        # Check whether this fact type has readings which could be confused for a previously-dumped one:
-        reading_texts = fact_type.all_reading.map{|r| naiive_expand(r)}
-        if reading_texts.size > 1
-          ambiguity =
-            fact_type.all_role.to_a[0].object_type.all_role.map{|r| r.fact_type}.
-              select{|f| f != fact_type && f.ordered_dumped }.
-              detect do |dft|
-                ambiguous_readings =
-                  reading_texts & dft.all_reading.map{|r| naiive_expand(r)}
-                ambiguous_readings.size > 0
-              end
-          if ambiguity
-            puts fact_type.default_reading([], true)+';  // Avoid ambiguity; this is a new fact type'
-          end
-        end
-
-        # There can be no roles of the objectified fact type in the readings, so no need to tell the Verbaliser anything special
-        verbaliser = ActiveFacts::Metamodel::Verbaliser.new
-        verbaliser.alternate_readings fact_type.all_reading
-        pr = fact_type.preferred_reading
-        if (pr.role_sequence.all_role_ref.to_a[0].play)
-          verbaliser.prepare_role_sequence pr.role_sequence
-        end
-        verbaliser.create_subscripts(:rolenames)
-
-        print(fact_readings_with_constraints(verbaliser, fact_type)*",\n\t")
-        if (pr.role_sequence.all_role_ref.to_a[0].play)
-          print " where\n\t"+verbaliser.verbalise_over_role_sequence(pr.role_sequence)
-        end
-        puts(';')
-      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].object_type){|subclass, role|
-          next nil unless subclass and EntityType === role.object_type
-          role.object_type.supertypes_transitive.include?(subclass) ? role.object_type : nil
-        }
-      end
-
-      def dump_presence_constraint(c)
-        # Loose binding in PresenceConstraints is limited to explicit role players (in an occurs list)
-        # having no exact match, but having instead exactly one role of the same player in the readings.
-
-        verbaliser = ActiveFacts::Metamodel::Verbaliser.new
-        # For a mandatory constraint (min_frequency == 1, max == nil or 1) any subtyping step is over the proximate role player
-        # For all other presence constraints any subtyping step is over the counterpart player
-        role_proximity = c.min_frequency == 1 && [nil, 1].include?(c.max_frequency) ? :proximate : :counterpart
-        if role_proximity == :proximate
-          verbaliser.role_refs_have_subtype_steps(c.role_sequence)
-        else
-          join_over, joined_roles = ActiveFacts::Metamodel.plays_over(c.role_sequence.all_role_ref.map{|rr|rr.role}, role_proximity)
-          verbaliser.roles_have_same_player(joined_roles) if join_over
-        end
-
-        verbaliser.prepare_role_sequence(c.role_sequence, join_over)
-        # REVISIT: Need to discount role_adjuncts in here, since this constraint uses loose binding:
-        verbaliser.create_subscripts :loose
-
-        expanded_readings = verbaliser.verbalise_over_role_sequence(c.role_sequence, nil, role_proximity)
-        if c.min_frequency == 1 && c.max_frequency == nil and c.role_sequence.all_role_ref.size == 2
-          puts "either #{expanded_readings*' or '};"
-        else
-          roles = c.role_sequence.all_role_ref.map{|rr| rr.role }
-          players = c.role_sequence.all_role_ref.map{|rr| verbaliser.subscripted_player(rr) }
-          players.uniq! if role_proximity == :proximate
-          min, max = c.min_frequency, c.max_frequency
-          pl = (min&&min>1)||(max&&max>1) ? 's' : ''
-          puts \
-            "each #{players.size > 1 ? "combination " : ""}#{players*", "} occurs #{c.frequency} time#{pl} in\n\t"+
-            "#{Array(expanded_readings)*",\n\t"};"
-        end
-      end
-
-      def dump_set_comparison_constraint(c)
-        scrs = c.all_set_comparison_roles.sort_by{|scr| scr.ordinal}
-        role_sequences = scrs.map{|scr|scr.role_sequence}
-        transposed_role_refs = scrs.map{|scr| scr.role_sequence.all_role_ref_in_order.to_a}.transpose
-        verbaliser = ActiveFacts::Metamodel::Verbaliser.new
-
-        # Tell the verbaliser all we know, so it can figure out which players to subscript:
-        players = []
-        trace :subscript, "Preparing query across projected roles in set comparison constraint" do
-          transposed_role_refs.each do |role_refs|
-            verbaliser.role_refs_have_subtype_steps role_refs
-            join_over, = ActiveFacts::Metamodel.plays_over(role_refs.map{|rr| rr.role})
-            players << join_over
-          end
-        end
-        trace :subscript, "Preparing query between roles in set comparison constraint" do
-          role_sequences.each do |role_sequence|
-            trace :subscript, "role sequence is #{role_sequence.describe}" do
-              verbaliser.prepare_role_sequence role_sequence
-            end
-          end
-        end
-        verbaliser.create_subscripts :normal
-
-        if role_sequences.detect{|scr| scr.all_role_ref.detect{|rr| rr.play}}
-          # This set constraint has an explicit query. Verbalise it.
-
-          readings_list = role_sequences.
-            map do |rs|
-              verbaliser.verbalise_over_role_sequence(rs) 
-            end
-          if c.is_a?(ActiveFacts::Metamodel::SetEqualityConstraint)
-            puts readings_list.join("\n\tif and only if\n\t") + ';'
-            return
-          end
-          if readings_list.size == 2 && c.is_mandatory  # XOR constraint
-            puts "either " + readings_list.join(" or ") + " but not both;"
-            return
-          end
-
-          # Internal check: We must have located the players here
-          if i = players.index(nil)
-            rrs = transposed_role_refs[i]
-            raise "Internal error detecting constrained object types in query involving #{rrs.map{|rr| rr.role.fact_type.default_reading}.uniq*', '}"
-          end
-
-          # Loose binding will apply only to the constrained roles, not to all roles. Not handled here.
-          mode = c.is_mandatory ? "exactly one" : "at most one"
-          puts "for each #{players.map{|p| p.name}*", "} #{mode} of these holds:\n\t" +
-            readings_list.join(",\n\t") +
-            ';'
-          return
-        end
-
-        if c.is_a?(ActiveFacts::Metamodel::SetEqualityConstraint)
-          puts \
-            scrs.map{|scr|
-              verbaliser.verbalise_over_role_sequence(scr.role_sequence)
-            } * "\n\tif and only if\n\t" + ";"
-          return
-        end
-
-        # A constrained role may involve a subtyping step. We substitute the name of the supertype for all occurrences.
-        players = transposed_role_refs.map{|role_refs| common_supertype(role_refs.map{|rr| rr.role.object_type})}
-        raise "Constraint must cover matching roles" if players.compact.size < players.size
-
-        readings_expanded = scrs.
-          map do |scr|
-            # verbaliser.verbalise_over_role_sequence(scr.role_sequence)
-            # REVISIT: verbalise_over_role_sequence cannot do what we need here, because of the
-            # possibility of subtyping steps in the constrained roles across the different scr's
-            # The following code uses "players" and "constrained_roles" to create substitutions.
-            # These should instead be passed to the verbaliser (one variable per index, role_refs for each).
-            fact_types_processed = {}
-            constrained_roles = scr.role_sequence.all_role_ref_in_order.map{|rr| rr.role}
-            join_over, joined_roles = *Metamodel.plays_over(constrained_roles)
-            constrained_roles.map do |constrained_role|
-              fact_type = constrained_role.fact_type
-              next nil if fact_types_processed[fact_type] # Don't emit the same fact type twice (in case of objectification step)
-              fact_types_processed[fact_type] = true
-              reading = fact_type.reading_preferably_starting_with_role(constrained_role)
-              expand_constrained(verbaliser, reading, constrained_roles, players)
-            end.compact * " and "
-          end
-
-        if scrs.size == 2 && c.is_mandatory
-          puts "either " + readings_expanded*" or " + " but not both;"
-        else
-          mode = c.is_mandatory ? "exactly one" : "at most one"
-          puts "for each #{players.map{|p| p.name}*", "} #{mode} of these holds:\n\t" +
-            readings_expanded*",\n\t" + ';'
-        end
-      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, subset_fact_types =
-          c.subset_role_sequence.all_role_ref_in_order.map{|rr| [rr.role, rr.role.fact_type]}.transpose
-        superset_roles, superset_fact_types =
-          c.superset_role_sequence.all_role_ref_in_order.map{|rr| [rr.role, rr.role.fact_type]}.transpose
-        transposed_role_refs = [c.subset_role_sequence, c.superset_role_sequence].map{|rs| rs.all_role_ref_in_order.to_a}.transpose
-
-        verbaliser = ActiveFacts::Metamodel::Verbaliser.new
-        transposed_role_refs.each { |role_refs| verbaliser.role_refs_have_subtype_steps role_refs }
-        verbaliser.prepare_role_sequence c.subset_role_sequence
-        verbaliser.prepare_role_sequence c.superset_role_sequence
-        verbaliser.create_subscripts :normal
-
-        puts \
-          verbaliser.verbalise_over_role_sequence(c.subset_role_sequence) +
-          "\n\tonly if " +
-          verbaliser.verbalise_over_role_sequence(c.superset_role_sequence) +
-          ";"
-      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}"
-      end
-
-      def constraint_dump(c)
-	case c
-	when ActiveFacts::Metamodel::PresenceConstraint
-	  dump_presence_constraint(c)
-	when ActiveFacts::Metamodel::RingConstraint
-	  dump_ring_constraint(c)
-	when ActiveFacts::Metamodel::SetComparisonConstraint # includes SetExclusionConstraint, SetEqualityConstraint
-	  dump_set_comparison_constraint(c)
-	when ActiveFacts::Metamodel::SubsetConstraint
-	  dump_subset_constraint(c)
-	else
-	  "#{c.class.basename} #{c.name}: unhandled constraint type"
-	end
-      end
-
-      # Find the common supertype of these object_types.
-      def common_supertype(object_types)
-        common = object_types[0].supertypes_transitive
-        object_types[1..-1].each do |object_type|
-          common &= object_type.supertypes_transitive
-        end
-        common[0]
-      end
-
-      #============================================================
-      # Verbalisation functions for fact type and entity type definitions
-      #============================================================
-
-      def fact_readings_with_constraints(verbaliser, fact_type)
-        fact_constraints = @presence_constraints_by_fact[fact_type]
-        readings = []
-        define_role_names = true
-        fact_type.all_reading_by_ordinal.each do |reading|
-          readings << expanded_reading(verbaliser, reading, fact_constraints, define_role_names)
-          define_role_names = false     # No need to define role names in subsequent readings
-        end
-        readings
-      end
-
-      def expanded_reading(verbaliser, reading, fact_constraints, define_role_names)
-        # Arrange the roles in order they occur in this reading:
-        role_refs = reading.role_sequence.all_role_ref_in_order
-        role_numbers = reading.text.scan(/\{(\d)\}/).flatten.map{|m| Integer(m) }
-        roles = role_numbers.map{|m| role_refs[m].role }
-
-        # Find the constraints that constrain frequency over each role we can verbalise:
-        frequency_constraints = []
-        value_constraints = []
-        roles.each do |role|
-          value_constraints <<
-            if vc = role.role_value_constraint and !vc.ordered_dumped
-              vc.ordered_dumped!
-              vc.describe
-            else
-              nil
-            end
-
-          frequency_constraints <<
-            if (role == roles.last)   # On the last role of the reading, emit any presence constraint
-              constraint = fact_constraints.
-                detect do |c|  # Find a UC that spans all other Roles
-                  c.is_a?(ActiveFacts::Metamodel::PresenceConstraint) &&
-                    !c.ordered_dumped &&  # Already verbalised
-                    roles-c.role_sequence.all_role_ref.map(&:role) == [role]
-                end
-              constraint.ordered_dumped! if constraint
-              constraint && constraint.frequency
-            else
-              nil
-            end
-        end
-
-        expanded = verbaliser.expand_reading(reading, frequency_constraints, define_role_names, value_constraints)
-	expanded = "it is not the case that "+expanded if (reading.is_negative)
-
-        if (ft_rings = @ring_constraints_by_fact[reading.fact_type]) &&
-           (ring = ft_rings.detect{|rc| !rc.ordered_dumped})
-          ring.ordered_dumped!
-          append_ring_to_reading(expanded, ring)
-        end
-        expanded
-      end
-
-      # Expand this reading, substituting players[i].name for the each role in the i'th position in constrained_roles
-      def expand_constrained(verbaliser, reading, constrained_roles, players)
-        # Make sure that we refer to the constrained players by their common supertype (as passed in)
-        frequency_constraints = reading.role_sequence.all_role_ref.
-          map do |role_ref|
-            player = role_ref.role.object_type
-            i = constrained_roles.index(role_ref.role)
-            player = players[i] if i
-            [ nil, player.name ]
-          end
-        frequency_constraints = [] unless frequency_constraints.detect{|fc| fc[0] != "some" }
-
-	expanded = verbaliser.expand_reading(reading, frequency_constraints)
-	expanded = "it is not the case that "+expanded if (reading.is_negative)
-	expanded
-      end
-
-      def build_indices
-	@presence_constraints_by_fact = Hash.new{ |h, k| h[k] = [] }
-	@ring_constraints_by_fact = Hash.new{ |h, k| h[k] = [] }
-
-	@vocabulary.all_constraint.each { |c|
-	    case c
-	    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:
-		# trace "Single-fact constraint on #{fact_types[0].concept.guid}: #{c.name}"
-		(@presence_constraints_by_fact[fact_types[0]] ||= []) << c
-	      end
-	    when ActiveFacts::Metamodel::RingConstraint
-	      (@ring_constraints_by_fact[c.role.fact_type] ||= []) << c
-	    else
-	      # trace "Found unhandled constraint #{c.class} #{c.name}"
-	    end
-	  }
-      end
-
-    end
-  end
-
-  module Metamodel
-    class ValueType
-      def as_cql
-        parameters =
-          [ length != 0 || scale != 0 ? length : nil,
-            scale != 0 ? scale : nil
-          ].compact
-        parameters = parameters.length > 0 ? "("+parameters.join(",")+")" : ""
-
-        "#{name
-          } #{
-            (is_independent ? '[independent] ' : '')
-          }is written as #{
-            (supertype || self).name
-          }#{
-            parameters
-          }#{
-            unit && " "+unit.name
-          }#{
-	    transaction_phase && " auto-assigned at "+transaction_phase
-          }#{
-	    concept.all_context_note_as_relevant_concept.map do |cn|
-	      cn.verbalise
-	    end.join("\n")
-	  }#{
-            value_constraint && " "+value_constraint.describe
-          };"
-      end
-    end
-
-    class Unit
-      def as_cql
-        if !ephemera_url
-          if coefficient
-            # REVISIT: Use a smarter algorithm to switch to exponential form when there'd be lots of zeroes.
-            coefficient.numerator.to_s('F') +
-
-            if d = coefficient.denominator and d != 1
-              "/#{d}"
-	    else
-	      ''
-            end +
-
-            ' '
-          else
-            '1 '
-          end
-	else
-	  ''
-        end +
-
-	all_derivation_as_derived_unit.
-	  sort_by{|d| d.base_unit.name}.
-          # REVISIT: Sort base units
-          # REVISIT: convert negative powers to division?
-          map do |der|
-            base = der.base_unit
-            "#{base.name}#{der.exponent and der.exponent != 1 ? "^#{der.exponent}" : ''} "
-          end*'' +
-
-        if o = offset and o != 0
-          "+ #{o.to_s('F')} "
-	else
-	  ''
-        end +
-
-        "converts to #{name}#{plural_name ? '/'+plural_name : ''}" +
-
-	(coefficient && !coefficient.is_precise ?  ' approximately' : '') +
-
-	(ephemera_url ? " ephemera #{ephemera_url}" : '') +
-
-        ';'
-      end
-    end
-  end
-end
-
-ActiveFacts::Registry.generator('cql', ActiveFacts::Generate::CQL)