activefacts-generators 1.7.1

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

@@ -0,0 +1,605 @@
+#
+#       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'
+require 'activefacts/generators/helpers/inject'
+require 'activefacts/generators/traits/ordered'
+
+module ActiveFacts
+  module Generators #: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
+          units_dump
+          value_types_dump
+          entity_types_dump
+          fact_types_dump
+          constraints_dump
+          vocabulary_end
+        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_type_fork(o)
+	  if o.name == "_ImplicitBooleanValueType"
+	    # do nothing
+	  elsif
+	      !o.supertype                      # No supertype, i.e. a base type
+	      o.all_role.size == 0 &&           # No roles
+	      !o.is_independent &&              # not independent
+	      !o.value_constraint &&		# No value constraints
+	      o.concept.all_context_note_as_relevant_concept.size == 0 &&	# No context notes
+	      o.all_instance.size == 0          # No instances
+	    data_type_dump(o)
+	  else
+	    super_type_name = o.supertype ? o.supertype.name : o.name
+	    length = (l = o.length) && l > 0 ? "#{l}" : nil
+	    scale = (s = o.scale) && s > 0 ? "#{s}" : nil
+	    facets = { :length => length, :scale => scale }
+	    value_type_dump(o, super_type_name, facets)
+	  end
+	end
+
+        def value_types_dump
+          done_banner = false
+          @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
+	      o.ordered_dumped!
+            }
+          value_type_end if done_banner
+        end
+
+        # Ensure that supertype gets dumped first
+        def value_type_chain_dump(o)
+          return if o.ordered_dumped
+          value_type_chain_dump(o.supertype) if (o.supertype && !o.supertype.ordered_dumped)
+          value_type_fork(o)
+          o.ordered_dumped!
+        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 o.ordered_dumped	    # Already done
+
+		trace :ordered, "Panicing to dump #{panic.name}" if panic
+                # Can we do this yet?
+		remaining_precursors = Array(@precursors[o])-[o]
+                if (o != panic and                  # We don't *have* to do it (panic mode)
+                    remaining_precursors.size > 0)  # precursors - still blocked
+		  trace :ordered, "Can't dump #{o.name} despite panic for #{panic.name}, it still needs #{remaining_precursors.map(&:name)*', '}" if panic
+                  skipped_this_pass += 1
+                  next
+                end
+		trace :ordered, "Dumping #{o.name} in panic mode, even though it still needs #{remaining_precursors.map(&:name)*', '}" if panic
+
+                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
+=begin
+                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".
+		  bad = sorted.select do |o|
+		      o.is_a?(ActiveFacts::Metamodel::EntityType) &&
+		      !o.ordered_dumped &&
+		      (Array(@precursors[o])-[o]).size > 0 &&
+		      (Array(@followers[o])-[o]).size > 0
+		    end
+
+                  raise "Unresolvable cycle of forward references: " +
+                    bad.map { |o| o.name }*', ' +
+                    ":\n\t" +
+		    (
+		      bad.map do |o|
+			o.name +
+			  " depends on " +
+			  (@precursors[o].uniq.map{|p| p.name}.sort*', ')
+		      end
+		    ) * "\n\t" +
+		    "\n"
+=end
+#                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| !o.ordered_dumped }.
+                    sort_by{|o|
+                        f = (@followers[o] || []) - [o];
+                        o.supertypes.detect{|s| !s.ordered_dumped } ? 0 : -f.size
+                      }[0]
+                  trace :ordered, "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; trace "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_type.ordered_dumped &&
+                  !fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType) &&
+                  !fact_type.all_role.detect{|r| !r.object_type.ordered_dumped } &&
+                  !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| !js.fact_type.ordered_dumped }
+          return false if query.all_variable.detect{|jn| !jn.object_type.ordered_dumped }
+          true
+        end
+
+        def skip_fact_type(f)
+          return true if f.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+          return false if f.entity_type && !f.entity_type.ordered_dumped
+
+          # REVISIT: There might be constraints we have to merge into the nested entity or subtype. 
+          # These will come up as un-handled constraints:
+	  # Dump this fact type only if it contains a presence constraint we've missed:
+          pcs = @presence_constraints_by_fact[f]
+          pcs && pcs.size > 0 && !pcs.detect{|c| !c.ordered_dumped }
+        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_type.ordered_dumped!
+          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 }
+            # trace "Dumping objectified FT #{et.name} as an entity, non-fact PI"
+            entity_type_dump(et)
+            released_fact_types_dump(et)
+            return
+          end
+
+          # trace "#{fact_type.name} has readings:\n\t#{fact_type.readings.map(&:name)*"\n\t"}"
+          # trace "Dumping #{fact_type.concept.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
+
+#CJH: Necessary?
+          fact_type.ordered_dumped!
+          fact_type.entity_type.ordered_dumped! 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_type.ordered_dumped 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_type.ordered_dumped
+              # trace "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
+        end
+
+        def fact_instances_dump
+          @vocabulary.fact_types.each{|f|
+              # Dump the instances:
+              f.facts.each{|i|
+                raise "REVISIT: Not dumping fact instances"
+                trace "\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
+          heading = false
+          @vocabulary.
+	      all_constraint.
+	      reject{|c| c.ordered_dumped}.
+	      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
+          trace "Should override vocabulary_start"
+        end
+
+        def vocabulary_end
+          trace "Should override vocabulary_end"
+        end
+
+        def units_banner
+        end
+
+        def units_end
+        end
+
+        def unit_dump unit
+        end
+
+        def value_type_banner
+          trace "Should override value_type_banner"
+        end
+
+        def value_type_end
+          trace "Should override value_type_end"
+        end
+
+        def data_type_dump(o)
+          trace "Should override data_type_dump"
+        end
+
+	def value_type_dump(o, super_type_name, facets)
+          trace "Should override value_type_dump"
+        end
+
+        def entity_type_banner
+          trace "Should override entity_type_banner"
+        end
+
+        def entity_type_group_end
+          trace "Should override entity_type_group_end"
+        end
+
+        def non_subtype_dump(o, pi)
+          trace "Should override non_subtype_dump"
+        end
+
+        def subtype_dump(o, supertypes, pi = nil)
+          trace "Should override subtype_dump"
+        end
+
+        def append_ring_to_reading(reading, ring)
+          trace "Should override append_ring_to_reading"
+        end
+
+        def fact_type_banner
+          trace "Should override fact_type_banner"
+        end
+
+        def fact_type_end
+          trace "Should override fact_type_end"
+        end
+
+        def fact_type_dump(fact_type, name)
+          trace "Should override fact_type_dump"
+        end
+
+        def constraint_banner
+          trace "Should override constraint_banner"
+        end
+
+        def constraint_end
+          trace "Should override constraint_end"
+        end
+
+        def constraint_dump(c)
+          trace "Should override constraint_dump"
+        end
+
+      end
+
+      def dump(vocabulary, out = $>)
+        OrderedDumper.new(vocabulary).dump(out)
+      end
+    end
+  end
+end