activefacts-generators 1.7.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e1e81fd6c874b5767f07dcb7d2f508f1be29c693
+  data.tar.gz: 497cfd7d1abc379b424acdb3e61b4c2b19de4589
+SHA512:
+  metadata.gz: 59851db95c25eba970ebb3da980838a2394a0de66d1fc8a24c004e002defbf87641f627e9be3e70f4abfa23e40ae02ce52cfe266f80cca47c2e40d1289cc1e99
+  data.tar.gz: f08d307b0a39c6dab0a6b267da237d04a45b3d820163da87fe90e9fe168971e128b232285dff8cd7e3664a17850d029203f33827194e7d598fad6ca5c7884527

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1 @@
+--format documentation

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.5
+before_install: gem install bundler -v 1.10.0.rc

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in activefacts-generators.gemspec
+gemspec
+
+if ENV['PWD'] =~ %r{\A/Users/cjh/work/activefacts}
+  gem 'activefacts-api', path: '/Users/cjh/work/activefacts/api'
+  gem 'activefacts-metamodel', path: '/Users/cjh/work/activefacts/metamodel'
+  # gem 'activefacts-metamodel', git: 'git://github.com/cjheath/activefacts-metamodel.git'
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Clifford Heath
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,30 @@
+# Activefacts::Generators
+
+Code generators for the ActiveFacts fact modeling suite, including the Constellation Query Language
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activefacts-generators'
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+After installation, the generators appear as options in the ActiveFacts generator <i>afgen</i>. Use
+
+    $ afgen --help
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/cjheath/activefacts-generators.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/activefacts-generators.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "activefacts-generators"
+  spec.version       = "1.7.1"
+  spec.authors       = ["Clifford Heath"]
+  spec.email         = ["clifford.heath@gmail.com"]
+
+  spec.summary       = %q{Code Generators for the ActiveFacts suite}
+  spec.description   = %q{Code generators for the ActiveFacts Fact Modeling suite, including the Constellation Query Language}
+  spec.homepage      = "http://github.com/cjheath/activefacts-generators"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10.a"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+
+  spec.add_runtime_dependency(%q<activefacts-metamodel>, [">= 1.7.0", "~> 1.7"])
+  spec.add_runtime_dependency(%q<activefacts-rmap>, [">= 1.7.0", "~> 1.7"])
+  spec.add_runtime_dependency(%q<activesupport>)
+end

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/generators/absorption.rb

@@ -0,0 +1,71 @@
+#
+#       ActiveFacts Generators.
+#       Absorption generator.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/metamodel'
+require 'activefacts/rmap'
+require 'activefacts/registry'
+
+module ActiveFacts
+  module Generators
+    # Emit the absorption (Relational summary) for vocabulary.
+    # Not currently working, it relies on the old relational composition code.
+    # Invoke as
+    #   afgen --absorption[=options] <file>.cql"
+    # Options are comma or space separated:
+    # * no_columns Don't emit the columns
+    # * all Show ObjectTypes that are not tables as well
+    # * paths Show the references paths through which each column was defined
+    # * no_identifier Don't show the identified_by columns for an EntityType
+
+    class Absorption
+      def initialize(vocabulary, *options)  #:nodoc:
+        @vocabulary = vocabulary
+        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+        @no_columns = options.include? "no_columns"
+        @paths = options.include? "paths"
+        @no_identifier = options.include? "no_identifier"
+      end
+
+      def generate(out = $>)  #:nodoc:
+	@out = out
+        no_absorption = 0
+        single_absorption_vts = 0
+        single_absorption_ets = 0
+        multi_absorption_vts = 0
+        multi_absorption_ets = 0
+        @vocabulary.tables
+        @vocabulary.all_object_type.sort_by{|c| c.name}.each do |o|
+          next if !o.is_table
+          show(o)
+        end
+      end
+
+      def show object_type        #:nodoc:
+        indices = object_type.indices
+        pk = indices.select(&:is_primary)[0]
+        indices = indices.clone
+        indices.delete pk
+        @out.puts "#{object_type.name}: #{
+#            "[#{object_type.indices.size} indices] "
+#          } #{
+            object_type.columns.sort_by do |column|
+              column.name(nil)
+            end.map do |column|
+              index_nrs =
+                [pk && pk.columns.include?(column) ? "*" : nil] +
+                (0...indices.size).select{|i| indices[i].columns.include?(column)}.map{|i| (i+1).to_i }
+              index_nrs.compact!
+              (@paths ? column.references.map{|r| r.to_names}.flatten : column.name(nil)) * '.' +
+                (index_nrs.empty? ? "" : "["+index_nrs*""+"]")
+            end*", "
+          }"
+
+      end
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('absorption', ActiveFacts::Generators::Absorption)

data/lib/activefacts/generators/composition.rb

@@ -0,0 +1,119 @@
+#
+#       ActiveFacts Generators.
+#       Generate a Relational Composition (for activefacts/composition).
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/metamodel'
+require 'activefacts/generators/helpers/inject'
+require 'activefacts/rmap'
+require 'activefacts/generators/traits/ruby'
+require 'activefacts/registry'
+
+module ActiveFacts
+  module Generators
+    #   afgen --composition[=options] <file>.cql
+    # Options are comma or space separated:
+    class Composition #:nodoc:
+    private
+      include RMap
+
+      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::Generators::Composition)