activefacts-compositions 1.9.10 → 1.9.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 92a737c515247b8ec677c99cdfed1a550daf92e1
-  data.tar.gz: 863d201ecf700a29c68a83bb373ead97382ca6f5
+  metadata.gz: 7ca6ad3d9944b1f64ffde699ef36bd7b26764b0e
+  data.tar.gz: 352761a4484292f70eeb90763d7518c892d9a562
 SHA512:
-  metadata.gz: cacf53c424c21b0764ae8e2878bf1e083f1fd7bd1ba93c7075420393ee0e34a16057688298255bb21516c40b5eb1630a632cec5c778ef745388b4065e3d6eaca
-  data.tar.gz: f179277f0ce2fc207466933f2e344260c86cf7acd995c902275787b70218aca7883f1565e7d068d30c90b76f56a66db2604dce46d49ddec82d7de4a2bb1601ed
+  metadata.gz: ee1a8f1fe902ab61728c16adadedb68fe4bc2b40339d478c9b1d59e27d73c14a57c4d760a6cd61787b3eb0fe86cd9dc24da0c03bcb3609893b62967e4a6bc1bb
+  data.tar.gz: f979de0913251692a2be5c7f115ce9d81fb58147c04af65746fd1e4574723513bd99f877fa0409df316fa8aa94ecf28c37498f6477432ca862d4a912129df761

data/.gitignore

@@ -13,3 +13,4 @@
 *.orig
 *.diff
 actual
+.byebug_history

data/activefacts-compositions.gemspec

@@ -23,11 +23,12 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.3"
 
-  spec.add_development_dependency "activefacts", "~> 1", ">= 1.8"
-
-  spec.add_runtime_dependency("activefacts-api", "~> 1", ">= 1.9.11")
-  spec.add_runtime_dependency("activefacts-metamodel", "~> 1", ">= 1.9.12")
+  spec.add_runtime_dependency "activesupport", "~> 4", ">= 4.2.7"
+  spec.add_runtime_dependency "json", "~> 1.8"
   spec.add_runtime_dependency "tracing", "~> 2", ">= 2.0.6"
 
-  spec.add_runtime_dependency "activefacts-cql", "~> 1", ">= 1.8"
+  spec.add_development_dependency "activefacts", "~> 1", ">= 1.8"
+  spec.add_runtime_dependency "activefacts-api", "~> 1", ">= 1.9.11"
+  spec.add_runtime_dependency "activefacts-metamodel", "~> 1", ">= 1.9.15"
+  spec.add_runtime_dependency "activefacts-cql", "~> 1", ">= 1.9"
 end

data/bin/afcomp

@@ -0,0 +1,192 @@
+#! /usr/bin/env ruby
+#
+# ActiveFacts: Read a model (CQL, ORM, etc), run a compositor, then a generator
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+$:.unshift File.dirname(File.expand_path(__FILE__))+"/../lib"
+
+require 'pathname'
+require 'activefacts/loadable'
+require 'activefacts/metamodel'
+require 'activefacts/compositions'
+require 'activefacts/generator'
+
+class SchemaCompositor
+  EXTENSIONS = ['fiml', 'fidl', 'fiql', 'cql']
+
+  attr_reader :options
+  attr_reader :compositors
+  attr_reader :generators
+
+  # Parse options into a hash, and values for each option into a hash
+  def initialize argv
+    @options = {}
+    while argv[0] =~ /^-/
+      option, value = argv.shift.split(/:/, 2)
+      csv = (value =~ /,/ ? value.split(',') : Array(value))
+      modes = csv.inject({}){|h,s| k, v = s.split(/=/, 2); h[k] = v || true; h }
+      @options[option.sub(/^-*/,'')] = modes
+    end
+  end
+
+  # Load and enumerate all available modules in this path
+  def enumerate_available path
+    trace :loading, "Enumerating under #{path.inspect}" do
+      Loadable.new(path).
+      enumerate.
+      select do |filename|
+        begin
+          require(pathname = path+"/"+filename)
+          trace :loading, "Loaded #{pathname}"
+        # rescue LoadError => e
+        #   trace :loading, "Can't load #{pathname}: #{e.class}: #{e.message} #{e.backtrace[0]}"
+        # rescue Exception => e
+        #   $stderr.puts "Can't load #{pathname}: #{e.class}: #{e.message} #{e.backtrace[0]}"
+        end
+      end
+    end
+  end
+
+  def arrange_actions
+    # Arrange the requested compositors and generators:
+    @compositors = []
+    @generators = []
+    @options.clone.each do |option, modes|
+
+      # Flip option and first mode if option is source or target
+      if option == 'source' || option == 'target'
+        compositor, flag = modes.shift
+        modes[option] = true
+        option = compositor
+      end
+
+      if action = ActiveFacts::Compositions.compositors[option]
+        options.delete(option)
+        check_options(action, modes)
+        @compositors << [action, modes, option]
+      elsif action = ActiveFacts::Generators.generators[option]
+        options.delete(option)
+        check_options(action, modes)
+        @generators << [action, modes, option]
+      else
+        $stderr.puts "Action --#{option} is not recognised"
+        exit 1
+      end
+      if modes['help']
+        puts "Help for #{option} is not yet available"
+      end
+    end
+  end
+
+  def process_files argv
+    # Process each input file:
+    argv.each do |arg|
+      filename, input_options = *arg.split(/=/, 2)
+
+      # Load the correct file type input method
+      pathname, basename, extension = * /(?:(.*)[\/\\])?(.*)\.([^.]*)$/.match(filename).captures
+      if EXTENSIONS.detect { |e| extension == e }
+        extension = "cql"
+      end
+      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
+
+      # 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
+      exit 0 unless vocabulary
+      vocabulary.finalise unless vocabulary == true
+
+      # Run one compositor
+      if @compositors.size != 1
+        raise "Expected one compositor"
+      end
+
+      compositor_klass, modes, option = @compositors[0]
+      compositor = compositor_klass.new(vocabulary.constellation, basename, modes)
+      compositor.generate
+
+      # Run each generator
+      @generators.each do |generator_klass, modes|
+        output = generator_klass.new(compositor.composition, modes).generate
+        puts output if output
+      end
+    end
+  end
+
+  def action_name action
+    action.name.sub(/ActiveFacts::[^:]+::/,'').gsub(/::/,'/').downcase
+  end
+
+  def display_options action, stream = $stdout
+    options = action.options
+    name = action.name.sub(/ActiveFacts::[^:]+::/,'').gsub(/::/,'/').downcase
+    if options.empty?
+      stream.puts "There are no options for --#{action_name action}"
+    else
+      stream.puts "Options for --#{name} (say e.g. --#{action_name action}=option1=value,option2)"
+      options.keys.sort.each do |key|
+        type, description = *options[key]
+        tag =
+          key.to_s +
+          case type
+          when NilClass,'Boolean', TrueClass
+            ''
+          when Numeric
+            ' num'
+          when Pathname
+            ' file'
+          else
+            ' str'
+          end
+
+        stream.puts "\t#{tag}#{' '*(24-tag.size)}#{description}"
+      end
+    end
+  end
+
+  # Ensure that the options provided are supported by the action
+  def check_options action, modes
+    if modes['help']
+      display_options(action)
+      exit
+    end
+    options = action.options
+    unsupported = modes.keys.select{|k| !options.has_key?(k.to_sym)}
+    return if unsupported.empty?
+    $stderr.puts "Action --#{action_name action} does not support #{unsupported.size >1 ? 'these options' : 'this option'}: #{unsupported*', '}"
+    display_options(action, $stderr)
+    exit 1
+  end
+end
+
+sc = SchemaCompositor.new(ARGV)
+sc.enumerate_available('activefacts/compositions')
+sc.enumerate_available('activefacts/generator')
+if sc.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"
+  puts "To get help for a particular action, follow it by =help, e.g. --relational=help"
+  exit
+end
+
+sc.arrange_actions
+sc.process_files ARGV

data/bin/schema_compositor

@@ -14,6 +14,8 @@ require 'activefacts/compositions'
 require 'activefacts/generator'
 
 class SchemaCompositor
+  EXTENSIONS = ['fiml', 'fidl', 'fiql', 'cql']
+
   attr_reader :options
   attr_reader :compositors
   attr_reader :generators
@@ -22,7 +24,7 @@ class SchemaCompositor
   def initialize argv
     @options = {}
     while argv[0] =~ /^-/
-      option, value = argv.shift.split(/=/, 2)
+      option, value = argv.shift.split(/[=:]/, 2)
       csv = (value =~ /,/ ? value.split(',') : Array(value))
       modes = csv.inject({}){|h,s| k, v = s.split(/=/, 2); h[k] = v || true; h }
       @options[option.sub(/^-*/,'')] = modes
@@ -52,14 +54,22 @@ class SchemaCompositor
     @compositors = []
     @generators = []
     @options.clone.each do |option, modes|
+
+      # Flip option and first mode if option is source or target
+      if option == 'source' || option == 'target'
+        compositor, flag = modes.shift
+        modes[option] = true
+        option = compositor
+      end
+
       if action = ActiveFacts::Compositions.compositors[option]
         options.delete(option)
         check_options(action, modes)
-        @compositors << [action, modes]
+        @compositors << [action, modes, option]
       elsif action = ActiveFacts::Generators.generators[option]
         options.delete(option)
         check_options(action, modes)
-        @generators << [action, modes]
+        @generators << [action, modes, option]
       else
         $stderr.puts "Action --#{option} is not recognised"
         exit 1
@@ -77,6 +87,9 @@ class SchemaCompositor
 
       # Load the correct file type input method
       pathname, basename, extension = * /(?:(.*)[\/\\])?(.*)\.([^.]*)$/.match(filename).captures
+      if EXTENSIONS.detect { |e| extension == e }
+        extension = "cql"
+      end
       input_handler = "activefacts/input/#{extension}"
       require input_handler
 
@@ -102,16 +115,18 @@ class SchemaCompositor
       exit 0 unless vocabulary
       vocabulary.finalise unless vocabulary == true
 
-      # Run one or more compositors
-      compositions = @compositors.map do |compositor_klass, modes|
-        compositor = compositor_klass.new(vocabulary.constellation, basename, modes)
-        compositor.generate
-        compositor.composition
+      # Run one compositor
+      if @compositors.size != 1
+        raise "Expected one compositor, use --help for a list"
       end
 
+      compositor_klass, modes, option = @compositors[0]
+      compositor = compositor_klass.new(vocabulary.constellation, basename, modes)
+      compositor.generate
+
       # Run each generator
       @generators.each do |generator_klass, modes|
-        output = generator_klass.new(compositions, modes).generate
+        output = generator_klass.new(compositor.composition, modes).generate
         puts output if output
       end
     end
@@ -127,7 +142,7 @@ class SchemaCompositor
     if options.empty?
       stream.puts "There are no options for --#{action_name action}"
     else
-      stream.puts "Options for --#{name} (say e.g. --#{action_name action}=option1=value,option2)"
+      stream.puts "Options for --#{name} (say e.g. --#{action_name action}:option1=value,option2)"
       options.keys.sort.each do |key|
         type, description = *options[key]
         tag =
@@ -169,7 +184,7 @@ sc.enumerate_available('activefacts/generator')
 if sc.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"
-  puts "To get help for a particular action, follow it by =help, e.g. --relational=help"
+  puts "To get help for a particular action, follow it by =help, e.g. --relational:help"
   exit
 end
 

data/lib/activefacts/compositions/binary.rb

@@ -10,6 +10,10 @@ require "activefacts/compositions"
 module ActiveFacts
   module Compositions
     class Binary < Compositor
+      def initialize constellation, name, options = {}, compositor_name = 'Binary'
+        super constellation, name, options, compositor_name
+      end
+
       def self.options
         {}
       end

data/lib/activefacts/compositions/compositor.rb

@@ -1,6 +1,6 @@
 #
 # 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
@@ -19,13 +19,21 @@ module ActiveFacts
       attr_reader :options, :name, :composition
 
       def self.options
-        {}
+        {
+        #  source: ['Boolean', "Generate composition for source schema"],
+        #  target: ['Boolean', "Generate composition for target schema"],
+        #  transform: ['Boolean', "Generate composition for transform schema"]
+        }
       end
 
-      def initialize constellation, name, options = {}
+      def initialize constellation, name, options = {}, compositor_name
         @constellation = constellation
         @name = name
+        @compositor_name = compositor_name
         @options = options
+        # @option_source = options.delete('source')
+        # @option_target = options.delete('target')
+        # @option_transform = options.delete('transform')
       end
 
       # Generate all Mappings into @binary_mappings for a binary composition of all ObjectTypes in this constellation
@@ -37,7 +45,7 @@ module ActiveFacts
           @composition.retract
         end
 
-        @composition = @constellation.Composition(:new, :name => @name)
+        @composition = @constellation.Composition(:new, :name => @name, :compositor_name => @compositor_name)
         preload_preferred_identifiers
         populate_references
       end
@@ -92,6 +100,35 @@ module ActiveFacts
         trace :binarize, "Populating #{a.inspect}"
       end
 
+      def find_topic import_role
+        if import = @constellation.Import.values.select{ |import| import.import_role == import_role }.first
+          import.precursor_topic
+        else
+          nil
+        end
+      end
+
+      def build_binary_mappings schema_topic
+        trace :binarize, "Build_binary_mappings for #{schema_topic.topic_name}"
+        if @schema_topics.key?(schema_topic)
+          trace :binarize, "already built, skip"
+          return
+        end
+        @schema_topics[schema_topic] = true
+
+        # add binary mapping for all object types in this schema
+        schema_topic.all_concept.each do |concept|
+          if concept.object_type
+            @binary_mappings[concept.object_type]
+          end
+        end
+
+        # recurse through precursor schemas
+        schema_topic.all_import.each do |import|
+          build_binary_mappings(import.precursor_topic)
+        end
+      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|
@@ -103,11 +140,46 @@ module ActiveFacts
         end
         @component_by_fact = {}
 
-        @constellation.ObjectType.each do |key, object_type|
+        @schema_topics = {}
+=begin
+        if @option_source || @option_target
+          import_role = @option_source ? 'source' : 'target'
+          trace :binarize, "Build binary bindings for #{import_role} schema" do
+            if schema_topic = find_topic(import_role)
+              build_binary_mappings(schema_topic)
+            else
+              raise "Could not find #{import_role} schema"
+            end
+          end
+        elsif @option_transform
+          trace :binarize, "Build binary bindings for transform schema" do
+            transform_topic = @constellation.Topic.values.select do |topic|
+              nr_importers = @constellation.Import.values.select{|i| i.precursor_topic == topic}.size
+              nr_importers == 0     # This topic is not imported by anything, it's the one
+            end.first
+
+            # add binary mapping for all object types in the transform schema
+            transform_topic.all_concept.each do |concept|
+              if concept.object_type
+                @binary_mappings[concept.object_type]
+              end
+            end
+          end
+        else
+=end
+          trace :binarize, "Build binary bindings for full schema" do
+            @constellation.ObjectType.each do |key, object_type|
+              @binary_mappings[object_type]  # Ensure we create the top Mapping even if it has no references
+            end
+          end
+#        end
+
+        @binary_mappings.each do |object_type, mapping|
           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|
+              # Exclude fact types not in @schema_topics
+              next if @schema_topics.size > 0 && !@schema_topics.key?(role.fact_type.concept.topic)
               # 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   # REVISIT: Continue to ignore roles in derived fact types?
@@ -166,7 +238,7 @@ module ActiveFacts
             detect do |c|
                 (rr = c.role_sequence.all_role_ref.single) and
                 rr.role == role
-            end 
+            end
 
         if from_1 || fact_type.entity_type
           # This is a role in an objectified fact type