activefacts-compositions 1.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: af89821431e548908e46672ee76691aad15ebd4b
+  data.tar.gz: 7edd1f9827bac4270fcf8ee99fc91f84adbd4ba3
+SHA512:
+  metadata.gz: f3747c23b121ab364f9b1fcdd543436df2a3a81c56f269059210eb66ba69041520f9aa26ae505cdd5ac7dbc7a19aa1e05421a3d15a039896f170d4c16a9a299e
+  data.tar.gz: e2ece71a45faf5ee7559b7f2171e52d00605f3df4d7f037358c0d29bb14691e47e37e1b14e9ea8eb53fc776cee6b8697e95114783adb84dd19ef2396a6166e13

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.swp
+.DS_Store
+*.rej
+*.orig
+*.diff

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,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+if ENV['PWD'] =~ %r{\A#{ENV['HOME']}/work}
+  $stderr.puts "Using work area gems for #{File.basename(File.dirname(__FILE__))} from activefacts-compositions"
+  gem 'activefacts-api', path: '/Users/cjh/work/activefacts/api'
+  gem 'activefacts-metamodel', path: '/Users/cjh/work/activefacts/metamodel'
+  gem 'activefacts-cql', path: '/Users/cjh/work/activefacts/cql'
+  # 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,43 @@
+# ActiveFacts::Compositions
+
+Create and represent composite schemas, schema transforms and data transforms over a fact-based model.
+
+This gem works with the Fact Modeling tools as part of ActiveFacts.
+
+## Installation
+
+Install via the activefacts gem bundle, or add this line to your application's Gemfile:
+
+```ruby
+gem 'activefacts-compositions'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install activefacts-compositions
+
+## Usage
+
+This gem adds schema manipulation tools (mappers, composers, transformations, generators) to the generator framework for activefacts. Refer to the afgen command-line tool for help:
+
+    $ afgen --help
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake rspec` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/cjheath/activefacts-compositions.
+
+
+## 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-compositions.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'activefacts/compositions/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "activefacts-compositions"
+  spec.version       = ActiveFacts::Compositions::VERSION
+  spec.authors       = ["Clifford Heath"]
+  spec.email         = ["clifford.heath@gmail.com"]
+
+  spec.summary       = %q{Create and represent composite schemas, schema transforms and data transforms over a fact-based model}
+  spec.description   = %q{Create and represent composite schemas, schema transforms and data transforms over a fact-based model}
+  spec.homepage      = "https://github.com/cjheath/activefacts-compositions"
+  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.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-metamodel", ">= 1.8", "~> 1.8.3")
+  spec.add_development_dependency "activefacts", "~> 1.8", "~> 1.8.0"
+  spec.add_development_dependency "activefacts-cql", "~> 1.8", "~> 1.8.0"
+end

data/bin/schema_compositor

@@ -0,0 +1,49 @@
+#! /usr/bin/env ruby
+#
+#       ActiveFacts: Read a Vocabulary (from a NORMA, CQL or other file) and run a generator
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+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/metamodel'
+require 'activefacts/compositions/binary'
+require 'activefacts/compositions/relational'
+
+arg = ARGV.shift
+
+# Load the file type input method
+if arg
+  arg, *options = *arg.split(/=/)
+  extension = arg.sub(/\A.*\./,'').downcase
+  input_handler = "activefacts/input/#{extension}"
+  require input_handler
+
+  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
+end
+
+# Read the input file:
+begin
+  if input_klass
+    vocabulary = input_klass.readfile(arg, *options)
+  else
+    vocabulary = true
+  end
+
+  exit 0 unless vocabulary
+
+  vocabulary.finalise unless vocabulary == true
+
+  compositor = ActiveFacts::Compositions::Relational.new(vocabulary.constellation, "test")
+  compositor.generate
+
+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

@@ -0,0 +1,8 @@
+require "activefacts/metamodel"
+require "activefacts/compositions/version"
+require "activefacts/compositions/compositor"
+
+module ActiveFacts
+  module Compositions
+  end
+end

data/lib/activefacts/compositions/binary.rb

@@ -0,0 +1,33 @@
+#
+# ActiveFacts Compositions, Binary Compositor.
+#
+#	Fans of RDF will like this one.
+#
+# Copyright (c) 2015 Clifford Heath. Read the LICENSE file.
+#
+require "activefacts/compositions"
+
+module ActiveFacts
+  module Compositions
+    class Binary < Compositor
+      def generate
+	super
+
+	trace :binary_, "Constructing Binary Composition" do
+	  @binary_mappings.keys.sort_by(&:name).each do |object_type|
+	    mapping = @binary_mappings[object_type]
+	    mapping.re_rank
+	  end
+	end
+
+	trace :binary_, "Full binary composition" do
+	  @binary_mappings.keys.sort_by(&:name).each do |object_type|
+	    mapping = @binary_mappings[object_type]
+	    mapping.show_trace 
+	  end
+	end
+
+      end
+    end
+  end
+end

data/lib/activefacts/compositions/compositor.rb

@@ -0,0 +1,182 @@
+#
+# ActiveFacts Compositions, Fundamental Compositor
+# 
+#	All Compositors derive from this one, which can calculate the basic binary bi-directional mapping
+#
+#	The term "reference" used here means either an Absorption
+#	(one direction of a binary fact type relating two object types),
+#	or an Indicator (for a unary fact type).
+#
+#	n-ary fact types and other objectified fact types are factored out by using the associated LinkFactTypes.
+#
+# Copyright (c) 2015 Clifford Heath. Read the LICENSE file.
+#
+require "activefacts/metamodel"
+
+module ActiveFacts
+  module Compositions
+    class Compositor
+      def initialize constellation, name, options = {}
+	@constellation = constellation
+	@name = name
+	@options = options
+      end
+
+      # Generate all Mappings into @binary_mappings for a binary composition of all ObjectTypes in this constellation
+      def generate
+	# Retract an existing composition by this name
+	if existing = @constellation.Name[[@name]] and
+	    @composition = existing.composition
+	  @composition.all_composite.to_a.each{|composite| composite.retract}
+	  @composition.retract
+	end
+
+	@composition = @constellation.Composition(:new, :name => @name)
+	populate_references
+      end
+
+    private
+      def populate_reference object_type, role
+	parent = @binary_mappings[role.object_type]
+
+	return if role.fact_type.all_role.size > 2
+	if role.fact_type.all_role.size != 1
+	  counterpart = role.counterpart
+	  rt = role_type(counterpart)
+	  if rt == :many_many
+	    raise "Can't absorb many-to-many (until we absorb derived fact types, or don't require explicit objectification)"
+	  end
+
+	  a = @constellation.Absorption(
+	      :new,
+	      name: counterpart.name,
+	      parent: parent,
+	      object_type: counterpart.object_type,
+	      parent_role: role,
+	      child_role: counterpart
+	    )
+	  # Populate the absorption/reverse_absorption (putting the "many" or optional side as reverse)
+	  if r = @component_by_fact[role.fact_type]
+	    # Second occurrence of this fact type, set the direction:
+	    if a.is_preferred_direction
+	      a.absorption = r
+	    else  # Set this as the reverse absorption
+	      a.reverse_absorption = r
+	    end
+	  else
+	    # First occurrence of this fact type
+	    @component_by_fact[role.fact_type] = a
+	  end
+	else	# It's an indicator
+	  a = @constellation.Indicator(
+	      :new,
+	      name: role.name,
+	      parent: parent,
+	      role: role
+	    )
+	  @component_by_fact[role.fact_type] = a  # For completeness, in case a subclass uses it
+	end
+	trace :binarize, "Populating #{a.inspect}"
+      end
+
+      def populate_references
+	# A table of Mappings by object type, with a default Mapping for each:
+	@binary_mappings = Hash.new do |h, object_type|
+	  h[object_type] = @constellation.Mapping(
+	      :new,
+	      name: object_type.name,
+	      object_type: object_type
+	    )
+	end
+	@component_by_fact = {}
+
+	@constellation.ObjectType.each do |key, object_type|
+	  trace :binarize, "Populating possible absorptions for #{object_type.name}" do
+	    @binary_mappings[object_type]  # Ensure we create the top Mapping even if it has no references
+
+	    object_type.all_role.each do |role|
+	      next if role.mirror_role_as_base_role # Exclude base roles, just use link fact types
+	      next if role.variable_as_projection   # REVISIT: Continue to ignore roles in derived fact types?
+	      populate_reference object_type, role
+	    end
+	    if object_type.is_a?(ActiveFacts::Metamodel::ValueType)
+	      # This requires a change in the metamodel to use TypeInheritance for ValueTypes
+	      if object_type.supertype
+		trace :binarize, "REVISIT: Eliding supertype #{object_type.supertype.name} for #{object_type.name}"
+	      end
+	      object_type.all_value_type_as_supertype.each do |subtype|
+		trace :binarize, "REVISIT: Eliding subtype #{subtype.name} for #{object_type.name}"
+	      end
+	    end
+	  end
+	end
+      end
+
+      def role_type role
+	fact_type = role.fact_type
+	if fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+	  return role.object_type == fact_type.supertype ? :supertype : :subtype
+	end
+
+	return :unary if fact_type.all_role.size == 1
+
+	if fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
+	  # Prevent an unnecessary from-1 search:
+	  from_1 = true
+	  # Change the to_1 search to detect a one-to-one:
+	  role = fact_type.implying_role
+	  fact_type = role.fact_type
+	end
+
+	# List the UCs on this fact type:
+        all_uniqueness_constraints =
+          fact_type.all_role.map do |fact_role|
+            fact_role.all_role_ref.map do |rr|
+              rr.role_sequence.all_presence_constraint.select do |pc|
+                pc.max_frequency == 1
+              end
+            end
+          end.flatten.uniq
+
+	# It's to-1 if a UC exists over exactly this role:
+        to_1 =
+          all_uniqueness_constraints.
+            detect do |c|
+                (rr = c.role_sequence.all_role_ref.single) and
+                rr.role == role
+            end 
+
+        if from_1 || fact_type.entity_type
+          # This is a role in an objectified fact type
+          from_1 = true
+        else
+          # It's from-1 if a UC exists over roles of this FT that doesn't cover this role:
+          from_1 = all_uniqueness_constraints.detect{|uc|
+            !uc.role_sequence.all_role_ref.detect{|rr| rr.role == role || rr.role.fact_type != fact_type}
+          }
+        end
+
+        if from_1
+          return to_1 ? :one_one : :one_many
+        else
+          return to_1 ? :many_one : :many_many
+        end
+      end
+
+      # Display the primitive binary mapping:
+      def show_references
+	trace :composition, "Displaying the mappings:" do
+	  @binary_mappings.keys.sort_by(&:name).each do |object_type|
+	    mapping = @binary_mappings[object_type]
+	    trace :composition, "#{object_type.name}" do
+	      mapping.all_member.each do |component|
+		trace :composition, component.inspect
+	      end
+	    end
+	  end
+	end
+      end
+
+    end
+  end
+end

data/lib/activefacts/compositions/relational.rb

@@ -0,0 +1,406 @@
+#
+# ActiveFacts Compositions, Relational Compositor.
+#
+#	Computes an Optimal Normal Form (close to 5NF) relational schema.
+#
+# Copyright (c) 2015 Clifford Heath. Read the LICENSE file.
+#
+require "activefacts/compositions"
+
+module ActiveFacts
+  module Compositions
+    class Relational < Compositor
+    private
+      MM = ActiveFacts::Metamodel
+    public
+      def generate
+	trace :relational_mapping, "Generating relational composition" do
+	  super
+
+	  # Make a data structure to help in computing the tables
+	  make_candidates
+
+	  # Apply any obvious table/non-table factors
+	  assign_default_tabulation
+
+	  # Figure out how best to absorb things to reduce the number of tables
+	  optimise_absorption
+
+	  # Remove the un-used absorption paths
+	  delete_reverse_absorptions
+
+	  # Actually make a Composite object for each table:
+	  make_composites
+
+	  # If a value type has been mapped to a table, add a column to hold its value
+	  inject_value_fields
+
+	  # Traverse the absorbed objects to build the path to each required column, including foreign keys:
+	  absorb_all_columns
+
+	  # Remove mappings for objects we have absorbed
+	  clean_unused_mappings
+
+	  trace :relational_, "Full relational composition" do
+	    @composition.all_composite.sort_by{|composite| composite.mapping.name}.each do |composite|
+	      composite.mapping.show_trace
+	    end
+	  end
+	end
+      end
+
+      def make_candidates
+	@candidates = @binary_mappings.inject({}) do |hash, (absorption, mapping)|
+	  hash[mapping.object_type] = Candidate.new(mapping)
+	  hash
+	end
+      end
+
+      def assign_default_tabulation
+	trace :relational_mapping, "Preparing relational composition by setting default assumptions" do
+	  @candidates.each do |object_type, candidate|
+	    candidate.assign_default
+	  end
+	end
+      end
+
+      def optimise_absorption
+	trace :relational_mapping, "Optimise Relational Composition" do
+	  undecided = @candidates.keys.select{|object_type| @candidates[object_type].is_tentative}
+	  pass = 0
+	  finalised = []
+	  begin
+	    pass += 1
+	    trace :relational_mapping, "Starting optimisation pass #{pass}" do
+	      finalised = optimise_absorption_pass(undecided)
+	    end
+	    trace :relational_mapping, "Finalised #{finalised.size} on this pass: #{finalised.map{|f| f.name}*', '}"
+	    undecided -= finalised
+	  end while !finalised.empty?
+	end
+      end
+
+      def optimise_absorption_pass undecided
+	possible_flips = {}
+	undecided.select do |object_type|
+	  candidate = @candidates[object_type]
+	  trace :relational_mapping, "Considering possible status of #{object_type.name}" do
+
+	    # Rule 1: Always absorb an objectified unary into its role player:
+	    if (f = object_type.fact_type) && f.all_role.size == 1
+	      trace :relational_mapping, "Absorb objectified unary #{object_type.name} into #{f.all_role.single.object_type.name}"
+	      candidate.definitely_not_table
+	      next object_type
+	    end
+
+	    # Rule 2: If the preferred_identifier contains one role only, played by an entity type that can absorb us, do that:
+	    absorbing_ref = nil
+	    pi_roles = []
+	    if object_type.is_a?(MM::EntityType) and		  # We're an entity type
+	      (pi_roles = object_type.preferred_identifier_roles).size == 1 and	  # Our PI has one role
+	      pi_roles[0].object_type.is_a?(MM::EntityType) and	  # played by another Entity Type
+	      candidate.references_from.detect do |absorption|
+		  next unless absorption.is_a?(MM::Absorption)
+		  next unless absorption.child_role == pi_roles[0] # Not the identifying absorption
+
+		  # Look at the other end; make sure it's a forward absorption:
+		  absorption = absorption.reverse_absorption ? absorption.reverse_absorption : absorption.flip!
+
+		  next absorbing_ref = absorption
+		end
+	      trace :relational_mapping, "#{object_type.name} is fully absorbed along its sole reference path #{absorbing_ref.inspect}"
+	      candidate.definitely_not_table
+	      next object_type
+	    end
+
+	    # Rule 3: If there's more than one absorption path and any functional dependencies that can't absorb us, it's a table
+	    # REVISIT: If one of the absorption paths is our identifier, we can be absorbed into that with out dependencies, and the other absorption paths can just reference us there...
+	    non_identifying_refs_from =
+	      candidate.references_from.reject do |absorption|
+		absorption.is_a?(MM::Absorption) && pi_roles.include?(absorption.child_role.base_role)
+	      end
+	    trace :relational_mapping, "#{object_type.name} has #{non_identifying_refs_from.size} non-identifying functional roles" do
+	      non_identifying_refs_from.each do |a|
+		trace :relational_mapping, a.inspect
+	      end
+	    end
+
+	    trace :relational_mapping, "#{object_type.name} has #{candidate.references_to.size} references to it" do
+	      candidate.references_to.each do |a|
+		trace :relational_mapping, a.inspect
+	      end
+	    end
+	    if candidate.references_to.size > 1 and
+		non_identifying_refs_from.size > 0
+	      trace :relational_mapping, "#{object_type.name} has #{non_identifying_refs_from.size} non-identifying functional dependencies and #{candidate.references_to.size} absorption paths so 3NF requires it be a table"
+	      candidate.definitely_table
+	      next object_type
+	    end
+
+	    # At this point, this object has no functional dependencies that would prevent its absorption
+	    next false if !candidate.is_table	# We can't reduce the number of tables by absorbing this one
+
+	    absorption_paths =
+	      ( non_identifying_refs_from +   # But we should exclude any that are already involved in an absorption; pre-decided ET=>ET or supertype absorption!
+	        candidate.references_to
+	      ).reject do |a|
+		next true unless a.is_a?(MM::Absorption)
+		cc = @candidates[a.child_role.object_type]
+		next true if !cc.is_table
+		next true if !(a.child_role.is_unique && a.parent_role.is_unique)
+
+		# Allow the sole identifying role for this object
+		next false if pi_roles.size == 1 && pi_roles.include?(a.parent_role)
+		next true unless a.parent_role.is_mandatory
+		next true if cc.is_absorbed # REVISIT: We can be absorbed into something that's also absorbed, but not into us!
+		false
+	      end
+
+	    trace :relational_mapping, "#{object_type.name} has #{absorption_paths.size} absorption paths"
+
+	    # Rule 4: If this object can be fully absorbed along non-identifying roles, do that (maybe flip some absorptions)
+	    if absorption_paths.size > 0
+	      trace :relational_mapping, "#{object_type.name} is fully absorbed in #{absorption_paths.size} places" do
+		absorption_paths.each do |a|
+		  flip = a.reverse_absorption
+		  a.flip! if flip
+		  trace :relational_mapping, "#{object_type.name} is FULLY ABSORBED via #{a.inspect}#{flip ? ' (flipped)' : ''}"
+		end
+	      end
+
+	      candidate.definitely_not_table
+	      candidate.is_absorbed = true
+	      next object_type
+	    end
+
+	    # Rule 5: If this object has no functional dependencies, it can be fully absorbed (must be along an identifying role?)
+	    if non_identifying_refs_from.size == 0
+	      trace :relational_mapping, "#{object_type.name} is fully absorbed in #{candidate.references_to.size} places: #{candidate.references_to.map{|ref| ref.inspect}*", "}"
+	      candidate.definitely_not_table
+	      candidate.is_absorbed = true
+	      next object_type
+	    end
+
+	    false   # Otherwise we failed to make a decision about this object type
+	  end
+	end
+      end
+
+      # Remove the unused reverse absorptions:
+      def delete_reverse_absorptions
+	@binary_mappings.each do |object_type, mapping|
+	  mapping.all_member.to_a.		# Avoid problems with deletion from all_member
+	  each do |member|
+	    next unless member.is_a?(MM::Absorption)
+	    member.retract if member.reverse_absorption	# This is the reverse of some absorption
+	  end
+	  mapping.re_rank
+	end
+      end
+
+      # Inject a ValueField for each value type that's a table:
+      def inject_value_fields
+	@constellation.Composite.each do |key, composite|
+	  mapping = composite.mapping
+	  if mapping.object_type.is_a?(MM::ValueType) and !mapping.all_member.detect{|m| m.is_a?(MM::ValueField)}
+	    trace :relational_mapping, "Adding value field for #{mapping.object_type.name}"
+	    @constellation.ValueField(
+	      :new,
+	      parent: mapping,
+	      name: mapping.object_type.name+" Value",
+	      object_type: mapping.object_type
+	    )
+	    mapping.re_rank
+	  end
+	end
+      end
+
+      # After all table/non-table decisions are made, convert Mappings for tables into Composites and retract the rest:
+      def make_composites
+	@candidates.keys.to_a.each do |object_type|
+	  candidate = @candidates[object_type]
+	  mapping = candidate.mapping
+	  if candidate.is_table
+	    composite = @constellation.Composite(mapping, composition: @composition)
+	  else
+	    @candidates.delete(object_type)
+	  end
+	end
+      end
+
+      def clean_unused_mappings
+	@candidates.keys.to_a.each do |object_type|
+	  candidate = @candidates[object_type]
+	  next if candidate.is_table
+	  mapping = candidate.mapping
+	  mapping.retract
+	  @binary_mappings.delete(object_type)
+	end
+      end
+
+      # Absorb all items which aren't tables (and keys to those which are) recursively
+      def absorb_all_columns
+	trace :relational_mapping, "Absorbing full contents of all tables" do
+	  @composition.all_composite_by_name.each do |composite|
+	    trace :relational_mapping, "Absorbing contents of #{composite.mapping.name}" do
+	      absorb_all composite.mapping, nil
+	    end
+	  end
+	end
+      end
+
+      def absorb_all mapping, from
+	(from||mapping).all_member.each do |member|
+	  member = fork_component_to_new_parent mapping, member if from	  # Top-level members are already instantiated
+	  if member.is_a?(MM::Absorption)
+	    # Should we absorb a foreign key or the whole contents?
+	    table = @candidates[member.child_role.object_type]
+	    trace :relational_mapping, "Absorbing #{table ? 'key' : 'contents'} of #{member.child_role.name} in #{member.inspect_reading}" do
+	      target = @binary_mappings[member.child_role.object_type]
+	      if table
+		absorb_key member, target
+	      else
+		absorb_all member, target
+	      end
+	    end
+	  end
+	end
+	# mapping.re_rank
+      end
+
+      # Recursively add members to this component for the existential roles of
+      # the composite mapping for the absorbed (child_role) object:
+      def absorb_key mapping, target
+	target.all_member.each do |member|
+	  next unless member.rank_key[0] == MM::Component::RANK_IDENT
+	  member = fork_component_to_new_parent mapping, member
+	  if member.is_a?(MM::Absorption)
+	    absorb_key member, @binary_mappings[member.child_role.object_type]
+	  end
+	end
+	# mapping.re_rank
+      end
+
+      def fork_component_to_new_parent parent, component
+	case component
+	# A place to put more special cases.
+	when MM::ValueField
+	  # When we fork from a ValueField, we want to use the name of the ValueType, not the ValueField name
+	  @constellation.fork component, guid: :new, parent: parent, name: component.object_type.name
+	else
+	  @constellation.fork component, guid: :new, parent: parent
+	end
+      end
+
+      # A candidate is a Mapping of an object type which may become a Composition (a table, in relational-speak)
+      class Candidate
+	attr_reader :mapping, :is_table, :is_tentative
+	attr_accessor :is_absorbed
+
+	def initialize mapping
+	  @mapping = mapping
+	end
+
+	def object_type
+	  @mapping.object_type
+	end
+
+	# References from us are things we can absorb and have a forward absorption for
+	def references_from
+	  # Anything that's not a Mapping must be an Absorption
+	  @mapping.all_member.select{|m| !m.is_a?(MM::Mapping) or !m.reverse_absorption && m.parent_role.is_unique }
+	end
+	alias_method :rf, :references_from
+
+	# References to us are things that can absorb us and they have a forward absorption for
+	def references_to
+	  @mapping.all_member.map{|m| m.is_a?(MM::Mapping) ? m.reverse_absorption : nil}.compact.select{|r| r.parent_role.is_unique }
+	end
+	alias_method :rt, :references_to
+
+	def has_references
+	  @mapping.all_member.select{|m| m.is_a?(MM::Absorption) }
+	end
+
+	def definitely_not_table
+	  @is_tentative = @is_table = false
+	end
+
+	def definitely_table
+	  @is_tentative = false
+	  @is_table = true
+	end
+
+	def probably_not_table
+	  @is_tentative = true
+	  @is_table = false
+	end
+
+	def probably_table
+	  @is_tentative = @is_table = true
+	end
+
+	def assign_default
+	  o = object_type
+	  if o.is_separate
+	    trace :relational_mapping, "#{o.name} is a table because it's declared independent or separate"
+	    definitely_table
+	    return
+	  end
+
+	  case o
+	  when MM::ValueType
+	    if o.is_auto_assigned
+	      trace :relational_mapping, "#{o.name} is not a table because it is auto assigned"
+	      definitely_not_table
+	    elsif references_from.size > 0
+	      trace :relational_mapping, "#{o.name} is a table because it has references to absorb"
+	      definitely_table
+	    else
+	      trace :relational_mapping, "#{o.name} is not a table because it will be absorbed wherever needed"
+	      definitely_not_table
+	    end
+
+	  when MM::EntityType
+	    if references_to.empty? and
+		!references_from.detect do |absorption|	  # detect whether anything can absorb this entity type
+		  absorption.is_a?(MM::Mapping) && absorption.parent_role.is_unique && absorption.child_role.is_unique
+		end
+	      trace :relational_mapping, "#{o.name} is a table because it has nothing to absorb it"
+	      definitely_table
+	      return
+	    end
+	    if !o.supertypes.empty?
+	      # We know that this entity type is not a separate or partitioned subtype, so a supertype that can absorb us does
+	      identifying_fact_type = o.preferred_identifier.role_sequence.all_role_ref.to_a[0].role.fact_type
+	      if identifying_fact_type.is_a?(MM::TypeInheritance)
+		trace :relational_mapping, "#{o.name} is absorbed into supertype #{identifying_fact_type.supertype_role.name}"
+		definitely_not_table
+	      else
+		trace :relational_mapping, "Subtype #{o.name} is initially presumed to be a table"
+		probably_not_table
+	      end
+	      return
+	    end	# subtype
+
+	    v = nil
+	    if references_to.size > 1 and   # Can be absorbed in more than one place
+		o.preferred_identifier.role_sequence.all_role_ref.detect do |rr|
+		  (v = rr.role.object_type).is_a?(MM::ValueType) and v.is_auto_assigned
+		end
+	      trace :relational_mapping, "#{o.name} must be a table to support its auto-assigned identifier #{v.name}"
+	      definitely_table
+	      return
+	    end
+
+	    trace :relational_mapping, "#{o.name} is initially presumed to be a table"
+	    probably_table
+
+	  end	# case
+	end
+
+      end
+
+    end
+  end
+end

data/lib/activefacts/compositions/version.rb

@@ -0,0 +1,5 @@
+module ActiveFacts
+  module Compositions
+    VERSION = "1.9.0"
+  end
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: activefacts-compositions
+version: !ruby/object:Gem::Version
+  version: 1.9.0
+platform: ruby
+authors:
+- Clifford Heath
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.10'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.10'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.10.6
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: activefacts-metamodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+- !ruby/object:Gem::Dependency
+  name: activefacts
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+- !ruby/object:Gem::Dependency
+  name: activefacts-cql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+description: Create and represent composite schemas, schema transforms and data transforms
+  over a fact-based model
+email:
+- clifford.heath@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- activefacts-compositions.gemspec
+- bin/schema_compositor
+- lib/activefacts/compositions.rb
+- lib/activefacts/compositions/binary.rb
+- lib/activefacts/compositions/compositor.rb
+- lib/activefacts/compositions/relational.rb
+- lib/activefacts/compositions/version.rb
+homepage: https://github.com/cjheath/activefacts-compositions
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Create and represent composite schemas, schema transforms and data transforms
+  over a fact-based model
+test_files: []