activefacts 0.8.16 → 0.8.18

data/lib/activefacts/generate/dm.rb

@@ -11,11 +11,11 @@
 #
 require 'activefacts/vocabulary'
 require 'activefacts/persistence'
-require 'activefacts/generate/oo'
+require 'activefacts/generate/helpers/oo'
 
 module ActiveFacts
   module Generate
-    class DM < OO #:nodoc:
+    class DM < Helpers::OO #:nodoc:
       # Generate SQL for DataMapper for an ActiveFacts vocabulary.
       # Invoke as
       #   afgen --dm[=options] <file>.cql
@@ -61,7 +61,11 @@ module ActiveFacts
 
       def key_fields(ref, reverse = false)
         # Compute and return child_key and parent_key if necessary
-        fk = ref.from.foreign_keys.detect{|k| k.reference == ref}
+        fk = ref.from.foreign_keys.detect{|k| k.jump_reference == ref}
+	unless fk
+	  debugger
+	  raise "foreign key not found for #{ref}"
+	end
         child_key = fk.from_columns.map{|c| column_name(c)}
         parent_key = fk.to_columns.map{|c| column_name(c)}
         if child_key != parent_key
@@ -130,7 +134,7 @@ module ActiveFacts
             puts "  include DataMapper::Resource\n\n" unless supertype
 
             columns = o.columns
-            o.references_from.each do |ref|
+            o.references_from.sort_by{|r| r.to_s}.each do |ref|
               # A (set of) columns
               if !columns
                 # absorbed subtypes didn't have columns populated
@@ -141,7 +145,7 @@ module ActiveFacts
               # debugger if ref_columns.detect{|c| [:subtype, :supertype].include?(c.references[0].role_type)}
               ref_columns = columns.select{|c| c.references[0] == ref }
               # puts "  \# #{ref.reading}:"
-              ref_columns.each do |column|
+              ref_columns.sort_by{|column| column_name(column)}.each do |column|
                 type, params, constraints = column.type
                 length = params[:length]
                 length &&= length.to_i
@@ -191,7 +195,7 @@ module ActiveFacts
 
             # Emit the "has n," associations
             # REVISIT: Need to use ActiveSupport to pluralise these names, or disable inflexion somehow.
-            o.references_to.each do |ref|
+            o.references_to.sort_by{|r| [r.to_s, (r.from_role||r.to_role).ordinal] }.each do |ref|
               next unless is_model[ref.from]
               constraint = ''
               association_type =
@@ -271,3 +275,5 @@ module ActiveFacts
     end
   end
 end
+
+ActiveFacts::Registry.generator('dm', ActiveFacts::Generate::DM)

data/lib/activefacts/generate/help.rb

@@ -14,16 +14,34 @@ module ActiveFacts
     class HELP
     private
       def initialize(vocabulary, *options)
+	generators = $:.
+	  map{|path|
+            Dir[path+"/activefacts/generate/**/*.rb"].
+	      reject{|p|
+		p =~ %r{/(transform|helpers)/}
+	      }.
+	      map{|p|
+                p.sub(%r{.*/activefacts/generate/}, '').sub(/\.rb/,'')
+              }
+          }
+	transformers = $:.
+	  map{|path|
+            Dir[path+"/activefacts/generate/transform/**/*.rb"].
+	      map{|p|
+                p.sub(%r{.*/activefacts/generate/}, '').sub(/\.rb/,'')
+	      }
+          }
+
         puts %Q{
-Usage: afgen --generator[=options] file.inp[=options]
+Usage: afgen [ --transformer[=options] ... ] [ --generator[=options] ... ] file.inp[=options]
         options are comma-separated lists. Use =help to get more information.
 
 Available generators are:
-        #{$:.map{|path|
-            Dir[path+"/activefacts/generate/**.rb"].map{|p|
-                p.sub(%r{.*/}, '').sub(/\.rb/,'')
-            }
-        }.flatten.uniq.sort.join("\n\t")
+        #{generators.flatten.uniq.sort.join("\n\t")
+}
+
+Available transformers are:
+        #{transformers.flatten.uniq.sort.join("\n\t")
 }
 
 inp is the name of a file input handler. Available input handlers are:
@@ -43,3 +61,4 @@ inp is the name of a file input handler. Available input handlers are:
   end
 end
 
+ActiveFacts::Registry.generator('help', ActiveFacts::Generate::HELP)

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

@@ -0,0 +1,195 @@
+#
+#       ActiveFacts Generators.
+#       Base class for generators of class libraries in any object-oriented language that supports the ActiveFacts API.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/vocabulary'
+require 'activefacts/generate/helpers/ordered'
+
+module ActiveFacts
+  module Generate
+    module Helpers
+      # Base class for generators of object-oriented class libraries for an ActiveFacts vocabulary.
+      class OO < OrderedDumper  #:nodoc:
+        def constraints_dump(constraints_used)
+          # Stub, not needed.
+        end
+
+        def value_type_banner
+        end
+
+        def value_type_end
+        end
+
+        def entity_type_dump(o)
+          @object_types_dumped[o] = true
+          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
+          @constraints_used[pi] = true
+        end
+
+        # Dump the roles for an object type (excluding the roles of a fact type which is objectified)
+        def roles_dump(o)
+          o.all_role.
+            select{|role|
+              role.fact_type.all_role.size <= 2 &&
+                !role.fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
+            }.
+            sort_by{|role|
+              preferred_role_name(role.fact_type.all_role.select{|r2| r2 != role}[0] || role, o)
+            }.each{|role| 
+              role_dump(role)
+            }
+        end
+
+        def role_dump(role)
+          return if role.fact_type.entity_type
+
+          fact_type = role.fact_type
+          if fact_type.all_role.size == 1
+            unary_dump(role, preferred_role_name(role))
+            return
+          elsif fact_type.all_role.size != 2
+            # Shouldn't come here, except perhaps for an invalid model
+            return  # ternaries and higher are always objectified
+          end
+
+          # REVISIT: TypeInheritance
+          if fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+            # debug "Ignoring role #{role} in #{fact_type}, subtype fact type"
+            # REVISIT: What about secondary subtypes?
+            # REVISIT: What about dumping the relational mapping when using separate tables?
+            return
+          end
+
+          return unless role.is_functional
+
+          other_role = fact_type.all_role.select{|r| r != role}[0]
+          other_role_name = preferred_role_name(other_role)
+          other_player = other_role.object_type
+
+          # It's a one_to_one if there's a uniqueness constraint on the other role:
+          one_to_one = other_role.is_functional
+          return if one_to_one &&
+              !@object_types_dumped[other_role.object_type]
+
+          # Find role name:
+          role_method = preferred_role_name(role)
+          other_role_method = one_to_one ? role_method : "all_"+role_method
+          # puts "---"+role.role_name if role.role_name
+          if other_role_name != other_player.name.gsub(/ /,'_').snakecase and
+            role_method == role.object_type.name.gsub(/ /,'_').snakecase
+            other_role_method += "_as_#{other_role_name}"
+          end
+
+          role_name = role_method
+          role_name = nil if role_name == role.object_type.name.gsub(/ /,'_').snakecase
+
+          binary_dump(role, other_role_name, other_player, role.is_mandatory, one_to_one, nil, role_name, other_role_method)
+        end
+
+        def preferred_role_name(role, is_for = nil)
+          return "" if role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+
+          if is_for && role.fact_type.entity_type == is_for && role.fact_type.all_role.size == 1
+            return role.object_type.name.gsub(/[- ]/,'_').snakecase
+          end
+
+          # debug "Looking for preferred_role_name of #{describe_fact_type(role.fact_type, role)}"
+          reading = role.fact_type.preferred_reading
+          preferred_role_ref = reading.role_sequence.all_role_ref.detect{|reading_rr|
+              reading_rr.role == role
+            }
+
+          # Unaries are a hack, with only one role for what is effectively a binary:
+          if (role.fact_type.all_role.size == 1)
+            return (role.role_name && role.role_name.snakecase) ||
+              reading.text.gsub(/ *\{0\} */,'').gsub(/[- ]/,'_').downcase
+          end
+
+          # debug "\tleading_adjective=#{(p=preferred_role_ref).leading_adjective}, role_name=#{role.role_name}, role player=#{role.object_type.name}, trailing_adjective=#{p.trailing_adjective}"
+          role_words = []
+          role_name = role.role_name
+          role_name = nil if role_name == ""
+
+          # REVISIT: Consider whether NOT to use the adjective if it's a prefix of the role_name
+          la = preferred_role_ref.leading_adjective
+          role_words << la.gsub(/[- ]/,'_') if la && la != "" and !role.role_name
+
+          role_words << (role_name || role.object_type.name.gsub(/[- ]/,'_'))
+          # REVISIT: Same when trailing_adjective is a suffix of the role_name
+          ta = preferred_role_ref.trailing_adjective
+          role_words << ta.gsub(/[- ]/,'_') if ta && ta != "" and !role_name
+          n = role_words.map{|w| w.gsub(/([a-z])([A-Z]+)/,'\1_\2').downcase}*"_"
+          # debug "\tresult=#{n}"
+          n.gsub(' ','_') 
+        end
+
+        def skip_fact_type(f)
+          # REVISIT: There might be constraints we have to merge into the nested entity or subtype.  These will come up as un-handled constraints.
+          !f.entity_type ||
+            f.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+        end
+
+        # An objectified fact type has internal roles that are always "has_one":
+        def fact_roles_dump(fact_type)
+          fact_type.all_role.sort_by{|role|
+              preferred_role_name(role, fact_type.entity_type)
+            }.each{|role| 
+              role_name = preferred_role_name(role, fact_type.entity_type)
+              one_to_one = role.all_role_ref.detect{|rr|
+                rr.role_sequence.all_role_ref.size == 1 &&
+                rr.role_sequence.all_presence_constraint.detect{|pc|
+                  pc.max_frequency == 1
+                }
+              }
+              as = role_name != role.object_type.name.gsub(/ /,'_').snakecase ? "_as_#{role_name}" : ""
+              raise "Fact #{fact_type.describe} type is not objectified" unless fact_type.entity_type
+              other_role_method = (one_to_one ? "" : "all_") + 
+                fact_type.entity_type.name.gsub(/ /,'_').snakecase +
+                as
+              binary_dump(role, role_name, role.object_type, true, one_to_one, nil, nil, other_role_method)
+            }
+        end
+
+        def entity_type_banner
+        end
+
+        def entity_type_group_end
+        end
+
+        def append_ring_to_reading(reading, ring)
+          # REVISIT: debug "Should override append_ring_to_reading"
+        end
+
+        def fact_type_banner
+        end
+
+        def fact_type_end
+        end
+
+        def constraint_banner
+          # debug "Should override constraint_banner"
+        end
+
+        def constraint_end
+          # debug "Should override constraint_end"
+        end
+
+        def constraint_dump(c)
+          # debug "Should override constraint_dump"
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,589 @@
+#
+#       ActiveFacts Generators.
+#       Generation support superclass that sequences entity types to avoid forward references.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/api'
+
+module ActiveFacts
+  module Generate #:nodoc:
+    module Helpers #:nodoc:
+      class OrderedDumper #:nodoc:
+        # Base class for generators of object-oriented class libraries for an ActiveFacts vocabulary.
+        def initialize(vocabulary, *options)
+          @vocabulary = vocabulary
+          @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+          options.each{|option| set_option(option) }
+        end
+
+        def set_option(option)
+        end
+
+        def puts(*a)
+          @out.puts *a
+        end
+
+        def print(*a)
+          @out.print *a
+        end
+
+        def generate(out = $>)
+          @out = out
+          vocabulary_start(@vocabulary)
+
+          build_indices
+          @object_types_dumped = {}
+          @fact_types_dumped = {}
+          units_dump()
+          value_types_dump()
+          entity_types_dump()
+          fact_types_dump()
+          constraints_dump(@constraints_used)
+          vocabulary_end
+        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:
+                  # debug "Single-fact constraint on #{fact_types[0].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
+                # debug "Found unhandled constraint #{c.class} #{c.name}"
+              end
+            }
+          @constraints_used = {}
+        end
+
+        def units_dump
+          done_banner = false
+          units = @vocabulary.all_unit.to_a.sort_by{|u| u.name.gsub(/ /,'')}
+          while units.size > 0
+            i = 0
+            while i < units.size
+              unit = units[i]
+              i += 1
+
+              # Skip this one if the precursors haven't yet been dumped:
+              next if unit.all_derivation_as_derived_unit.detect{|d| units.include?(d.base_unit) }
+
+              # Even if we skip, we're done with this unit
+              units.delete(unit)
+              i -= 1
+
+              # Skip value-type derived units
+              next if unit.name =~ /\^/
+
+              if !done_banner
+                done_banner = true
+                units_banner
+              end
+              unit_dump(unit)
+            end
+          end
+          units_end if done_banner
+        end
+
+        def value_types_dump
+          done_banner = false
+          @value_type_dumped = {}
+          @vocabulary.all_object_type.sort_by{|o| o.name.gsub(/ /,'')}.each{|o|
+              next unless o.is_a?(ActiveFacts::Metamodel::ValueType)
+
+              value_type_banner unless done_banner
+              done_banner = true
+
+              value_type_chain_dump(o)
+              @object_types_dumped[o] = true
+            }
+          value_type_end if done_banner
+        end
+
+        # Ensure that supertype gets dumped first
+        def value_type_chain_dump(o)
+          return if @value_type_dumped[o]
+          value_type_chain_dump(o.supertype) if (o.supertype && !@value_type_dumped[o.supertype])
+          value_type_dump(o) if o.name != "_ImplicitBooleanValueType"
+          @value_type_dumped[o] = true
+        end
+
+        # Try to dump entity types in order of name, but we need
+        # to dump ETs before they're referenced in preferred ids
+        # if possible (it's not always, there may be loops!)
+        def entity_types_dump
+          # Build hash tables of precursors and followers to use:
+          @precursors, @followers = *build_entity_dependencies
+
+          done_banner = false
+          sorted = @vocabulary.all_object_type.select{|o|
+            o.is_a?(ActiveFacts::Metamodel::EntityType) # and !o.fact_type
+          }.sort_by{|o| o.name.gsub(/ /,'')}
+          panic = nil
+          while true do
+            count_this_pass = 0
+            skipped_this_pass = 0
+            sorted.each{|o|
+                next if @object_types_dumped[o]    # Already done
+
+                # Can we do this yet?
+                if (o != panic and                  # We don't *have* to do it (panic mode)
+                    (p = @precursors[o]) and         # There might be...
+                    p.size > 0)                     # precursors - still blocked
+                  skipped_this_pass += 1
+                  next
+                end
+
+                entity_type_banner unless done_banner
+                done_banner = true
+
+                # We're going to emit o - remove it from precursors of others:
+                (@followers[o]||[]).each{|f|
+                    @precursors[f] -= [o]
+                  }
+                count_this_pass += 1
+                panic = nil
+
+                if (o.fact_type)
+                  fact_type_dump_with_dependents(o.fact_type)
+                  released_fact_types_dump(o)
+                else
+                  entity_type_dump(o)
+                  released_fact_types_dump(o)
+                end
+
+                entity_type_group_end
+              }
+
+              # Check that we made progress if there's any to make:
+              if count_this_pass == 0 && skipped_this_pass > 0
+                if panic        # We were already panicing... what to do now?
+                  # This won't happen again unless the above code is changed to decide it can't dump "panic".
+                  raise "Unresolvable cycle of forward references: " +
+                    (bad = sorted.select{|o| EntityType === o && !@object_types_dumped[o]}).map{|o| o.name }.inspect +
+                    ":\n\t" + bad.map{|o|
+                      o.name +
+                      ": " +
+                      @precursors[o].map{|p| p.name}.uniq.inspect
+                    } * "\n\t" + "\n"
+                else
+                  # Find the object that has the most followers and no fwd-ref'd supertypes:
+                  # This selection might be better if we allow PI roles to be fwd-ref'd...
+                  panic = sorted.
+                    select{|o| !@object_types_dumped[o] }.
+                    sort_by{|o|
+                        f = @followers[o] || []; 
+                        o.supertypes.detect{|s| !@object_types_dumped[s] } ? 0 : -f.size
+                      }[0]
+                  # debug "Panic mode, selected #{panic.name} next"
+                end
+              end
+
+              break if skipped_this_pass == 0       # All done.
+
+          end
+        end
+
+        def identified_by(o, pi)
+          # Different adjectives might be used for different readings.
+          # Here, we must find the role_ref containing the adjectives that we need for each identifier,
+          # which will be attached to the uniqueness constraint on this object in the binary FT that
+          # attaches that identifying role.
+          identifying_role_refs = pi.role_sequence.all_role_ref.sort_by{|role_ref| role_ref.ordinal}
+
+          # We need to get the adjectives for the roles from the identifying fact's preferred readings:
+          identifying_facts = ([o.fact_type]+identifying_role_refs.map{|rr| rr.role.fact_type }).compact.uniq
+
+          identification = identified_by_roles_and_facts(o, identifying_role_refs, identifying_facts)
+
+          identification
+        end
+
+        def describe_fact_type(fact_type, highlight = nil)
+          (fact_type.entity_type ? fact_type.entity_type.name : "")+
+          describe_roles(fact_type.all_role, highlight)
+        end
+
+        def describe_roles(roles, highlight = nil)
+          "("+
+          roles.map{|role| role.object_type.name + (role == highlight ? "*" : "")}*", "+
+          ")"
+        end
+
+        def describe_role_sequence(role_sequence)
+          "("+
+          role_sequence.all_role_ref.map{|role_ref| role_ref.role.object_type.name }*", "+
+          ")"
+        end
+
+        # This returns an array of two hash tables each keyed by an EntityType.
+        # The values of each hash entry are the precursors and followers (respectively) of that entity.
+        def build_entity_dependencies
+          @vocabulary.all_object_type.inject([{},{}]) { |a, o|
+              if o.is_a?(ActiveFacts::Metamodel::EntityType)
+                precursor = a[0]
+                follower = a[1]
+                blocked = false
+                pi = o.preferred_identifier
+                if pi
+                  pi.role_sequence.all_role_ref.each{|rr|
+                      role = rr.role
+                      player = role.object_type
+                      # REVISIT: If we decide to emit value types on demand, need to remove this:
+                      next unless player.is_a?(ActiveFacts::Metamodel::EntityType)
+                      # player is a precursor of o
+                      (precursor[o] ||= []) << player if (player != o)
+                      (follower[player] ||= []) << o if (player != o)
+                    }
+                end
+                if o.fact_type
+                  o.fact_type.all_role.each do |role|
+                    next unless role.object_type.is_a?(ActiveFacts::Metamodel::EntityType)
+                    (precursor[o] ||= []) << role.object_type
+                    (follower[role.object_type] ||= []) << o
+                  end
+                end
+
+                # Supertypes are precursors too:
+                subtyping = o.all_type_inheritance_as_supertype
+                next a if subtyping.size == 0
+                subtyping.each{|ti|
+                    # debug ti.class.roles.verbalise; debug "all_type_inheritance_as_supertype"; exit
+                    s = ti.subtype
+                    (precursor[s] ||= []) << o
+                    (follower[o] ||= []) << s
+                  }
+  #            REVISIT: Need to use this to order ValueTypes after their supertypes
+  #            else
+  #              o.all_value_type_as_supertype.each { |s|
+  #                (precursor[s] ||= []) << o
+  #                (follower[o] ||= []) << s
+  #              }
+              end
+              a
+            }
+        end
+
+        # Dump all fact types for which all precursors (of which "o" is one) have been emitted:
+        def released_fact_types_dump(o)
+          roles = o.all_role
+          begin
+            progress = false
+            roles.map(&:fact_type).uniq.select{|fact_type|
+                # The fact type hasn't already been dumped but all its role players have
+                !@fact_types_dumped[fact_type] &&
+                  !fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType) &&
+                  !fact_type.all_role.detect{|r| !@object_types_dumped[r.object_type] } &&
+                  !fact_type.entity_type &&
+                  derivation_precursors_complete(fact_type)
+                # REVISIT: A derived fact type must not be dumped before its dependent fact types have
+              }.sort_by{|fact_type|
+                fact_type_key(fact_type)
+              }.each{|fact_type|
+                fact_type_dump_with_dependents(fact_type)
+                # Objectified Fact Types may release additional fact types
+                roles += fact_type.entity_type.all_role.sort_by{|role| role.ordinal} if fact_type.entity_type
+                progress = true
+              }
+          end while progress
+        end
+
+        def derivation_precursors_complete(fact_type)
+          pr = fact_type.preferred_reading
+          return true unless jr = pr.role_sequence.all_role_ref.to_a[0].play
+          query = jr.variable.query
+          return false if query.all_step.detect{|js| !@fact_types_dumped[js.fact_type] }
+          return false if query.all_variable.detect{|jn| !@object_types_dumped[jn.object_type] }
+          true
+        end
+
+        def skip_fact_type(f)
+          # REVISIT: There might be constraints we have to merge into the nested entity or subtype. 
+          # These will come up as un-handled constraints:
+          pcs = @presence_constraints_by_fact[f]
+          return true if f.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+          return false if f.entity_type && !@object_types_dumped[f.entity_type]
+          pcs && pcs.size > 0 && !pcs.detect{|c| !@constraints_used[c] }
+        end
+
+        # Dump one fact type.
+        # Include as many as possible internal constraints in the fact type readings.
+        def fact_type_dump_with_dependents(fact_type)
+          @fact_types_dumped[fact_type] = true
+          # debug "Trying to dump FT again" if @fact_types_dumped[fact_type]
+          return if skip_fact_type(fact_type)
+
+          if (et = fact_type.entity_type) &&
+              (pi = et.preferred_identifier) &&
+              pi.role_sequence.all_role_ref.detect{|rr| rr.role.fact_type != fact_type }
+            # debug "Dumping objectified FT #{et.name} as an entity, non-fact PI"
+            entity_type_dump(et)
+            released_fact_types_dump(et)
+            return
+          end
+
+          fact_constraints = @presence_constraints_by_fact[fact_type]
+
+          # debug "for fact type #{fact_type.to_s}, considering\n\t#{fact_constraints.map(&:to_s)*",\n\t"}"
+          # debug "#{fact_type.name} has readings:\n\t#{fact_type.readings.map(&:name)*"\n\t"}"
+          # debug "Dumping #{fact_type.guid} as a fact type"
+
+          # Fact types that aren't nested have no names
+          name = fact_type.entity_type && fact_type.entity_type.name
+
+          fact_type_dump(fact_type, name)
+
+          # REVISIT: Go through the residual constraints and re-process appropriate readings to show them
+
+          @fact_types_dumped[fact_type] = true
+          @object_types_dumped[fact_type.entity_type] = true if fact_type.entity_type
+        end
+
+        # Dump fact types.
+        def fact_types_dump
+          # REVISIT: Uniqueness on the LHS of a binary can be coded using "distinct"
+
+          # The only fact types that can be remaining are those involving only value types,
+          # since we dumped every fact type as soon as all relevant entities were dumped.
+          # Iterate over all fact types of all value types, looking for these strays.
+
+          done_banner = false
+          fact_collection = @vocabulary.constellation.FactType
+          fact_collection.keys.select{|fact_id|
+                  fact_type = fact_collection[fact_id] and
+                  !fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) and
+                  !fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType) and
+                  !@fact_types_dumped[fact_type] and
+                  !skip_fact_type(fact_type) and
+                  !fact_type.all_role.detect{|r| r.object_type.is_a?(ActiveFacts::Metamodel::EntityType) }
+              }.sort_by{|fact_id|
+                  fact_type = fact_collection[fact_id]
+                  fact_type_key(fact_type)
+              }.each{|fact_id|
+                  fact_type = fact_collection[fact_id]
+
+                  fact_type_banner unless done_banner
+                  done_banner = true
+                  fact_type_dump_with_dependents(fact_type)
+            }
+
+          # REVISIT: Find out why some fact types are missed during entity dumping:
+          @vocabulary.constellation.FactType.values.select{|fact_type|
+              !fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) &&
+                !fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
+            }.sort_by{|fact_type|
+              fact_type_key(fact_type)
+            }.each{|fact_type|
+              next if @fact_types_dumped[fact_type]
+              # debug "Not dumped #{fact_type.verbalise}(#{fact_type.all_role.map{|r| r.object_type.name}*", "})"
+              fact_type_banner unless done_banner
+              done_banner = true
+              fact_type_dump_with_dependents(fact_type)
+            }
+
+          fact_type_end if done_banner
+          # unused = constraints - @constraints_used.keys
+          # debug "residual constraints are\n\t#{unused.map(&:to_s)*",\n\t"}"
+
+          @constraints_used
+        end
+
+        def fact_instances_dump
+          @vocabulary.fact_types.each{|f|
+              # Dump the instances:
+              f.facts.each{|i|
+                raise "REVISIT: Not dumping fact instances"
+                debug "\t\t"+i.to_s
+              }
+          }
+        end
+
+        # Arrange for objectified fact types to appear in order of name, after other fact types.
+        # Facts are ordered alphabetically by the names of their role players,
+        # then by preferred_reading (subtyping fact types have no preferred_reading).
+        def fact_type_key(fact_type)
+          role_names =
+            if (pr = fact_type.preferred_reading)
+              pr.role_sequence.
+                all_role_ref.
+                sort_by{|role_ref| role_ref.ordinal}.
+                map{|role_ref| [ role_ref.leading_adjective, role_ref.role.object_type.name, role_ref.trailing_adjective ].compact*"-" } +
+                [pr.text]
+            else
+              fact_type.all_role.map{|role| role.object_type.name }
+            end
+
+          (fact_type.entity_type ? [fact_type.entity_type.name] : [""]) + role_names
+        end
+
+        def role_ref_key(role_ref)
+          [ role_ref.leading_adjective, role_ref.role.object_type.name, role_ref.trailing_adjective ].compact*"-" +
+          " in " +
+          role_ref.role.fact_type.preferred_reading.expand
+        end
+
+        def constraint_sort_key(c)
+          case c
+          when ActiveFacts::Metamodel::RingConstraint
+            [ 1,
+              c.ring_type,
+              c.role.object_type.name,
+              c.other_role.object_type.name,
+              c.name||""
+            ]
+          when ActiveFacts::Metamodel::SetExclusionConstraint
+            [ 2+(c.is_mandatory ? 0 : 1),
+              c.all_set_comparison_roles.map{|scrs|
+                scrs.role_sequence.all_role_ref.map{|rr|
+                  role_ref_key(rr)
+                }
+              },
+              c.name||""
+            ]
+          when ActiveFacts::Metamodel::SetEqualityConstraint
+            [ 4,
+              c.all_set_comparison_roles.map{|scrs|
+                scrs.role_sequence.all_role_ref.map{|rr|
+                  role_ref_key(rr)
+                }
+              },
+              c.name||""
+            ]
+          when ActiveFacts::Metamodel::SubsetConstraint
+            [ 5,
+              [c.superset_role_sequence, c.subset_role_sequence].map{|rs|
+                rs.all_role_ref.map{|rr|
+                  role_ref_key(rr)
+                }
+              },
+              c.name||""
+            ]
+          when ActiveFacts::Metamodel::PresenceConstraint
+            [ 6,
+              c.role_sequence.all_role_ref.map{|rr|
+                role_ref_key(rr)
+              },
+              c.name||""
+            ]
+          end
+        end
+
+        def constraints_dump(except = {})
+          heading = false
+          @vocabulary.all_constraint.reject{|c| except[c]}.sort_by{ |c| constraint_sort_key(c) }.each do|c|
+            # Skip some PresenceConstraints:
+            if c.is_a?(ActiveFacts::Metamodel::PresenceConstraint)
+              # Skip uniqueness constraints that cover all roles of a fact type, they're implicit
+              fact_types = c.role_sequence.all_role_ref.map{|rr| rr.role.fact_type}.uniq
+              if fact_types.size == 1 &&
+                !c.role_sequence.all_role_ref.detect{|rr| rr.play } &&
+                c.max_frequency == 1 &&         # Uniqueness
+                fact_types[0].all_role.size == c.role_sequence.all_role_ref.size
+                next
+              end
+
+              # Skip internal PresenceConstraints over TypeInheritances:
+              next if c.role_sequence.all_role_ref.size == 1 &&
+                fact_types[0].is_a?(ActiveFacts::Metamodel::TypeInheritance)
+            end
+
+            constraint_banner unless heading
+            heading = true
+
+            # Skip presence constraints on value types:
+            # next if ActiveFacts::PresenceConstraint === c &&
+            #     ActiveFacts::ValueType === c.object_type
+            constraint_dump(c)
+          end
+          constraint_end if heading
+        end
+
+        def vocabulary_start(vocabulary)
+          debug "Should override vocabulary_start"
+        end
+
+        def vocabulary_end
+          debug "Should override vocabulary_end"
+        end
+
+        def units_banner
+        end
+
+        def units_end
+        end
+
+        def unit_dump unit
+        end
+
+        def value_type_banner
+          debug "Should override value_type_banner"
+        end
+
+        def value_type_end
+          debug "Should override value_type_end"
+        end
+
+        def value_type_dump(o)
+          debug "Should override value_type_dump"
+        end
+
+        def entity_type_banner
+          debug "Should override entity_type_banner"
+        end
+
+        def entity_type_group_end
+          debug "Should override entity_type_group_end"
+        end
+
+        def non_subtype_dump(o, pi)
+          debug "Should override non_subtype_dump"
+        end
+
+        def subtype_dump(o, supertypes, pi = nil)
+          debug "Should override subtype_dump"
+        end
+
+        def append_ring_to_reading(reading, ring)
+          debug "Should override append_ring_to_reading"
+        end
+
+        def fact_type_banner
+          debug "Should override fact_type_banner"
+        end
+
+        def fact_type_end
+          debug "Should override fact_type_end"
+        end
+
+        def fact_type_dump(fact_type, name)
+          debug "Should override fact_type_dump"
+        end
+
+        def constraint_banner
+          debug "Should override constraint_banner"
+        end
+
+        def constraint_end
+          debug "Should override constraint_end"
+        end
+
+        def constraint_dump(c)
+          debug "Should override constraint_dump"
+        end
+
+      end
+
+      def dump(vocabulary, out = $>)
+        OrderedDumper.new(vocabulary).dump(out)
+      end
+    end
+  end
+end