activefacts 1.3.0 → 1.5.0

data/lib/activefacts/generate/cql.rb

@@ -188,7 +188,7 @@ module ActiveFacts
 
         # 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.describe
+          constraint_text = " "+c.as_cql
         end
         (entity_type.is_independent ? ' independent' : '') +
           " identified by its #{value_residual}#{constraint_text}#{mapping_pragma(entity_type, true)}" +
@@ -651,6 +651,8 @@ module ActiveFacts
             parameters
           }#{
             unit && " "+unit.name
+          }#{
+	    transaction_phase && " auto-assigned at "+transaction_phase
           }#{
 	    concept.all_context_note_as_relevant_concept.map do |cn|
 	      cn.verbalise

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

@@ -0,0 +1,16 @@
+require 'activefacts/vocabulary'
+
+module ActiveFacts
+  module TraitInjector
+    def self.included other
+      overlap = Metamodel.constants & other.constants
+      overlap.each do |const|
+	mix_into = Metamodel.const_get(const)
+	mix_in = other.const_get(const)
+	mix_into.instance_exec {
+	  include(mix_in)
+	}
+      end
+    end
+  end
+end

data/lib/activefacts/generate/rails/models.rb

@@ -151,7 +151,7 @@ module ActiveFacts
 
 	    ref = fk.jump_reference
 	    [
-	      "\n    \# #{fk.verbalised_path}" +
+	      "\n    \# #{fk.verbalised_path(true)}" +
 	      "\n" +
 		%Q{    #{association_type} :#{association_name}} +
 		%Q{, :class_name => '#{fk.from.rails_class_name}'} +

data/lib/activefacts/generate/stats.rb

@@ -0,0 +1,69 @@
+#
+#       ActiveFacts Generators.
+#       Generate metamodel statistics fora compiled vocabulary
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/persistence'
+
+module ActiveFacts
+  module Generate
+    # Generate a text verbalisation of the metamodel constellation created for an ActiveFacts vocabulary.
+    # Invoke as
+    #   afgen --text <file>.cql
+    class Statistics
+    private
+      def initialize(vocabulary)
+        @vocabulary = vocabulary
+        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+      end
+
+    public
+      def generate(out = $>)
+	constellation = @vocabulary.constellation
+	object_types = constellation.ObjectType.values
+	fact_types = constellation.FactType.values
+
+	# All metamodel object types:
+	object_count = 0
+	populated_object_type_count = 0
+	fact_types_processed = {}
+	fact_count = 0
+	role_played_count = 0
+	constellation.vocabulary.object_type.map do |object_type_name, object_type|
+	  objects = constellation.send(object_type_name)
+	  next unless objects.size > 0
+	  puts "\t#{object_type_name}: #{objects.size} instances (which play #{object_type.all_role.size} roles)"
+	  populated_object_type_count += 1
+	  object_count += objects.size
+
+	  #puts "#{object_type_name} has #{object_type.all_role.size} roles"
+	  object_type.all_role.each do |name, role|
+	    next unless role.unique
+	    next if fact_types_processed[role.fact_type]
+	    next if role.fact_type.is_a?(ActiveFacts::API::TypeInheritanceFactType)
+	    role_population_count =
+	      objects.values.inject(0) do |count, object|
+		count += 1 if object.send(role.name) != nil
+		count
+	      end
+	    puts "\t\t#{object_type_name}.#{role.name} has #{role_population_count} instances" if role_population_count > 0
+	    fact_count += role_population_count
+	    role_played_count += role_population_count*role.fact_type.all_role.size
+
+	    fact_types_processed[role.fact_type] = true
+	  end
+
+	end
+	puts "#{@vocabulary.name} has"
+	puts "\t#{object_types.size} object types"
+	puts "\t#{fact_types.size} fact types"
+	puts "\tcompiles to #{object_count} objects in total, of #{populated_object_type_count} metamodel types"
+	puts "\tcompiles to #{fact_count} facts in total, of #{fact_types_processed.size} metamodel fact types"
+	puts "\tcompiles to #{role_played_count} role instances in total"
+      end
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('records', ActiveFacts::Generate::Statistics)

data/lib/activefacts/generate/topics.rb

@@ -0,0 +1,265 @@
+#
+#       ActiveFacts Generators.
+#       Generate metamodel topic hierarchy (topologically sorted) for a compiled vocabulary
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/dependency_analyser'
+require 'activefacts/persistence'
+
+module ActiveFacts
+  module Generate
+    # Generate a topic hierarchy of the metamodel constellation created for an ActiveFacts vocabulary.
+    # Invoke as
+    #   afgen --topics <file>.cql
+    class Topics
+    private
+      def initialize(vocabulary)
+        @vocabulary = vocabulary
+        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+      end
+
+    public
+      def generate(out = $>)
+	@constellation = @vocabulary.constellation
+
+	@concepts = @constellation.Concept.values.select do |c|
+	  !c.embodied_as.is_a?(ActiveFacts::Metamodel::Role) &&
+	  !c.implication_rule
+	end
+
+	@concept_deps = ActiveFacts::DependencyAnalyser.new(@concepts) {|c| c.precursors }
+
+	# list_concepts(@concept_deps)
+	# list_precursors(@concept_deps)
+	# list_followers(@concept_deps)
+	# list_chasers(@concept_deps)
+	# list_ranks(@concept_deps)
+
+#	@constellation.Topic.values.each do |topic|
+#	  puts "#{topic.topic_name} depends on #{topic.precursors.map(&:topic_name)*', '}"
+#	end
+
+	# analyse_topic_sequence
+
+	list_groups_by_rank @concept_deps
+
+      end
+
+      def list_concepts concept_deps
+	puts "Concepts are"
+	concept_deps.each do |concept|
+	  puts "\t#{concept.describe}"
+	end
+	puts
+      end
+
+      def list_precursors(concept_deps)
+	puts "Precursors are"
+	concept_deps.each do |concept|
+	  next unless (p = concept_deps.precursors(concept)).size > 0
+	  puts "#{concept.describe}:"
+	  p.each do |precursor|
+	    puts "\t#{precursor.describe}"
+	  end
+	end
+      end
+
+      def list_followers(concept_deps)
+	puts "Followers are:"
+	concept_deps.each do |concept|
+	  next unless (f = concept_deps.followers(concept)).size > 0
+	  puts "#{concept.describe}:"
+	  f.each do |follower|
+	    puts "\t#{follower.describe}"
+	  end
+	end
+      end
+
+      def list_chasers(concept_deps)
+	puts "Chasers are:"
+	concept_deps.each do |concept|
+	  next unless (f = concept_deps.chasers(concept)).size > 0
+	  puts "#{concept.describe}:"
+	  f.each do |follower|
+	    puts "\t#{follower.describe}"
+	  end
+	end
+      end
+
+      def list_ranks(concept_deps)
+	puts "Ranks are:"
+	page_rank = concept_deps.page_rank
+	page_rank.keys.sort_by{|k| -page_rank[k]}.each do |concept|
+	  puts("%8.4f\t%s" % [page_rank[concept], concept.describe])
+	end
+      end
+
+      def analyse_topic_sequence
+	if @constellation.Topic.size == 1
+	  @topics = @constellation.Topic.values.first
+	else
+	  puts "=== Analysing existing topics ==="
+	  @topic_analyser = ActiveFacts::DependencyAnalyser.new(@constellation.Topic.values) do |topic|
+	    topic.precursors
+	  end
+
+	  @topics = []
+	  failed_topics = @topic_analyser.tsort { |topic|
+	    @topics << topic
+	    puts "#{topic.topic_name} including #{topic.all_concept.size} concepts"
+	  }
+	  if failed_topics
+	    puts "Topological sort of topics is impossible"
+
+	    # REVISIT: The strategy here should be to look at the structure of the dependency loop
+	    # involving the highest-rank topic. Choose the loop member that has fewest dependencies
+	    # involving individual concepts, and dump that (it will need to flip topic to dump
+	    # those dependencies). That should break the loop in a minimal way, so we can continue.
+
+	    failed_topics.each do |topic, precursor_topics|
+	      puts "#{topic.topic_name} depends on:"
+	      precursor_topics.each do |precursor_topic|
+		puts "\t#{precursor_topic.topic_name} because of:"
+
+		blocking_concept =
+		  precursor_topic.all_concept.select{|concept| 
+		    concept.precursors.detect{|cp|
+		      cp.topic == precursor_topic
+		    }
+		  }
+
+		  blocking_concept.each do |concept|
+		    puts "\t\t#{concept.describe} (depends on #{concept.precursors.map(&:topic).uniq.map(&:topic_name).sort.inspect})"
+		  end
+	      end
+	    end
+	    return
+	  end
+	end
+      end
+
+      def list_groups_by_rank concept_deps
+	puts "=== Concepts listed in Ranking Order with chasers ==="
+	# List the highest-ranked items that have no un-listed precursors.
+	# After each listed item, list the chasers *transitively* before
+	# choosing the next highest ranked item.
+	@listed = {}
+
+	start = Time.now
+	@page_rank = concept_deps.page_rank    # Get the page_rank
+	# puts "done in #{Time.now-start}"
+
+	@ranked = @page_rank.keys.sort_by{|k| -@page_rank[k]} # Sort decreasing
+	@topic = nil
+	until @listed.size >= @ranked.size
+	  vt = nil  # Capture the first listable ValueType, which we'll choose if we must
+	  chosen = @ranked.detect do |concept|
+	    next if @listed[concept]
+
+	    unlisted_precursors = 
+	      concept_deps.precursors_transitive(concept).
+	      reject do |precursor|
+		is_value_type_concept(precursor) or
+		  precursor == concept or
+		  @listed[precursor] or
+		  is_value_type_concept(precursor)
+	      end
+	    next if unlisted_precursors.size > 0	  # Still has precursors
+	    vt ||= concept
+	    next if is_value_type_concept(concept)
+	    concept
+	  end
+	  chosen ||= vt	  # Choose a value type if there's no other
+
+	  @cluster = []
+
+	  descend concept_deps, chosen
+
+	  cluster_ranks = @cluster.sort_by{|c| -@page_rank[c]}
+	  head = cluster_ranks.detect{|c| c.object_type} || cluster_ranks.first
+	  puts "/*\n * #{head.object_type ? head.object_type.name : head.describe}\n */"
+	  @cluster.each do |concept|
+	    puts '*'*10+" TOPIC #{@topic = concept.topic.topic_name}" if @topic != concept.topic.topic_name
+	    puts concept.describe
+	  end
+	  puts	  # Put a line between sections
+	end
+      end
+
+      # Descend the concept, also the items that are necessarily dumped with concept, so we don't select them again
+      def descend(concept_deps, concept, tab = '')
+	@causation ||= []
+	@cluster ||= []
+	return if @listed[concept] || @causation.include?(concept)  # Recursion prevention
+	begin
+	  @causation << concept	# Reversed by the "ensure" below.
+
+	  concept_deps.precursors(concept).each do |precursor|
+	    descend(concept_deps, precursor, tab) unless @listed[precursor] || precursor == concept
+	  end
+
+	  #puts tab+concept.describe
+	  @listed[concept] = true
+	  @cluster << concept
+
+	  body = concept.embodied_as
+	  case body
+	  when ActiveFacts::Metamodel::FactType
+	    body.internal_presence_constraints.each do |pc|
+	      # puts "Listing #{pc.concept.describe} as internal_presence_constraint of #{concept.describe}"
+	      descend(concept_deps, pc.concept, tab+"\t")
+	    end
+	    if body.entity_type
+	      # puts "Listing #{body.entity_type.concept.describe} as objectification of #{concept.describe}"
+	      descend(concept_deps, body.entity_type.concept, tab+"\t")
+	    end
+	    body.all_role.each do |role|
+	      role.all_ring_constraint.each do |rc|
+		# puts "Listing #{rc.concept.describe} as ring_constraint of #{concept.describe}"
+		descend(concept_deps, rc.concept, tab+"\t")
+	      end
+	    end
+	  when ActiveFacts::Metamodel::EntityType
+	    body.preferred_identifier.role_sequence.all_role_ref.each do |rr|
+	      # puts "Listing #{rr.role.fact_type.concept.describe} as existential fact of #{concept.describe}"
+	      descend(concept_deps, rr.role.fact_type.concept, tab+"\t")
+	    end
+	    descend(concept_deps, body.preferred_identifier.concept, tab+"\t")
+	  when ActiveFacts::Metamodel::ValueType
+	    if body.value_constraint
+	      # puts "Listing #{body.value_constraint.concept.describe} as value constraint of #{concept.describe}"
+	      descend(concept_deps, body.value_constraint.concept, tab+"\t")
+	    end
+	  end
+
+	  # Follow up with unlisted chasers (that have no remaining precursors) in order of decreasing importance:
+	  chasers =
+	    concept_deps.followers(concept).reject do |follower|
+	      @listed[follower] or
+		is_value_type_concept(follower) or
+		concept_deps.precursors(follower).detect{|p| !@listed[p] && !is_value_type_concept(p) } or
+		# Exclude subtypes of entity types from the followers:
+		concept.object_type && concept.object_type.is_a?(ActiveFacts::Metamodel::EntityType) && concept.object_type.subtypes.include?(follower.object_type)
+	    end.
+	    sort_by{|nc| -@page_rank[nc]}
+
+	  chasers.each do |chaser|
+	    # puts "**** Listing #{chaser.describe} as chaser of #{concept.describe}"
+	    descend(concept_deps, chaser, tab)
+	  end
+
+	ensure
+	  @causation.pop
+	end
+      end
+
+      def is_value_type_concept concept
+	o = concept.object_type and o.is_a?(ActiveFacts::Metamodel::ValueType)
+      end
+
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('topics', ActiveFacts::Generate::Topics)

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

@@ -0,0 +1,73 @@
+#
+#       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.
+#
+module ActiveFacts
+  module Generate
+    module OOTraits
+      module ObjectType
+	# Map the ObjectType name to an OO class name
+	def oo_type_name
+	  name.words.capcase
+	end
+
+	# Map the OO class name to a default role name
+	def oo_default_role_name
+          name.words.snakecase
+	end
+      end
+
+      module Role
+	def oo_role_definition
+          return if fact_type.entity_type
+
+          if fact_type.all_role.size == 1
+	    return "    maybe :#{preferred_role_name}\n"
+          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)
+            # trace "Ignoring role #{self} 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 is_functional
+
+          counterpart_role = fact_type.all_role.select{|r| r != self}[0]
+          counterpart_type = counterpart_role.object_type
+          counterpart_role_name = counterpart_role.preferred_role_name
+          counterpart_type_default_role_name = counterpart_type.oo_default_role_name
+
+          # It's a one_to_one if there's a uniqueness constraint on the other role:
+          one_to_one = counterpart_role.is_functional
+          return if one_to_one &&
+              false # REVISIT: !@object_types_dumped[counterpart_role.object_type]
+
+          # Find role name:
+          role_method = preferred_role_name
+          counterpart_role_method = one_to_one ? role_method : "all_"+role_method
+          # puts "---"+role.role_name if role.role_name
+          if counterpart_role_name != counterpart_type.oo_default_role_name and
+	      role_method == self.object_type.oo_default_role_name
+#	    debugger
+            counterpart_role_method += "_as_#{counterpart_role_name}"
+          end
+
+          role_name = role_method
+          role_name = nil if role_name == object_type.oo_default_role_name
+
+          as_binary(counterpart_role_name, counterpart_type, is_mandatory, one_to_one, nil, role_name, counterpart_role_method)
+	end
+      end
+
+      include ActiveFacts::TraitInjector	# Must be last in this module, after all submodules have been defined
+    end
+  end
+end