activefacts-compositions 1.9.10 → 1.9.12

data/lib/activefacts/compositions/relational.rb

@@ -14,14 +14,14 @@ module ActiveFacts
 
       def self.options
         {
-          surrogates: ['Boolean', "Inject a surrogate key into each table whose primary key is not already suitable as a foreign key"]
-        }
+          surrogates: ['Boolean', "Inject a surrogate key into each table whose primary key is not already suitable as a foreign key"],
+        }.merge(Compositor.options)
       end
 
-      def initialize constellation, name, options = {}
+      def initialize constellation, name, options = {}, compositor_name = 'Relational'
         # Extract recognised options:
         @option_surrogates = options.delete('surrogates')
-        super constellation, name, options
+        super constellation, name, options, compositor_name
       end
 
       def generate
@@ -183,10 +183,10 @@ module ActiveFacts
                 next true if a.full_absorption && child_candidate.full_absorption.absorption != a
 
                 # If our counterpart is a full absorption, don't try to reverse that!
-                next false if (a.forward_absorption || a.reverse_absorption).full_absorption
+                next false if (aa = (a.forward_absorption || a.reverse_absorption)) && aa.full_absorption
 
                 # Otherwise the other end must already be a table or fully absorbed into one
-                next false unless child_candidate.is_table || child_candidate.full_absorption
+                next false unless child_candidate.nil? || child_candidate.is_table || child_candidate.full_absorption
 
                 next false unless a.child_role.is_unique && a.parent_role.is_unique   # Must be one-to-one
 
@@ -347,7 +347,7 @@ module ActiveFacts
           # * there are no other columns (that might require updating) and
           # * the object is not the target of a foreign key:
           if non_fk_surrogate
-            trace :surrogates, "#{composite.inspect} has non-FK identifiers so requires a surrogate"
+            trace :surrogates, "#{composite.inspect} has non-FK identifiers (in #{key_members.inspect}) so requires a surrogate"
             return true
           end
 
@@ -389,7 +389,7 @@ module ActiveFacts
           trace :surrogates, "#{composite.inspect} already has an auto-assigned key so does NOT require a surrogate"
           return false
         end
-        trace :surrogates, "#{composite.inspect} requires a surrogate"
+        trace :surrogates, "#{composite.inspect} PK is #{key_member.inspect} which requires a surrogate"
         return true
       end
 

data/lib/activefacts/compositions/staging.rb

@@ -14,7 +14,8 @@ module ActiveFacts
       def self.options
         {
           stgname: ['String', "Suffix or pattern for naming staging tables. Include a + to insert the name. Default 'STG'"],
-        }
+        }.merge(Relational.options).
+        reject{|k,v| [:surrogates].include?(k) }
       end
 
       def initialize constellation, name, options = {}
@@ -22,7 +23,7 @@ module ActiveFacts
         @option_stg_name = options.delete('stgname') || 'STG'
         @option_stg_name.sub!(/^/,'+ ') unless @option_stg_name =~ /\+/
 
-        super constellation, name, options
+        super constellation, name, options, 'Staging'
 
       end
 

data/lib/activefacts/compositions/version.rb

@@ -1,5 +1,5 @@
 module ActiveFacts
   module Compositions
-    VERSION = "1.9.10"
+    VERSION = "1.9.12"
   end
 end

data/lib/activefacts/generator/doc/cwm.rb

@@ -21,15 +21,11 @@ module ActiveFacts
         attr_accessor   :xmiid
       end
       
-      class ActiveFacts::Metamodel::Absorption      # for columns
+      class ActiveFacts::Metamodel::Component      # for columns
         attr_accessor   :xmiid
         attr_accessor   :index_xmiid
       end
       
-      class ActiveFacts::Metamodel::Indicator
-        attr_accessor   :xmiid
-      end
-      
       class ActiveFacts::Metamodel::Index           # for primary and unique indexes
         attr_accessor   :xmiid
       end
@@ -38,11 +34,6 @@ module ActiveFacts
         attr_accessor   :xmiid
       end
       
-      class ActiveFacts::Metamodel::ValueField
-        attr_accessor   :xmiid
-        attr_accessor   :index_xmiid
-      end
-      
       class CWM      
         MM = ActiveFacts::Metamodel unless const_defined?(:MM)
         def self.options
@@ -51,9 +42,8 @@ module ActiveFacts
           }
         end
 
-        def initialize compositions, options = {}
-          raise "--cwm only processes a single composition" if compositions.size > 1
-          @composition = compositions[0]
+        def initialize composition, options = {}
+          @composition = composition
           @options = options
           @underscore = options.has_key?("underscore") ? (options['underscore'] || '_') : ''
 
@@ -141,12 +131,14 @@ module ActiveFacts
         def populate_table_ids(table)
           tname = table_name(table)
           nsdef(table)
-          table.mapping.all_leaf.flat_map do |leaf|
+          table.mapping.all_leaf.flat_map.sort_by{|c| column_name(c)}.map do |leaf|
             # Absorbed empty subtypes appear as leaves
             next if leaf.is_a?(MM::Absorption) && leaf.parent_role.fact_type.is_a?(MM::TypeInheritance)
             nsdef(leaf)
           end
-          table.all_index.map do |index|
+          table.all_index.sort_by do |idx| 
+            idx.all_index_field.map { |ixf| ixf.component.xmiid }
+          end.map do |index|
             nsdef(index)
             index.all_index_field.map{|idf| idf.component.index_xmiid = index.xmiid}
           end
@@ -162,7 +154,7 @@ module ActiveFacts
           "<XMI xmlns:CWM=\"org.omg.CWM1.1\" xmlns:CWMRDB=\"org.omg.CWM1.1/Relational\" xmi.version=\"1.1\">\n" +
           "  <XMI.header>\n" +
           "    <XMI.documentation>\n" +
-          "      <XMI.exporter>Infinuedo APRIMO</XMI.exporter>\n" +
+          "      <XMI.exporter>ActiveFacts</XMI.exporter>\n" +
           "      <XMI.exporterVersion>0.1</XMI.exporterVersion>\n" +
           "    </XMI.documentation>\n" +
           "    <XMI.metamodel xmi.name=\"CWM\" xmi.version=\"1.1\" />" +
@@ -228,7 +220,9 @@ module ActiveFacts
 
           table_keys =
             indent(depth, "  <CWM:Namespace.ownedElement>") +
-            (table.all_index.map do |index|
+              (table.all_index.sort_by do |idx| 
+                idx.all_index_field.map { |ixf| ixf.component.xmiid }
+              end.map do |index|
                 generate_index(depth+2, table.xmiid, index, name, table.all_foreign_key_as_target_composite)
               end
             ) * "" +

data/lib/activefacts/generator/oo.rb

@@ -18,9 +18,8 @@ module ActiveFacts
         }
       end
 
-      def initialize compositions, options = {}
-        raise "--oo only processes a single composition" if compositions.size > 1
-        @composition = compositions[0]
+      def initialize composition, options = {}
+        @composition = composition
         @options = options
         @comments = @options.delete("comments")
       end

data/lib/activefacts/generator/rails/models.rb

@@ -22,9 +22,8 @@ module ActiveFacts
           })
         end
 
-        def initialize compositions, options = {}
-          raise "--rails/models only processes a single composition" if compositions.size > 1
-          @composition = compositions[0]
+        def initialize composition, options = {}
+          @composition = composition
           @options = options
           @option_output = options.delete("output")
           @option_concern = options.delete("concern")

data/lib/activefacts/generator/rails/schema.rb

@@ -24,9 +24,8 @@ module ActiveFacts
           })
         end
 
-        def initialize compositions, options = {}
-          raise "--rails/schema only processes a single composition" if compositions.size > 1
-          @composition = compositions[0]
+        def initialize composition, options = {}
+          @composition = composition
           @options = options
           @option_exclude_fks = options.delete("exclude_fks")
           @option_include_comments = options.delete("include_comments")

data/lib/activefacts/generator/ruby.rb

@@ -20,8 +20,7 @@ module ActiveFacts
         )
       end
 
-      def initialize compositions, options = {}
-        raise "--ruby only processes a single composition" if compositions.size > 1
+      def initialize composition, options = {}
         super
         @scope = options.delete('scope') || ''
         @scope = @scope.split(/::/)

data/lib/activefacts/generator/sql.rb

@@ -14,35 +14,47 @@ module ActiveFacts
   module Generators
     # Options are comma or space separated:
     # * delay_fks Leave all foreign keys until the end, not just those that contain forward-references
-    # * underscore 
+    # * underscore
     class SQL
       MM = ActiveFacts::Metamodel unless const_defined?(:MM)
       def self.options
         {
           delay_fks: ['Boolean', "Delay emitting all foreign keys until the bottom of the file"],
-          underscore: [String, "Use 'str' instead of underscore between words in table names"],
+          underscore: ['String', "Use 'str' instead of underscore between words in table names"],
           unicode: ['Boolean', "Use Unicode for all text fields by default"],
+          # datavault: ['String', "Generate 'raw' or 'business' data vault tables"],
+          restrict: ['String', "Restrict generation to tables in the specified group (e.g. bdv, rdv)"]
         }
       end
 
-      def initialize compositions, options = {}
-        raise "--sql only processes a single composition" if compositions.size > 1
-        @composition = compositions[0]
+      def initialize composition, options = {}
+        @composition = composition
         @options = options
         @delay_fks = options.delete "delay_fks"
         @underscore = options.has_key?("underscore") ? (options['underscore'] || '_') : ''
         @unicode = options.delete "unicode"
+        @restrict = options.delete "restrict"
+        # Legacy option. Use restrict=bdv/rdv instead
+        @datavault = options.delete "datavault"
+        case @datavault
+        when "business"
+          @restrict = "bdv"
+        when "raw"
+          @restrict = "rdv"
+        end
       end
 
       def generate
         @tables_emitted = {}
         @delayed_foreign_keys = []
 
+        @composite_list = @composition.all_composite.sort_by{|composite| composite.mapping.name}
+        if @restrict
+          @composite_list.select!{|composite| g = composite.composite_group and g.name == @restrict}
+        end
+
         generate_schema +
-        @composition.
-        all_composite.
-        sort_by{|composite| composite.mapping.name}.
-        map{|composite| generate_table composite}*"\n" + "\n" +
+        @composite_list.map{|composite| generate_table composite}*"\n" + "\n" +
         @delayed_foreign_keys.sort*"\n"
       end
 
@@ -88,7 +100,9 @@ module ActiveFacts
           end.compact.sort +
           composite.all_foreign_key_as_source_composite.map do |fk|
             fk_text = generate_foreign_key fk
-            if !@delay_fks and @tables_emitted[fk.composite]
+            if !@delay_fks and  # We're not delaying foreign keys unnecessarily
+                @tables_emitted[fk.composite] ||          # Already done
+                !@composite_list.include?(fk.composite)   # Not going to be done
               fk_text
             else
               @delayed_foreign_keys <<
@@ -195,12 +209,12 @@ module ActiveFacts
             MM::DataType.normalise_int_length('int', data_type_context.default_surrogate_length, value_constraint, data_type_context)[0]
           else
             v, = MM::DataType.normalise_int_length(type_name, length, value_constraint, data_type_context)
-            v
+            v   # The typename here has the appropriate length, don't return a length
           end
         when MM::DataType::TYPE_Real;
           ["FLOAT", data_type_context.default_length(type, type_name)]
-        when MM::DataType::TYPE_Decimal;  'DECIMAL'
-        when MM::DataType::TYPE_Money;    'DECIMAL'
+        when MM::DataType::TYPE_Decimal;  ['DECIMAL', length]
+        when MM::DataType::TYPE_Money;    ['DECIMAL', length]
         when MM::DataType::TYPE_Char;     [data_type_context.default_char_type, length || data_type_context.char_default_length]
         when MM::DataType::TYPE_String;   [data_type_context.default_varchar_type, length || data_type_context.varchar_default_length]
         when MM::DataType::TYPE_Text;     [data_type_context.default_text_type, length || 'MAX']
@@ -213,10 +227,10 @@ module ActiveFacts
           if length
             ['BINARY', length]
           else
-            'VARBINARY'
+            ['VARBINARY', length]
           end
         else
-          type_name
+          [type_name, length]
         end
       end
 

data/lib/activefacts/generator/summary.rb

@@ -1,6 +1,6 @@
 #
 # ActiveFacts Compositions, Metamodel aspect to create a textual summary of a composition and its Composites
-# 
+#
 # Copyright (c) 2015 Clifford Heath. Read the LICENSE file.
 #
 require "activefacts/metamodel"
@@ -13,7 +13,11 @@ module ActiveFacts
     class Composition
       def summary
         classify_constraints
-        "Summary of #{name}\n" +
+
+        vn = (v = constellation.Vocabulary.values[0]) ? v.version_number : nil
+        version_str = vn ? " version #{vn}" : ''
+
+        "Summary of #{name}#{version_str}\n" +
         all_composite.
         sort_by{|composite| composite.mapping.name}.
         flat_map do |composite|
@@ -35,14 +39,15 @@ module ActiveFacts
 
             # Build a display of the names in this absorption path, with FK and optional indicators
             path_names = leaf.path.map do |component|
-                is_mandatory = case component
-                  when Indicator
-                    false
-                  when Absorption
-                    component.parent_role.is_mandatory
-                  else
-                    true
-                  end
+                is_mandatory = true
+                is_unique = true
+                case component
+                when Absorption
+                  is_mandatory = component.parent_role.is_mandatory
+                  is_unique = component.parent_role.is_unique
+                when Indicator
+                  is_mandatory = false
+                end
 
                 if component.all_foreign_key_field.size > 0
                   "[#{component.name}]"
@@ -51,8 +56,8 @@ module ActiveFacts
                 else
                   component.name
                 end +
-                  (is_mandatory ? '' : '?')
-              end*'->' 
+                  (is_mandatory ? '' : '?') + (is_unique ? '' : '*')
+              end*'->'
 
             # Build a symbolic representation of the index participation of this leaf
             pos = 0
@@ -63,8 +68,8 @@ module ActiveFacts
               end
               a
             end
-            if indexing.empty? 
-              indexing = '' 
+            if indexing.empty?
+              indexing = ''
             else
               indexing = "[#{indexing*','}]"
             end
@@ -92,13 +97,13 @@ module ActiveFacts
         }
       end
 
-      def initialize compositions, options = {}
-        @compositions = compositions
+      def initialize composition, options = {}
+        @composition = composition
         @options = options
       end
 
       def generate
-        @compositions.map(&:summary)*"\n\n"
+        @composition.summary
       end
     end
     publish_generator Summary

data/lib/activefacts/generator/transgen.rb

@@ -0,0 +1,144 @@
+#
+#       ActiveFacts Tranformation Rule Stub Generator
+#
+# Copyright (c) 2017 Factil Pty Ltd. Read the LICENSE file.
+#
+require 'digest/sha1'
+require 'activefacts/metamodel'
+require 'activefacts/metamodel/datatypes'
+require 'activefacts/compositions'
+require 'activefacts/compositions/names'
+require 'activefacts/generator'
+
+module ActiveFacts
+  module Generators
+    class TransGen
+      INDENT = "    "
+      def self.options
+        {
+        }
+      end
+
+      def initialize composition, options = {}
+        @composition = composition
+        @options = options
+      end
+
+      def generate
+        @constellation = @composition.constellation
+        @transform_topic = @constellation.Topic.values.select{|t| t.all_import_as_precursor_topic.size == 0}.first
+        if !@constellation.Vocabulary.values.to_a[0].is_transform
+          raise "Expected input file to be transform"
+        end
+
+        source_imports = @constellation.Import.values.select{|imp| imp.topic == @transform_topic && imp.import_role == "source"}
+        target_imports = @constellation.Import.values.select{|imp| imp.topic == @transform_topic && imp.import_role == "target"}
+
+        composite_list = @composition.all_composite.select do |composite|
+          target_imports.detect do |imp|
+            imp.precursor_topic.all_concept.detect{|c| c.object_type == composite.mapping.object_type}
+          end
+        end.sort_by{|composite| composite.mapping.name}
+
+        generate_header(source_imports, target_imports) +
+        composite_list.map{|composite| generate_transform_rule composite}*"\n" + "\n"
+      end
+
+      def generate_header source_imports, target_imports
+        "transform #{@transform_topic.topic_name};\n" +
+        "\n" +
+        source_imports.map{|imp| "import source #{imp.precursor_topic.topic_name};"} * "\n" + "\n" +
+        target_imports.map{|imp| "import target #{imp.precursor_topic.topic_name};"} * "\n" + "\n" +
+        "\n"
+      end
+
+      def generate_transform_rule composite
+        existing_rules = @transform_topic.all_concept.select do |concept|
+          tr = concept.transform_rule and
+            tr.compound_matching.all_transform_target_ref.to_a[0].object_type == composite.mapping.object_type
+        end.map {|concept| concept.transform_rule}
+
+        if existing_rules.size > 0
+          existing_rules.map{|tr| regenerate_transform_rule(composite, tr)} * "\n\n"
+        else
+          generate_new_transform_rule(composite)
+        end
+      end
+
+      def indent text, level
+        INDENT * level + text
+      end
+
+      def leading_hyphenate leading_adjective
+        words = leading_adjective.words
+        if words.size == 1
+          leading_adjective + '-'
+        else
+          words[0] + '- ' + words[1..-1].join(' ')
+        end
+      end
+
+      def trailing_hyphenate trailing_adjective
+        words = trailing_adjective.words
+        if words.size == 1
+          '-' + trailing_adjective
+        else
+          words[0...-1].join(' ') + ' -' + words[-1]
+        end
+      end
+
+      def full_role_name mapping
+        if mapping.is_a?(ActiveFacts::Metamodel::Absorption)
+          la = mapping.child_role.all_role_ref.to_a[0].leading_adjective
+          ta = mapping.child_role.all_role_ref.to_a[0].trailing_adjective
+          (la ? leading_hyphenate(la) + ' ' : '') + mapping.object_type.name + (ta ? ' ' + trailing_hyphenate(ta) : '')
+        else
+          mapping.object_type.name
+        end
+      end
+
+      #
+      # New transform rule
+      #
+      def generate_new_transform_rule composite
+        generate_compound_matching(composite.mapping, 0, '') + ";\n"
+      end
+
+      def generate_transform_matching mapping, level, prefix
+        if mapping.object_type.is_a?(ActiveFacts::Metamodel::ValueType)
+          generate_simple_matching(mapping, level, prefix)
+        else
+          generate_compound_matching(mapping, level, prefix)
+        end
+      end
+
+      def generate_simple_matching mapping, level, prefix
+        full_name = full_role_name(mapping)
+        prefixed_name = (prefix.size > 0 ? prefix + ' . ' : '') + full_name
+        indent("#{prefixed_name} <-- /* EXPR */", level)
+      end
+
+      def generate_compound_matching mapping, level, prefix
+        members = mapping.all_member.sort_by(&:ordinal).flatten
+        prefixed_name = (prefix.size > 0 ? prefix + ' . ' : '') + full_role_name(mapping)
+        if members.size == 1
+          generate_transform_matching(members[0], level, prefixed_name)
+        else
+          indent("#{prefixed_name} <== /* OBJECT TYPE or QUERY */ {\n", level) +
+          members.map do |m|
+            generate_transform_matching(m, level + 1, '')
+          end * ",\n" + "\n" +
+          indent("}", level)
+        end
+      end
+
+      #
+      # Regenerate existing transform rule
+      #
+      def regenerate_transform_rule(composite, transform_rule)
+        # regenerate_compound_matching(composite.mapping, 0, '') + ";\n"
+      end
+    end
+    publish_generator TransGen
+  end
+end