activefacts 1.3.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e9276d073a9b3444de848bf033b76f373784a51
-  data.tar.gz: 0ab5602a9298cc84ce688168a3635bd7f4d976a8
+  metadata.gz: f4c7be7ca9e116d36232a6e9c0bcf28f0f4a63eb
+  data.tar.gz: a3c13e8e437aa028760eff29cd05df07b0017a91
 SHA512:
-  metadata.gz: a984577de5c0aa667d5975f70b35c76f2bb4ab65555fc6a19ca0b7a8bae635cd77fb6d3fbac3959f9f9d76bc53c81846214940ea5109d3e58c6ae5b06197c6c5
-  data.tar.gz: 169adf1025e3c1bb46fa58fd45e79d05c2eb45e4ffb069c25bec1c10b786f3dddca32c97f54556353bd48fb9580e2becc279f5a11185373857af4dff64694635
+  metadata.gz: 49878c205424a5534e811af19bf09ebe0e3c8aefbd3127a1ee0695d3a5c77eec2beb74715455ff32d7bde613e8a1eff8241dc35ba77a79915770e1ee68c60ba0
+  data.tar.gz: 4396ee06e34a48236e858274010356123f66847686a04763b4b4992283ae30f8dd6b0d96e7086803339a97f9ffbc2c158d2563a8840a288c330623f11680de8b

data/Manifest.txt

@@ -71,10 +71,13 @@ lib/activefacts/cql/compiler/shared.rb
 lib/activefacts/cql/compiler/value_type.rb
 lib/activefacts/cql/nodes.rb
 lib/activefacts/cql/parser.rb
+lib/activefacts/dependency_analyser.rb
 lib/activefacts/generate/absorption.rb
+lib/activefacts/generate/composition.rb
 lib/activefacts/generate/cql.rb
 lib/activefacts/generate/dm.rb
 lib/activefacts/generate/help.rb
+lib/activefacts/generate/helpers/inject.rb
 lib/activefacts/generate/helpers/oo.rb
 lib/activefacts/generate/helpers/ordered.rb
 lib/activefacts/generate/helpers/rails.rb
@@ -85,9 +88,14 @@ lib/activefacts/generate/records.rb
 lib/activefacts/generate/ruby.rb
 lib/activefacts/generate/sql/mysql.rb
 lib/activefacts/generate/sql/server.rb
+lib/activefacts/generate/stats.rb
 lib/activefacts/generate/rails/schema.rb
 lib/activefacts/generate/rails/models.rb
 lib/activefacts/generate/text.rb
+lib/activefacts/generate/topics.rb
+lib/activefacts/generate/traits/oo.rb
+lib/activefacts/generate/traits/ordered.rb
+lib/activefacts/generate/traits/ruby.rb
 lib/activefacts/generate/transform/surrogate.rb
 lib/activefacts/generate/version.rb
 lib/activefacts/input/cql.rb
@@ -107,6 +115,7 @@ lib/activefacts/vocabulary.rb
 lib/activefacts/vocabulary/extensions.rb
 lib/activefacts/vocabulary/metamodel.rb
 lib/activefacts/vocabulary/verbaliser.rb
+lib/activefacts/vocabulary/query_evaluator.rb
 script/txt2html
 spec/cql/comparison_spec.rb
 spec/cql/contractions_spec.rb

data/examples/CQL/Metamodel.cql

@@ -31,6 +31,7 @@ Rotation Setting is written as String restricted to {'left', 'right'};
 Scale is written as Unsigned Integer(32);
 Subscript is written as Unsigned Integer(16);
 Text is written as String(256);
+Topic Name is written as Name;
 Transaction Phase is written as String restricted to {'assert', 'commit'};
 X is written as Signed Integer(32);
 Y is written as Signed Integer(32);
@@ -165,6 +166,10 @@ Subset Constraint is a kind of Set Constraint;
 Subset Constraint covers one subset-Role Sequence;
 Subset Constraint covers one superset-Role Sequence;
 
+Topic is identified by its Name;
+Concept belongs to at most one Topic,
+	Topic contains Concept;
+
 Unit is identified by Concept where
 	Unit is an instance of one Concept;
 Ephemera URL provides Unit coefficient,

data/lib/activefacts/cql/compiler.rb

@@ -56,6 +56,15 @@ module ActiveFacts
         extend language_module
       end
 
+      # Mark any new Concepts as belonging to this topic
+      def topic_flood
+	@constellation.Concept.each do |key, concept|
+	  next if concept.topic
+	  trace :topic, "Colouring #{concept.describe} with #{@topic.topic_name}"
+	  concept.topic = @topic
+	end
+      end
+
       def compile input
         include_language
 
@@ -75,7 +84,14 @@ module ActiveFacts
               ast.vocabulary = @vocabulary
               value = compile_definition ast
               trace :definition, "Compiled to #{value.is_a?(Array) ? value.map{|v| v.verbalise}*', ' : value.verbalise}" if value
-              @vocabulary = value if ast.is_a?(Compiler::Vocabulary)
+	      if value.is_a?(ActiveFacts::Metamodel::Topic)
+		topic_flood if @topic
+		@topic = value
+	      elsif ast.is_a?(Compiler::Vocabulary)
+		topic_flood if @topic
+		@vocabulary = value
+		@topic = @constellation.Topic(@vocabulary.name)
+	      end
             rescue => e
               # Augment the exception message, but preserve the backtrace
               start_line = @string.line_of(node.interval.first)
@@ -86,6 +102,7 @@ module ActiveFacts
               raise ne
             end
           end
+	  topic_flood if @topic
         end
         raise failure_reason unless ok
         vocabulary
@@ -96,12 +113,18 @@ module ActiveFacts
         saved_block = @block
         saved_string = @string
         saved_input_length = @input_length
+        saved_topic = @topic
         old_filename = @filename
         @filename = File.dirname(old_filename)+'/'+file+'.cql'
 
         # REVISIT: Save and use another @vocabulary for this file?
         File.open(@filename) do |f|
-          ok = parse_all(f.read, nil, &@block)
+	  topic_flood if @topic
+	  @topic = @constellation.Topic(File.basename(@filename, '.cql'))
+	  trace :import, "Importing #{@filename} as #{@topic.topic_name}" do
+	    ok = parse_all(f.read, nil, &@block)
+	  end
+	  @topic = saved_topic
         end
 
       rescue => e

data/lib/activefacts/cql/compiler/constraint.rb

@@ -47,8 +47,16 @@ module ActiveFacts
 
       class Constraint < Definition
         def initialize context_note, enforcement, clauses_lists = []
-          if context_note.is_a?(Treetop::Runtime::SyntaxNode)
+          if context_note.is_a?(Treetop::Runtime::SyntaxNode) && !context_note.empty?
             context_note = context_note.empty? ? nil : context_note.ast
+	  else
+	    context_note = nil	# Perhaps a context note got attached to one of the clauses. Steal it.
+	    clauses_lists.detect do |clauses_list|
+	      if c = clauses_list.last.context_note
+		context_note = c
+		clauses_list.last.context_note = nil
+	      end
+	    end
           end
           @context_note = context_note
           @enforcement = enforcement

data/lib/activefacts/cql/compiler/fact_type.rb

@@ -323,6 +323,7 @@ module ActiveFacts
 		:max_frequency => 1,
 		:is_preferred_identifier => true # (prefer || !!@fact_type.entity_type)
 	      )
+	      pc.concept.topic = @fact_type.concept.topic
 	      trace :constraint, "Made new fact type implicit PC GUID=#{pc.concept.guid} #{pc.name} min=nil max=1 over #{rs.describe}"
 	    elsif pc
 	      trace :constraint, "Will rely on existing UC GUID=#{pc.concept.guid} #{pc.name} to be used as PI over #{rs.describe}"

data/lib/activefacts/cql/compiler/shared.rb

@@ -116,7 +116,11 @@ module ActiveFacts
         end
 
         def compile
-          @constellation.Vocabulary @name
+          if @constellation.Vocabulary.size > 0
+	    @constellation.Topic @name
+	  else
+	    @constellation.Vocabulary @name
+	  end
         end
 
         def to_s

data/lib/activefacts/dependency_analyser.rb

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

data/lib/activefacts/generate/composition.rb

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