activefacts-compositions 1.9.5 → 1.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61900437c96a5fa32c68fdcc195c8a681ace3cd9
-  data.tar.gz: 9f4917265c5b36482552e74c554197e2fa390874
+  metadata.gz: 9dd27f8a8f6a05f883483391f31e2a026b9a52b4
+  data.tar.gz: cc0355b8f29a879c654d7e36e542a95045e71994
 SHA512:
-  metadata.gz: c052e52630a0a814533cab84d1880bf9518968be13dde299d167514496c411acc4a5708c4c9bd35f0f670c0e15f28a5973ee0fc8b8868921f6df4b146bf5b8e4
-  data.tar.gz: 7f475031a473c7f0ee566d33baaf49c9785cca3e4c2b142e16e0e176993ee387d64bf03e893debb3ee575e4f72afbd6aa652e059bdaec8fc644dea524cad71fe
+  metadata.gz: 2dc13c0b861580a23517fe1fe50f6dd4d8b88a42fb7ee15827119992c090172386efb984855a7ecf81f97a682e3439201f718bd1ae7fcb7aeeb3420317c86230
+  data.tar.gz: 45854d64978972f11839794e6c6fe0cd38a0e09c0c13f66081e9a0580cd4d01503350f144946dd22174b06530c0394b72632f5ac0fa660ba1ddf706e036bcb55

data/Gemfile

@@ -2,9 +2,11 @@ source 'https://rubygems.org'
 
 gemspec
 
-if ENV['PWD'] =~ %r{\A#{ENV['HOME']}/work}i
-  $stderr.puts "Using work area gems for #{File.basename(File.dirname(__FILE__))} from activefacts-compositions"
-  gem 'activefacts-api', path: '../api'
-  gem 'activefacts-metamodel', path: '../metamodel'
-  gem 'activefacts-cql', path: '../cql'
+this_file = File.absolute_path(__FILE__)
+if this_file =~ %r{\A#{ENV['HOME']}}i
+  dir = File.dirname(File.dirname(this_file))
+  $stderr.puts "Using work area gems in #{dir} from activefacts-compositions"
+  gem 'activefacts-api', path: dir+'/api'
+  gem 'activefacts-metamodel', path: dir+'/metamodel'
+  gem 'activefacts-cql', path: dir+'/cql'
 end

data/README.md

@@ -2,16 +2,17 @@
 
 Fact-based schemas are always in highly normalised or *elementary* form.
 Most other schemas are composite (object-oriented, relational, warehousing, analytical, messaging, APIs, etc).
-This gem provides the framework for *Compositions*, which are representations of the two-way mapping between an elementary schema and a composite schema.
-As such, it supports any-to-any mappings between different composite forms.
 
-It also provides automated generators for some types of composite schemas, especially relational and Data Vault schemas.
+A *Composition* is a representation of the two-way mapping between an elementary schema and the composite schemas.
 
-This gem works with the Fact Modeling tools as part of ActiveFacts.
+This gem provides:
+* an API for compositions,
+* several compositors which create Compositions - O-O, Relational and Data Vault and
+* some generators which emit various kinds of output (Ruby, SQL) etc, for composed schemas.
 
-## Installation
+This gem builds on the Fact Modeling Metamodel and languages of ActiveFacts.
 
-Install as part of activefacts, just "gem install" directly, or add this line to your application's Gemfile:
+## Installation
 
 ```ruby
 gem 'activefacts-compositions'
@@ -19,24 +20,18 @@ gem 'activefacts-compositions'
 
 And then execute:
 
-    $ bundle
+    $ schema_compositor --help
 
 ## Usage
 
-This gem adds schema manipulation tools (mappers, composers, transformations) to the generator framework for *activefacts*.
-Refer to the afgen command-line tool for help:
-
-    $ afgen --help
-
-A stand-alone relational generator program is provided, mostly for exploratory purposes; use tracing to see what it is doing, e.g.:
-
-    $ TRACE=relational bin/schema_compositor --surrogate spec/relational/CompanyDirectorEmployee.cql
+    $ bin/schema_compositor --relational --sql spec/relational/CompanyDirectorEmployee.cql
+    $ bin/schema_compositor --binary --ruby spec/relational/CompanyDirectorEmployee.cql
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake rspec` to run the tests.
+After checking out the repo, run `bundle` to install dependencies. Then, run `rake rspec` to run the tests.
 
-To install this gem onto your local machine, run `bundle exec rake install`.
+To install this gem onto your local machine from local source code, run `rake install`.
 
 ## Contributing
 

data/activefacts-compositions.gemspec

@@ -15,18 +15,19 @@ Gem::Specification.new do |spec|
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", ">= 1.10", "~> 1.10.6"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.3"
 
-  spec.add_runtime_dependency("activefacts-api", "~> 1", ">= 1.9.4")
-  spec.add_runtime_dependency("activefacts-metamodel", "~> 1", ">= 1.9.5")
+  spec.add_development_dependency "activefacts", "~> 1", ">= 1.8"
+
+  spec.add_runtime_dependency("activefacts-api", "~> 1", ">= 1.9.5")
+  spec.add_runtime_dependency("activefacts-metamodel", "~> 1", ">= 1.9.6")
   spec.add_runtime_dependency "tracing", "~> 2", ">= 2.0.6"
 
-  spec.add_development_dependency "activefacts", "~> 1", ">= 1.8"
-  spec.add_development_dependency "activefacts-cql", "~> 1", ">= 1.8"
+  spec.add_runtime_dependency "activefacts-cql", "~> 1", ">= 1.8"
 end

data/bin/schema_compositor

@@ -1,6 +1,6 @@
 #! /usr/bin/env ruby
 #
-#       ActiveFacts: Read a Vocabulary (from a NORMA, CQL or other file) and run a generator
+# ActiveFacts: Read a model (CQL, ORM, etc), run a compositor, then a generator
 #
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
@@ -8,90 +8,108 @@ ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
 require 'bundler/setup' # Set up gems listed in the Gemfile.
 $:.unshift File.dirname(File.expand_path(__FILE__))+"/../lib"
 
+require 'activefacts/loadable'
 require 'activefacts/metamodel'
-require 'activefacts/compositions/binary'
-require 'activefacts/compositions/relational'
-require 'activefacts/compositions/validator'
+require 'activefacts/compositions'
+require 'activefacts/generator'
 
+# Parse options into a hash, and values for each option into a hash
 options = {}
-while arg = ARGV.shift and arg =~ /^-/
-  option, value = arg.split(/=/, 2)
-  options[option.sub(/^-*/,'')] = value =~ /,/ ? value.split(',') : (value || true)
+while ARGV[0] =~ /^-/
+  option, value = ARGV.shift.split(/=/, 2)
+  options[option.sub(/^-*/,'')] =
+    (value =~ /,/ ? value.split(',') : Array(value)).
+    inject({}){|h,s| k, v = s.split(/=/, 2); h[k] = v || true; h }
 end
 
-validate = options.delete('validate')
-show = options.delete('show')
+# Load and enumerate all available compositors:
+compositions_path = "activefacts/compositions"
+Loadable.new(compositions_path).
+enumerate.
+select do |filename|
+  begin
+    require(pathname = compositions_path+"/"+filename)
+  rescue LoadError => e
+  rescue Exception => e
+    puts "Can't load #{pathname}: #{e.class}: #{e.message} #{e.backtrace[0]}"
+  end
+end
 
-# Load the file type input method
-if arg
-  arg, input_options = *arg.split(/=/, 2)
-  extension = arg.sub(/\A.*\./,'').downcase
-  input_handler = "activefacts/input/#{extension}"
-  require input_handler
+# Load and enumerate all available generators
+generators_path = "activefacts/generator"
+Loadable.new(generators_path).
+enumerate.
+select do |filename|
+  begin
+    require(pathname = generators_path+"/"+filename)
+  rescue LoadError => e
+  rescue Exception => e
+    puts "Can't load #{pathname}: #{e.class}: #{e.message} #{e.backtrace[0]}"
+  end
+end
 
-  input_class = extension.upcase
-  input_klass = ActiveFacts::Input.const_get(input_class.to_sym)
-  raise "Expected #{input_handler} to define #{input_class}" unless input_klass
+if options['help']
+  puts "Available compositors:\n\t#{ActiveFacts::Compositions.compositors.keys.sort*"\n\t"}\n\n"
+  puts "Available generators:\n\t#{ActiveFacts::Generators.generators.keys.sort*"\n\t"}\n\n"
+  exit
 end
 
-# Read the input file:
-begin
-  if input_klass
-    vocabulary = input_klass.readfile(arg, *input_options)
-  else
-    vocabulary = true
+# Arrange the requested compositors and generators:
+compositors = []
+generators = []
+options.clone.each do |option, mode|
+  if action = ActiveFacts::Compositions.compositors[option]
+    options.delete(option)
+    compositors << [action, mode]
+  elsif action = ActiveFacts::Generators.generators[option]
+    options.delete(option)
+    generators << [action, mode]
   end
+  if mode && mode['help']
+    puts "REVISIT: Help for #{option} is not yet available"
+  end
+end
 
-  exit 0 unless vocabulary
+# Process each input file:
+ARGV.each do |arg|
+  filename, input_options = *arg.split(/=/, 2)
 
-  vocabulary.finalise unless vocabulary == true
+  # Load the correct file type input method
+  pathname, basename, extension = * /(?:(.*)[\/\\])?(.*)\.([^.]*)$/.match(filename).captures
+  input_handler = "activefacts/input/#{extension}"
+  require input_handler
 
-  compositor = ActiveFacts::Compositions::Relational.new(vocabulary.constellation, "test", options)
-  compositor.generate
+  input_class = extension.upcase
+  input_klass = ActiveFacts::Input.const_get(input_class.to_sym)
+  raise "Expected #{input_handler} to define #{input_class}" unless input_klass
 
-  if validate
-    trace.enable 'composition_validator'
-    compositor.validate do |component, problem|
-      trace :composition_validator, "!!PROBLEM!! #{component.inspect}: #{problem}"
+  # Read the input file:
+  vocabulary =
+    if input_klass
+      begin
+	input_klass.readfile(filename, *input_options)
+      rescue => e
+	$stderr.puts "#{e.message}"
+	if trace :exception
+	  $stderr.puts "\t#{e.backtrace*"\n\t"}"
+	else
+	  $stderr.puts "\t#{e.backtrace[0]}"
+	end
+	exit 1
+      end
     end
-  end
-
-  if show
-    compositor.
-    composition.
-    all_composite.
-    sort_by{|composite| composite.mapping.name}.
-    each do |composite|
-      puts composite.mapping.name
-      indices = composite.all_indices_by_rank
+  exit 0 unless vocabulary
+  vocabulary.finalise unless vocabulary == true
 
-      composite.mapping.leaves.each do |leaf|
-	# Build a symbolic representation of the index participation of this leaf
-	pos = 0
-	indexing = indices.inject([]) do |a, index|
-	  pos += 1
-	  if part = index.position_in_index(leaf)
-	    a << "#{pos}.#{part}"
-	  end
-	  a
-	end
+  # Run each compositor
+  compositors.each do |compositor_klass, mode|
+    compositor = compositor_klass.new(vocabulary.constellation, basename, mode||{})
+    compositor.generate
 
-	puts "\t#{leaf.path.map{|component|
-	    if component.is_a?(ActiveFacts::Metamodel::Absorption) && component.foreign_key
-	      "[#{component.name}]"
-	    else
-	      component.name
-	    end +
-	      (component.is_a?(ActiveFacts::Metamodel::Absorption) && !component.parent_role.is_mandatory ? '?' : '')
-	  }*'->'}" +
-	  (indexing.empty? ? '' : "[#{indexing*','}]")	# Show the indexing
-      end
+    # Run each generator
+    generators.each do |generator, mode|
+      output = generator.new(compositor.composition, mode||{}).generate
+      puts output if output
     end
   end
-
-rescue => e
-  $stderr.puts "#{e.message}"
-  # puts "\t#{e.backtrace*"\n\t"}"
-  $stderr.puts "\t#{e.backtrace*"\n\t"}" if trace :exception
-  exit 1
 end

data/lib/activefacts/compositions.rb

@@ -4,5 +4,12 @@ require "activefacts/compositions/compositor"
 
 module ActiveFacts
   module Compositions
+    def self.compositors
+      @@compositors ||= {}
+    end
+
+    def self.publish_compositor klass
+      compositors[klass.name.sub(/^ActiveFacts::Compositions::/,'').gsub(/::/, '/').downcase] = klass
+    end
   end
 end

data/lib/activefacts/compositions/binary.rb

@@ -1,4 +1,4 @@
-#
+### Composition
 # ActiveFacts Compositions, Binary Compositor.
 #
 #	Fans of RDF will like this one.
@@ -17,6 +17,7 @@ module ActiveFacts
 	  @binary_mappings.keys.sort_by(&:name).each do |object_type|
 	    mapping = @binary_mappings[object_type]
 	    mapping.re_rank
+	    composite = @constellation.Composite(mapping, composition: @composition)
 	  end
 	end
 
@@ -29,5 +30,6 @@ module ActiveFacts
 
       end
     end
+    publish_compositor(Binary)
   end
 end

data/lib/activefacts/compositions/compositor.rb

@@ -15,6 +15,8 @@ require "activefacts/metamodel"
 
 module ActiveFacts
   module Compositions
+    private
+      MM = ActiveFacts::Metamodel
     class Compositor
       attr_reader :options, :name, :composition
 
@@ -107,7 +109,7 @@ module ActiveFacts
 	    object_type.all_role.each do |role|
 	      # Exclude base roles in objectified fact types (unless unary); just use link fact types
 	      next if role.fact_type.entity_type && role.fact_type.all_role.size != 1
-	      next if role.variable_as_projection   # REVISIT: Continue to ignore roles in derived fact types?
+	      next if role.variable   # REVISIT: Continue to ignore roles in derived fact types?
 	      populate_reference object_type, role
 	    end
 	    if object_type.is_a?(ActiveFacts::Metamodel::ValueType)
@@ -127,7 +129,8 @@ module ActiveFacts
 #	if role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) && role == role.fact_type.subtype_role
 #	  return "Is "+role.object_type.name
 #	end
-	String::Words.new(role.base_role.preferred_reference.role_name(nil)).capwords*' '
+	role = role.base_role unless role.base_role.fact_type.all_role.size == 1
+	String::Words.new(role.preferred_reference.role_name(nil)).capwords*' '
       end
 
       def role_type role

data/lib/activefacts/compositions/constraints.rb

@@ -0,0 +1,86 @@
+#
+# ActiveFacts Compositions, Metamodel aspect for Constraint classification
+# 
+# Copyright (c) 2016 Clifford Heath. Read the LICENSE file.
+#
+require "activefacts/metamodel"
+
+module ActiveFacts
+  module Metamodel
+    class Composition
+      def retract_constraint_classifications
+	all_composite.each(&:retract_constraint_classifications)
+      end
+
+      def classify_constraints
+	retract_constraint_classifications
+	all_composite.each(&:classify_constraints)
+      end
+    end
+
+    class Composite
+      def retract_constraint_classifications
+	all_spanning_constraint.to_a.each(&:retract)
+	all_local_constraint.to_a.each(&:retract)
+	mapping.leaves.each do |component|
+	  component.all_leaf_constraint.to_a.each(&:retract)
+	end
+      end
+
+      def classify_constraints
+	leaves = mapping.leaves
+
+	# Categorise and index all constraints not already baked-in to the composition
+	all_composite_roles = []
+	all_composite_constraints = []
+	constraints_by_leaf = {}
+	leaves.each do |leaf|
+	  all_composite_roles += leaf.path.flat_map(&:all_role)	  # May be non-unique, fix later
+	  leaf.all_role.each do |role|
+	    role.all_constraint.each do |constraint|
+	      if constraint.is_a?(PresenceConstraint)
+		# Exclude single-role mandatory constraints and all uniqueness constraints:
+		if constraint.role_sequence.all_role_ref.size == 1 && constraint.min_frequency == 1 && constraint.is_mandatory or
+		    constraint.max_frequency == 1
+		  next
+		end
+	      end
+	      all_composite_constraints << constraint
+	      (constraints_by_leaf[leaf] ||= []) << constraint
+	    end
+	  end
+	end
+
+	all_composite_roles.uniq!
+	all_composite_constraints.uniq!
+	spanning_constraints =
+	  all_composite_constraints.reject do |constraint|
+	    (constraint.all_constrained_role-all_composite_roles).size == 0
+	  end
+	local_constraints = all_composite_constraints - spanning_constraints
+
+	spanning_constraints.each do |spanning_constraint|
+	  constellation.SpanningConstraint(composite: self, spanning_constraint: spanning_constraint)
+	end
+
+	leaves.each do |leaf|
+	  # Find any constraints that affect just this leaf:
+	  leaf_constraints = (constraints_by_leaf[leaf]||[]).
+	    reject do |constraint|
+	      (constraint.all_constrained_role - leaf.all_role).size > 0
+	    end
+	  local_constraints -= leaf_constraints
+	  leaf_constraints.each do |leaf_constraint|
+	    constellation.LeafConstraint(component: leaf, leaf_constraint: leaf_constraint)
+	  end
+	end
+
+	local_constraints.each do |local_constraint|
+	  constellation.LocalConstraint(composite: self, local_constraint: local_constraint)
+	end
+
+      end
+    end
+
+  end
+end

data/lib/activefacts/compositions/names.rb

@@ -0,0 +1,80 @@
+#
+# ActiveFacts Compositions, Metamodel aspect to build compacted column names for (leaf) Components
+#
+#	Compresses the names arising from absorption paths into usable column names
+#
+# Copyright (c) 2016 Clifford Heath. Read the LICENSE file.
+#
+require "activefacts/compositions"
+
+module ActiveFacts
+  module Metamodel
+    class Component
+      def column_name
+	column_path = path[1..-1]
+	prev_words = []
+	String::Words.new(
+	  column_path.
+	  inject([]) do |na, member|
+	    is_absorption = member.is_a?(Absorption)
+	    is_type_inheritance = is_absorption && member.parent_role.fact_type.is_a?(TypeInheritance)
+	    fact_type = is_absorption && member.parent_role.fact_type
+
+	    # If the parent object identifies the child via this absorption, skip it.
+	    if member != column_path.first and
+		is_absorption and
+		!is_type_inheritance and
+		member.parent_role.base_role.is_identifying
+	      trace :names, "Skipping #{member}, identifies non-initial object"
+	      next na
+	    end
+
+	    words = member.name.words
+
+	    if na.size > 0 && is_type_inheritance
+	      # When traversing type inheritances, keep the subtype name, not the supertype names as well:
+	      if member.child_role != fact_type.subtype_role
+		trace :names, "Skipping supertype #{member}"
+		next na
+	      end
+	      trace :names, "Eliding supertype in #{member}"
+	      prev_words.size.times{na.pop}
+
+	    elsif member.parent && member != column_path.first && is_absorption && member.child_role.base_role.is_identifying
+	      # When Xyz is followed by identifying XyzID (even if we skipped the Xyz), truncate that to just ID
+	      pnames = member.parent.name.words
+	      if pnames == words[0, pnames.size]
+		pnames.size.times do
+		  pnames.shift
+		  words.shift
+		end
+	      end
+	    end
+
+	    # If the reference is to the single identifying role of the object_type making the reference,
+	    # strip the object_type name from the start of the reference role
+	    if na.size > 0 and
+		is_absorption and
+		member.child_role.base_role.is_identifying and
+		(et = member.object_type).is_a?(EntityType) and
+		et.preferred_identifier.role_sequence.all_role_ref.size == 0 and
+		et.name.downcase == words[0][0...et.name.size].downcase
+	      trace :columns, "truncating transitive identifying role #{words.inspect}"
+	      words[0] = words[0][et.name.size..-1]
+	      words.shift if words[0] == ''
+	    end
+
+	    prev_words = words
+	    na += words.to_a
+	  end.elide_repeated_subsequences do |a, b|
+	    if a.is_a?(Array)
+	      a.map{|e| e.downcase} == b.map{|e| e.downcase}
+	    else
+	      a.downcase == b.downcase
+	    end
+	  end
+	)
+      end
+    end
+  end
+end