activefacts-generators 1.8.3 → 1.9.0

data/lib/activefacts/generators/cql.rb

@@ -18,7 +18,7 @@ module ActiveFacts
     private
       def vocabulary_start
         puts "vocabulary #{@vocabulary.name};\n\n"
-	build_indices
+        build_indices
       end
 
       def vocabulary_end
@@ -29,7 +29,7 @@ module ActiveFacts
       end
 
       def unit_dump unit
-	puts unit.as_cql
+        puts unit.as_cql
       end
 
       def units_end
@@ -45,7 +45,7 @@ module ActiveFacts
       end
 
       def data_type_dump(o)
-	value_type_dump(o, o.name, {}) if o.all_role.size > 0
+        value_type_dump(o, o.name, {}) if o.all_role.size > 0
       end
 
       def value_type_dump(o, super_type_name, facets)
@@ -54,22 +54,22 @@ module ActiveFacts
 
         # REVISIT: A ValueType that is only used as a reference mode need not be emitted here.
 
-	puts o.as_cql
+        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
+        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)
@@ -193,9 +193,9 @@ module ActiveFacts
         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") +
+          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
@@ -230,9 +230,9 @@ module ActiveFacts
         (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") +
+          entity_type.concept.all_context_note_as_relevant_concept.map do |cn|
+            cn.verbalise
+          end.join("\n") +
           " where\n\t"+identifying_fact_text
       end
 
@@ -294,8 +294,8 @@ module ActiveFacts
           # Alternate identification of objectified fact type?
           primary_supertype = supertypes[0]
           if fact_type.all_role.size > 1 and
-	      pi = fact_type.entity_type.preferred_identifier and
-	      primary_supertype && primary_supertype.preferred_identifier != pi
+              pi = fact_type.entity_type.preferred_identifier and
+              primary_supertype && primary_supertype.preferred_identifier != pi
             puts identified_by(o, pi) + ';'
             return
           end
@@ -369,7 +369,7 @@ module ActiveFacts
         if role_proximity == :proximate
           verbaliser.role_refs_have_subtype_steps(c.role_sequence)
         else
-	  roles = c.role_sequence.all_role_ref.map{|rr|rr.role}
+          roles = c.role_sequence.all_role_ref.map{|rr|rr.role}
           join_over, joined_roles = ActiveFacts::Metamodel.plays_over(roles, role_proximity)
           verbaliser.roles_have_same_player(joined_roles) if join_over
         end
@@ -514,18 +514,18 @@ module ActiveFacts
       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
+        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.
@@ -586,7 +586,7 @@ module ActiveFacts
         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)
+        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})
@@ -608,29 +608,29 @@ module ActiveFacts
           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
+        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
-	  }
+        @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
@@ -655,12 +655,12 @@ module ActiveFacts
           }#{
             unit && " "+unit.name
           }#{
-	    transaction_phase && " auto-assigned at "+transaction_phase
+            transaction_phase && " auto-assigned at "+transaction_phase
+          }#{
+            concept.all_context_note_as_relevant_concept.map do |cn|
+              cn.verbalise
+            end.join("\n")
           }#{
-	    concept.all_context_note_as_relevant_concept.map do |cn|
-	      cn.verbalise
-	    end.join("\n")
-	  }#{
             value_constraint && " "+value_constraint.describe
           };"
       end
@@ -675,20 +675,20 @@ module ActiveFacts
 
             if d = coefficient.denominator and d != 1
               "/#{d}"
-	    else
-	      ''
+            else
+              ''
             end +
 
             ' '
           else
             '1 '
           end
-	else
-	  ''
+        else
+          ''
         end +
 
-	all_derivation_as_derived_unit.
-	  sort_by{|d| d.base_unit.name}.
+        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|
@@ -698,15 +698,15 @@ module ActiveFacts
 
         if o = offset and o != 0
           "+ #{o.to_s('F')} "
-	else
-	  ''
+        else
+          ''
         end +
 
         "converts to #{name}#{plural_name ? '/'+plural_name : ''}" +
 
-	(coefficient && !coefficient.is_precise ?  ' approximately' : '') +
+        (coefficient && !coefficient.is_precise ?  ' approximately' : '') +
 
-	(ephemera_url ? " ephemera #{ephemera_url}" : '') +
+        (ephemera_url ? " ephemera #{ephemera_url}" : '') +
 
         ';'
       end

data/lib/activefacts/generators/diagrams/json.rb

@@ -16,322 +16,322 @@ module ActiveFacts
       #   afgen --diagrams/json <file>.cql=diagrams
       class JSON
       private
-	def initialize(vocabulary)
-	  @vocabulary = vocabulary
-	  @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
-	end
+        def initialize(vocabulary)
+          @vocabulary = vocabulary
+          @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+        end
 
-	def puts(*a)
-	  @out.puts *a
-	end
+        def puts(*a)
+          @out.puts *a
+        end
 
       public
-	def generate(out = $>)
-	  @out = out
-	  uuids = {}
-
-	  puts "{ model: '#{@vocabulary.name}',\n" +
-	  "diagrams: [\n#{
-	    @vocabulary.all_diagram.sort_by{|o| o.name.gsub(/ /,'')}.map do |d|
-	      j = {:uuid => (uuids[d] ||= uuid_from_id(d)), :name => d.name}
-	      "    #{j.to_json}"
-	    end*",\n"
-	  }\n  ],"
-
-	  object_types = @vocabulary.all_object_type.sort_by{|o| o.name.gsub(/ /,'')}
-	  puts "  object_types: [\n#{
-	    object_types.sort_by{|o|o.identifying_role_values.inspect}.map do |o|
-	      uuids[o] ||= uuid_from_id(o)
-	      ref_mode = nil
-	      if o.is_a?(ActiveFacts::Metamodel::EntityType) and
-		p = o.preferred_identifier and
-		(rrs = p.role_sequence.all_role_ref).size == 1 and
-		!(o.fact_type && o.fact_type.all_role.size == 1) and
-		(r = rrs.single.role).fact_type != o.fact_type and
-		r.object_type.is_a?(ActiveFacts::Metamodel::ValueType) and
-		!r.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-		ref_mode = "#{r.object_type.name}"
-		ref_mode.sub!(%r{#{o.name} *}, '.')
-	      end
-	      j = {
-		:uuid => uuids[o],
-		:name => o.name,
-		:shapes => o.all_object_type_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
-		  x = { :diagram => uuids[shape.orm_diagram],
-		    :is_expanded => shape.is_expanded,
-		    :uuid => uuid_from_id(shape),
-		    :x => shape.location.x,
-		    :y => shape.location.y
-		  }
-		  x[:is_expanded] = true if ref_mode && shape.is_expanded  # Don't show the reference mode
-		  x
-		end
-	      }
-	      j[:ref_mode] = ref_mode if ref_mode
-	      j[:independent] = true if o.is_independent
-
-	      if o.is_a?(ActiveFacts::Metamodel::EntityType)
-		# Entity Type may be objectified, and may have supertypes:
-		if o.fact_type
-		  uuid = (uuids[o.fact_type] ||= uuid_from_id(o.fact_type))
-		  j[:objectifies] = uuid
-		  j[:implicit] = true if o.concept.implication_rule
-		end
-		if o.all_type_inheritance_as_subtype.size > 0
-		  j[:supertypes] = o.
-		    all_type_inheritance_as_subtype.
-		    sort_by{|ti| ti.provides_identification ? 0 : 1}.
-		    map{|ti|
-		      [ uuids[ti.supertype] ||= uuid_from_id(ti.supertype),
-			uuids[ti.supertype_role] = uuid_from_id(ti.supertype_role)
-		      ]
-		    }
-		end
-	      else
-		# ValueType usually has a supertype:
-		if (o.supertype)
-		  j[:supertype] = (uuids[o.supertype] ||= uuid_from_id(o.supertype))
-		end
-	      end
-	      # REVISIT: Place a ValueConstraint and shape
-	      "    #{j.to_json}"
-	    end*",\n"
-	  }\n  ],"
-
-	  fact_types = @vocabulary.constellation.
-	    FactType.values.
-	    reject{|ft|
-	      ActiveFacts::Metamodel::LinkFactType === ft || ActiveFacts::Metamodel::TypeInheritance === ft
-	    }
-	  puts "  fact_types: [\n#{
-	    fact_types.sort_by{|f| f.identifying_role_values.inspect}.map do |f|
-	      uuids[f] ||= uuid_from_id(f)
-	      j = {:uuid => uuids[f]}
-
-	      if f.entity_type
-		j[:objectified_as] = uuids[f.entity_type]
-	      end
-
-	      # Emit roles
-	      roles = f.all_role.sort_by{|r| r.ordinal }
-	      j[:roles] = roles.map do |role|
-		uuid = (uuids[role] ||= uuid_from_id(role))
-		# REVISIT: Internal Mandatory Constraints
-		# REVISIT: Place a ValueConstraint and shape
-		# REVISIT: Place a RoleName shape
-		{:uuid => uuid, :player => uuids[role.object_type]}
-		# N.B. The object_type shape to which this role is attached is not in the meta-model
-		# Attach to the closest instance on this diagram (if any)
-	      end
-
-	      # Emit readings. Each is a [role_order, text] pair
-	      j[:readings] = f.all_reading.map do |r|
-		role_refs = r.role_sequence.all_role_ref_in_order
-		[
-		  role_order(uuids, role_refs.map{|rr| rr.role}, roles),
-		  r.text.gsub(/\{([0-9])\}/) do |insert|
-		    role_ref = role_refs[$1.to_i]
-		    la = role_ref.leading_adjective
-		    la = nil if la == ''
-		    ta = role_ref.trailing_adjective
-		    ta = nil if ta == ''
-		    (la ? la+'-' : '') +
-		      (la && la.index(' ') ? ' ' : '') +
-		      insert +
-		      (ta && ta.index(' ') ? ' ' : '') +
-		      (ta ? '-'+ta : '')
-		  end
-		]
-	      end.sort_by{|(ro,text)| ro }.map do |(ro,text)|
-		[ ro, text ]
-	      end
-
-	      # Emit shapes
-	      j[:shapes] = f.all_fact_type_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
-		sj = {
-		  :diagram => uuids[shape.orm_diagram],
-		  :uuid => uuid_from_id(shape),
-		  :x => shape.location.x,
-		  :y => shape.location.y
-		}
-
-		# Add the role_order, if specified
-		if shape.all_role_display.size > 0
-		  if shape.all_role_display.size != roles.size
-		    raise "Invalid RoleDisplay for #{f.default_reading} in #{shape.orm_diagram.name} diagram"
-		  end
-		  ro = role_order(
-		    uuids,
-		    shape.all_role_display.sort_by{|rd| rd.ordinal }.map{|rd| rd.role },
-		    roles
-		  )
-		  sj[:role_order] = ro if ro
-		end
-
-		# REVISIT: Place the ReadingShape
-
-		# Emit the location of the name, if objectified
-		if n = shape.objectified_fact_type_name_shape
-		  sj[:name_shape] = {:x => n.location.x, :y => n.location.y}
-		end
-		sj
-	      end
-
-	      # Emit Internal Presence Constraints
-	      f.internal_presence_constraints.to_a.sort_by{|ipc, z|
-		    [ipc.is_preferred_identifier ? 0 : 1, ipc.is_mandatory ? 0 : 1, ipc.min_frequency || 0, ipc.max_frequency || 1_000]
-		  }.each do |ipc|
-		uuid = (uuids[ipc] ||= uuid_from_id(ipc))
-
-		constraint = {
-		  :uuid => uuid,
-		  :min => ipc.min_frequency,
-		  :max => ipc.max_frequency,
-		  :is_preferred => ipc.is_preferred_identifier,
-		  :mandatory => ipc.is_mandatory
-		}
-
-		# Get the role (or excluded role, for a UC)
-		roles = ipc.role_sequence.all_role_ref_in_order.map{|r| r.role}
-		if roles.size > 1 || (!ipc.is_mandatory && ipc.max_frequency == 1)
-		  # This can be only a uniqueness constraint. Record the missing role, if any
-		  role = (f.all_role.to_a - roles)[0]
-		  constraint[:uniqueExcept] = uuids[role]
-		else
-		  # An internal mandatory or frequency constraint applies to only one role.
-		  # If it's also unique (max == 1), that applies on the counterpart role.
-		  # You can also have a mandatory frequency constraint, but that applies on this role.
-		  constraint[:role] = uuids[roles[0]]
-		end
-		(j[:constraints] ||= []) << constraint
-	      end
-
-	      # Add ring constraints
-	      f.all_role_in_order.
-		map{|r| r.all_ring_constraint.to_a+r.all_ring_constraint_as_other_role.to_a }.
-		flatten.uniq.each do |ring|
-		  (j[:constraints] ||= []) << {
-		      :uuid => (uuids[ring] ||= uuid_from_id(ring)),
-		      :shapes => ring.all_constraint_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
-			{ :diagram => uuids[shape.orm_diagram],
-			  :uuid => uuid_from_id(shape),
-			  :x => shape.location.x,
-			  :y => shape.location.y
-			}
-		      end,
-		      :ringKind => ring.ring_type,
-		      :roles => [uuids[ring.role], uuids[ring.other_role]]
-		      # REVISIT: Deontic, enforcement
-		    }
-		end
-
-	      # REVISIT: RotationSetting
-
-	      "    #{j.to_json}"
-	    end*",\n"
-	  }\n  ],"
-
-	  constraints = @vocabulary.constellation.
-	    Constraint.values
-	  puts "  constraints: [\n#{
-	    constraints.sort_by{|c|c.identifying_role_values.inspect}.select{|c| !uuids[c]}.map do |c|
-	      uuid = uuids[c] ||= uuid_from_id(c)
-	      j = {
-		:uuid => uuid,
-		:type => c.class.basename,
-		:shapes => c.all_constraint_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
-		  { :diagram => uuids[shape.orm_diagram],
-		    :uuid => uuid_from_id(shape),
-		    :x => shape.location.x,
-		    :y => shape.location.y
-		  }
-		end
-	      }
-
-	      if (c.enforcement)
-		# REVISIT: Deontic constraint
-	      end
-	      if (c.concept.all_context_note_as_relevant_concept.size > 0)
-		# REVISIT: Context Notes
-	      end
-
-	      case c
-	      when ActiveFacts::Metamodel::PresenceConstraint
-		j[:min_frequency] = c.min_frequency
-		j[:max_frequency] = c.max_frequency
-		j[:is_mandatory] = c.is_mandatory
-		j[:is_preferred_identifier] = c.is_preferred_identifier
-		rss = [c.role_sequence.all_role_ref_in_order.map(&:role)]
-
-		# Ignore internal presence constraints on TypeInheritance fact types
-		next nil if !c.role_sequence.all_role_ref.
-		  detect{|rr|
-		    !rr.role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-		  }
-
-	      when ActiveFacts::Metamodel::RingConstraint
-		next nil  # These are emitted with the corresponding fact type
-
-	      when ActiveFacts::Metamodel::SetComparisonConstraint
-		rss = c.
-		  all_set_comparison_roles.sort_by{|scr| scr.ordinal}.
-		  map{|scr| scr.role_sequence.all_role_ref_in_order.map(&:role) }
-		if (ActiveFacts::Metamodel::SetExclusionConstraint === c)
-		  j[:is_mandatory] = c.is_mandatory
-		end
-
-	      when ActiveFacts::Metamodel::SubsetConstraint
-		rss = [c.subset_role_sequence, c.superset_role_sequence].
-		  map{|rs| rs.all_role_ref_in_order.map(&:role) }
-
-	      when ActiveFacts::Metamodel::ValueConstraint
-		next nil  # REVISIT: Should have been handled elsewhere
-		if (c.role)
-		  # Should have been handled as role.role_value_constraint
-		elsif (c.value_type)
-		  # Should have been handled as object_type.value_constraint
-		end
-		j[:allowed_ranges] = c.all_allowed_range.map{|ar|
-		  [ ar.value_range.minimum_bound, ar.value_range.maximum_bound ].
-		    map{|b| [b.value.literal, b.value.unit.name, b.is_inclusive] }
-		}
-
-	      else
-		raise "REVISIT: Constraint type not yet dumped to JSON"
-	      end
-
-	      # rss contains the constrained role sequences; map to uuids
-	      j[:role_sequences] = rss.map{|rs|
-		rs.map do |role|
-		  uuids[role]
-		end
-	      }
-
-	      "    #{j.to_json}"
-	    end.compact*",\n"
-	  }\n  ]"
-
-	  puts "}"
-	end
-
-	def role_order(uuids, roles, order)
-	  if (roles.size > 9)
-	    roles.map{|r| uuids[r] }
-	  else
-	    roles.map{|r| order.index(r).to_s }*''
-	  end
-	end
-
-	def uuid_from_id o
-	  irvs = o.identifying_role_values.inspect
-	  d = Digest::SHA1.digest irvs
-	  # $stderr.puts "#{o.class.basename}: #{irvs}"
-	  d[0,4].unpack("H8")[0]+'-'+
-	    d[4,2].unpack("H4")[0]+'-'+
-	    d[6,2].unpack("H4")[0]+'-'+
-	    d[8,2].unpack("H4")[0]+'-'+
-	    d[10,6].unpack("H6")[0]
-	end
+        def generate(out = $>)
+          @out = out
+          uuids = {}
+
+          puts "{ model: '#{@vocabulary.name}',\n" +
+          "diagrams: [\n#{
+            @vocabulary.all_diagram.sort_by{|o| o.name.gsub(/ /,'')}.map do |d|
+              j = {:uuid => (uuids[d] ||= uuid_from_id(d)), :name => d.name}
+              "    #{j.to_json}"
+            end*",\n"
+          }\n  ],"
+
+          object_types = @vocabulary.all_object_type.sort_by{|o| o.name.gsub(/ /,'')}
+          puts "  object_types: [\n#{
+            object_types.sort_by{|o|o.identifying_role_values.inspect}.map do |o|
+              uuids[o] ||= uuid_from_id(o)
+              ref_mode = nil
+              if o.is_a?(ActiveFacts::Metamodel::EntityType) and
+                p = o.preferred_identifier and
+                (rrs = p.role_sequence.all_role_ref).size == 1 and
+                !(o.fact_type && o.fact_type.all_role.size == 1) and
+                (r = rrs.single.role).fact_type != o.fact_type and
+                r.object_type.is_a?(ActiveFacts::Metamodel::ValueType) and
+                !r.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+                ref_mode = "#{r.object_type.name}"
+                ref_mode.sub!(%r{#{o.name} *}, '.')
+              end
+              j = {
+                :uuid => uuids[o],
+                :name => o.name,
+                :shapes => o.all_object_type_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
+                  x = { :diagram => uuids[shape.orm_diagram],
+                    :is_expanded => shape.is_expanded,
+                    :uuid => uuid_from_id(shape),
+                    :x => shape.location.x,
+                    :y => shape.location.y
+                  }
+                  x[:is_expanded] = true if ref_mode && shape.is_expanded  # Don't show the reference mode
+                  x
+                end
+              }
+              j[:ref_mode] = ref_mode if ref_mode
+              j[:independent] = true if o.is_independent
+
+              if o.is_a?(ActiveFacts::Metamodel::EntityType)
+                # Entity Type may be objectified, and may have supertypes:
+                if o.fact_type
+                  uuid = (uuids[o.fact_type] ||= uuid_from_id(o.fact_type))
+                  j[:objectifies] = uuid
+                  j[:implicit] = true if o.concept.implication_rule
+                end
+                if o.all_type_inheritance_as_subtype.size > 0
+                  j[:supertypes] = o.
+                    all_type_inheritance_as_subtype.
+                    sort_by{|ti| ti.provides_identification ? 0 : 1}.
+                    map{|ti|
+                      [ uuids[ti.supertype] ||= uuid_from_id(ti.supertype),
+                        uuids[ti.supertype_role] = uuid_from_id(ti.supertype_role)
+                      ]
+                    }
+                end
+              else
+                # ValueType usually has a supertype:
+                if (o.supertype)
+                  j[:supertype] = (uuids[o.supertype] ||= uuid_from_id(o.supertype))
+                end
+              end
+              # REVISIT: Place a ValueConstraint and shape
+              "    #{j.to_json}"
+            end*",\n"
+          }\n  ],"
+
+          fact_types = @vocabulary.constellation.
+            FactType.values.
+            reject{|ft|
+              ActiveFacts::Metamodel::LinkFactType === ft || ActiveFacts::Metamodel::TypeInheritance === ft
+            }
+          puts "  fact_types: [\n#{
+            fact_types.sort_by{|f| f.identifying_role_values.inspect}.map do |f|
+              uuids[f] ||= uuid_from_id(f)
+              j = {:uuid => uuids[f]}
+
+              if f.entity_type
+                j[:objectified_as] = uuids[f.entity_type]
+              end
+
+              # Emit roles
+              roles = f.all_role.sort_by{|r| r.ordinal }
+              j[:roles] = roles.map do |role|
+                uuid = (uuids[role] ||= uuid_from_id(role))
+                # REVISIT: Internal Mandatory Constraints
+                # REVISIT: Place a ValueConstraint and shape
+                # REVISIT: Place a RoleName shape
+                {:uuid => uuid, :player => uuids[role.object_type]}
+                # N.B. The object_type shape to which this role is attached is not in the meta-model
+                # Attach to the closest instance on this diagram (if any)
+              end
+
+              # Emit readings. Each is a [role_order, text] pair
+              j[:readings] = f.all_reading.map do |r|
+                role_refs = r.role_sequence.all_role_ref_in_order
+                [
+                  role_order(uuids, role_refs.map{|rr| rr.role}, roles),
+                  r.text.gsub(/\{([0-9])\}/) do |insert|
+                    role_ref = role_refs[$1.to_i]
+                    la = role_ref.leading_adjective
+                    la = nil if la == ''
+                    ta = role_ref.trailing_adjective
+                    ta = nil if ta == ''
+                    (la ? la+'-' : '') +
+                      (la && la.index(' ') ? ' ' : '') +
+                      insert +
+                      (ta && ta.index(' ') ? ' ' : '') +
+                      (ta ? '-'+ta : '')
+                  end
+                ]
+              end.sort_by{|(ro,text)| ro }.map do |(ro,text)|
+                [ ro, text ]
+              end
+
+              # Emit shapes
+              j[:shapes] = f.all_fact_type_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
+                sj = {
+                  :diagram => uuids[shape.orm_diagram],
+                  :uuid => uuid_from_id(shape),
+                  :x => shape.location.x,
+                  :y => shape.location.y
+                }
+
+                # Add the role_order, if specified
+                if shape.all_role_display.size > 0
+                  if shape.all_role_display.size != roles.size
+                    raise "Invalid RoleDisplay for #{f.default_reading} in #{shape.orm_diagram.name} diagram"
+                  end
+                  ro = role_order(
+                    uuids,
+                    shape.all_role_display.sort_by{|rd| rd.ordinal }.map{|rd| rd.role },
+                    roles
+                  )
+                  sj[:role_order] = ro if ro
+                end
+
+                # REVISIT: Place the ReadingShape
+
+                # Emit the location of the name, if objectified
+                if n = shape.objectified_fact_type_name_shape
+                  sj[:name_shape] = {:x => n.location.x, :y => n.location.y}
+                end
+                sj
+              end
+
+              # Emit Internal Presence Constraints
+              f.internal_presence_constraints.to_a.sort_by{|ipc, z|
+                    [ipc.is_preferred_identifier ? 0 : 1, ipc.is_mandatory ? 0 : 1, ipc.min_frequency || 0, ipc.max_frequency || 1_000]
+                  }.each do |ipc|
+                uuid = (uuids[ipc] ||= uuid_from_id(ipc))
+
+                constraint = {
+                  :uuid => uuid,
+                  :min => ipc.min_frequency,
+                  :max => ipc.max_frequency,
+                  :is_preferred => ipc.is_preferred_identifier,
+                  :mandatory => ipc.is_mandatory
+                }
+
+                # Get the role (or excluded role, for a UC)
+                roles = ipc.role_sequence.all_role_ref_in_order.map{|r| r.role}
+                if roles.size > 1 || (!ipc.is_mandatory && ipc.max_frequency == 1)
+                  # This can be only a uniqueness constraint. Record the missing role, if any
+                  role = (f.all_role.to_a - roles)[0]
+                  constraint[:uniqueExcept] = uuids[role]
+                else
+                  # An internal mandatory or frequency constraint applies to only one role.
+                  # If it's also unique (max == 1), that applies on the counterpart role.
+                  # You can also have a mandatory frequency constraint, but that applies on this role.
+                  constraint[:role] = uuids[roles[0]]
+                end
+                (j[:constraints] ||= []) << constraint
+              end
+
+              # Add ring constraints
+              f.all_role_in_order.
+                map{|r| r.all_ring_constraint.to_a+r.all_ring_constraint_as_other_role.to_a }.
+                flatten.uniq.each do |ring|
+                  (j[:constraints] ||= []) << {
+                      :uuid => (uuids[ring] ||= uuid_from_id(ring)),
+                      :shapes => ring.all_constraint_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
+                        { :diagram => uuids[shape.orm_diagram],
+                          :uuid => uuid_from_id(shape),
+                          :x => shape.location.x,
+                          :y => shape.location.y
+                        }
+                      end,
+                      :ringKind => ring.ring_type,
+                      :roles => [uuids[ring.role], uuids[ring.other_role]]
+                      # REVISIT: Deontic, enforcement
+                    }
+                end
+
+              # REVISIT: RotationSetting
+
+              "    #{j.to_json}"
+            end*",\n"
+          }\n  ],"
+
+          constraints = @vocabulary.constellation.
+            Constraint.values
+          puts "  constraints: [\n#{
+            constraints.sort_by{|c|c.identifying_role_values.inspect}.select{|c| !uuids[c]}.map do |c|
+              uuid = uuids[c] ||= uuid_from_id(c)
+              j = {
+                :uuid => uuid,
+                :type => c.class.basename,
+                :shapes => c.all_constraint_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
+                  { :diagram => uuids[shape.orm_diagram],
+                    :uuid => uuid_from_id(shape),
+                    :x => shape.location.x,
+                    :y => shape.location.y
+                  }
+                end
+              }
+
+              if (c.enforcement)
+                # REVISIT: Deontic constraint
+              end
+              if (c.concept.all_context_note_as_relevant_concept.size > 0)
+                # REVISIT: Context Notes
+              end
+
+              case c
+              when ActiveFacts::Metamodel::PresenceConstraint
+                j[:min_frequency] = c.min_frequency
+                j[:max_frequency] = c.max_frequency
+                j[:is_mandatory] = c.is_mandatory
+                j[:is_preferred_identifier] = c.is_preferred_identifier
+                rss = [c.role_sequence.all_role_ref_in_order.map(&:role)]
+
+                # Ignore internal presence constraints on TypeInheritance fact types
+                next nil if !c.role_sequence.all_role_ref.
+                  detect{|rr|
+                    !rr.role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+                  }
+
+              when ActiveFacts::Metamodel::RingConstraint
+                next nil  # These are emitted with the corresponding fact type
+
+              when ActiveFacts::Metamodel::SetComparisonConstraint
+                rss = c.
+                  all_set_comparison_roles.sort_by{|scr| scr.ordinal}.
+                  map{|scr| scr.role_sequence.all_role_ref_in_order.map(&:role) }
+                if (ActiveFacts::Metamodel::SetExclusionConstraint === c)
+                  j[:is_mandatory] = c.is_mandatory
+                end
+
+              when ActiveFacts::Metamodel::SubsetConstraint
+                rss = [c.subset_role_sequence, c.superset_role_sequence].
+                  map{|rs| rs.all_role_ref_in_order.map(&:role) }
+
+              when ActiveFacts::Metamodel::ValueConstraint
+                next nil  # REVISIT: Should have been handled elsewhere
+                if (c.role)
+                  # Should have been handled as role.role_value_constraint
+                elsif (c.value_type)
+                  # Should have been handled as object_type.value_constraint
+                end
+                j[:allowed_ranges] = c.all_allowed_range.map{|ar|
+                  [ ar.value_range.minimum_bound, ar.value_range.maximum_bound ].
+                    map{|b| [b.value.literal, b.value.unit.name, b.is_inclusive] }
+                }
+
+              else
+                raise "REVISIT: Constraint type not yet dumped to JSON"
+              end
+
+              # rss contains the constrained role sequences; map to uuids
+              j[:role_sequences] = rss.map{|rs|
+                rs.map do |role|
+                  uuids[role]
+                end
+              }
+
+              "    #{j.to_json}"
+            end.compact*",\n"
+          }\n  ]"
+
+          puts "}"
+        end
+
+        def role_order(uuids, roles, order)
+          if (roles.size > 9)
+            roles.map{|r| uuids[r] }
+          else
+            roles.map{|r| order.index(r).to_s }*''
+          end
+        end
+
+        def uuid_from_id o
+          irvs = o.identifying_role_values.inspect
+          d = Digest::SHA1.digest irvs
+          # $stderr.puts "#{o.class.basename}: #{irvs}"
+          d[0,4].unpack("H8")[0]+'-'+
+            d[4,2].unpack("H4")[0]+'-'+
+            d[6,2].unpack("H4")[0]+'-'+
+            d[8,2].unpack("H4")[0]+'-'+
+            d[10,6].unpack("H6")[0]
+        end
 
       end
     end