activefacts-compositions 1.9.22 → 1.9.23

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

@@ -19,8 +19,12 @@ module ActiveFacts
           }
         end
 
-        def initialize compositions, options = {}
-          raise "--graphviz only processes a single composition" if compositions.size > 1
+        def self.compatibility
+          [1, nil]  # one composition of ny kind
+        end
+
+        def initialize constellation, composition, options = {}
+          @constellation = constellation
           @composition = compositions[0]
           @options = options
         end

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

@@ -21,9 +21,13 @@ module ActiveFacts
           }
         end
 
-        def initialize compositions, options = {}
-          raise "--ldm only processes a single composition" if compositions.size > 1
-          @composition = compositions[0]
+        def self.compatibility
+          [1, %i{relational}]   # one relational composition
+        end
+
+        def initialize constellation, composition, options = {}
+          @constellation = constellation
+          @composition = [composition].flatten[0]
           @options = options
           @underscore = options.has_key?("underscore") ? (options['underscore'] || '_') : ''
 

data/lib/activefacts/generator/etl/unidex.rb

@@ -15,7 +15,6 @@ module ActiveFacts
   module Generators
     module ETL
       class Unidex
-
         MM = ActiveFacts::Metamodel unless const_defined?(:MM)
         def self.options
           # REVISIT: There's no way to support SQL dialect options here
@@ -29,7 +28,13 @@ module ActiveFacts
           )
         end
 
-        def initialize composition, options = {}
+        def self.compatibility
+          # REVISIT: Remove the dependency on the "persistent" option of the staging compositor.
+          [1, %i{relational}]   # one relational composition
+        end
+
+        def initialize constellation, composition, options = {}
+          @constellation = constellation
           @composition = composition
           @options = options
 

data/lib/activefacts/generator/oo.rb

@@ -18,7 +18,8 @@ module ActiveFacts
         }
       end
 
-      def initialize composition, options = {}
+      def initialize constellation, composition, options = {}
+        @constellation = constellation
         @composition = composition
         @options = options
         @comments = @options.delete("comments")

data/lib/activefacts/generator/population.rb

@@ -0,0 +1,174 @@
+#
+#       ActiveFacts Population Generator
+#
+# Copyright (c) 2018 Clifford Heath. Read the LICENSE file.
+#
+require 'digest/sha1'
+require 'activefacts/metamodel'
+require 'activefacts/metamodel/datatypes'
+require 'activefacts/compositions'
+require 'activefacts/compositions/names'
+require 'activefacts/generator'
+require 'activefacts/generator/traits/sql'
+
+module ActiveFacts
+  module Generators
+    class Population
+
+      MM = ActiveFacts::Metamodel unless const_defined?(:MM)
+      def self.options
+        # REVISIT: There's no way to support SQL dialect options here
+        sql_trait = ActiveFacts::Generators::Traits::SQL
+        Class.new.extend(sql_trait).  # Anonymous class to enable access to traits module instance methods
+        options.
+        merge(
+          {
+            dialect: [String, "SQL Dialect to use"],
+            population: [String, "Name of the fact population to process (defaults to anonymous seed population)"],
+          }
+        )
+      end
+
+      def self.compatibility
+        [1, %i{relational}]   # one relational composition
+      end
+
+      def initialize constellation, composition, options = {}
+        @constellation = constellation
+        @composition = composition
+        @options = options
+
+        @trait = ActiveFacts::Generators::Traits::SQL
+        if @dialect = options.delete("dialect")
+          require 'activefacts/generator/traits/sql/'+@dialect
+          trait_name = ActiveFacts::Generators::Traits::SQL.constants.detect{|c| c.to_s =~ %r{#{@dialect}}i}
+          @trait = @trait.const_get(trait_name)
+        end
+        self.class.include @trait
+        self.class.extend @trait
+        extend @trait
+        @population_name = options.delete("population") || ''
+
+        process_options options
+      end
+
+      def process_options options
+        super
+      end
+
+      def generate
+        @constellation = @composition.constellation
+        @vocabulary = @constellation.Vocabulary.values[0]
+        @population = @constellation.Population[[[@vocabulary.name], @population_name]]
+        raise "Population #{@population_name.inspect} doesn't exist in #{@vocabulary.name.inspect}" unless @population_name
+        @composites = @composition.all_composite.select{|c| c.mapping.object_type.all_instance.size > 0}
+        header +
+          @composites.
+          map{|c| generate_composite c}.
+          compact*"\n\n" +
+        trailer
+      end
+
+      def header
+        schema_prefix
+      end
+
+      def generate_composite composite
+        leaf_column_names = composite.mapping.all_leaf.map do |leaf|
+          [leaf, safe_column_name(leaf)]
+        end
+
+        "-- #{composite.mapping.name}\n" +
+        composite.mapping.object_type.all_instance.map do |instance|
+          ncv = named_column_values leaf_column_names, instance
+          %Q{INSERT INTO #{safe_table_name composite}(#{ncv.map{|name, value|name}*', '})\n} +
+          %Q{\tVALUES (#{ncv.map{|name, value| value}*', '});}
+        end.sort * "\n"
+      end
+
+      def named_column_values leaf_column_names, instance
+        leaf_column_names.map do |leaf, column_name|
+          current = instance
+          value = nil
+          leaf.path[1..-1].each do |component|
+            trace :population, "Traversing #{component.inspect}" do
+              case component
+              when MM::Absorption       # Fact
+                fact_type = component.parent_role.fact_type
+                trace :population, "Fact Type #{fact_type.default_reading}"
+
+                if MM::LinkFactType === fact_type
+                  # Populations do not contain LinkFactTypes for an Objectified Fact Type,
+                  # but Compositions use them. The child_role is probably a mirror role.
+                  role = fact_type.implying_role  # This is the real role
+                  fact_type = role.fact_type      # And this is the real fact
+                  raise "Internal error finding objectified fact" if instance.fact.fact_type != fact_type
+                  role_value = fact.all_role_value{|rv| rv.role == role}
+                else
+                  role_values = instance.all_role_value.select{|rv| rv.population == @population && rv.fact.fact_type == fact_type}
+                  raise "Population contains duplicate fact for #{fact_type.default_reading.inspect} in violation of uniqueness constraint" if role_values.size > 1
+                  if role_values.empty?
+                    trace :population, "No fact is present"
+                    break
+                  end
+                  residual_rvs = role_values[0].fact.all_role_value.to_a-[role_values[0]]
+                  raise "Instance of #{fact_type.default_reading.inspect} lacks some role players" unless residual_rvs.size == fact_type.all_role.size-1
+                  if residual_rvs.size != 1
+                    raise "Internal error in fact population, n-ary fact type #{fact_type.default_reading}"
+                  end
+                  role_value = residual_rvs[0]
+                end
+
+                current = role_value.instance
+                trace :population, "Instance is #{current.object_type.name}#{current.value ? ' = '+current.value.inspect : ''}"
+                value = current.value.inspect
+
+              when MM::Indicator
+                fact_type = component.role.fact_type
+                trace :population, "Fact Type #{fact_type.default_reading}"
+                role_values = instance.all_role_value.select{|rv| rv.population == @population && rv.fact.fact_type == fact_type}
+                raise "Population contains duplicate fact for #{fact_type.default_reading.inspect} in violation of uniqueness constraint" if role_values.size > 1
+                value = true
+
+              when MM::ValueField
+                # The value is the value of the Value Type
+                value = current.value.inspect
+
+              when MM::Discriminator
+                # The value depends on which of the discriminated roles are played (must be only one)
+                raise "Cannot emit population containing a Discriminator, not implemented"
+                drs = component.all_discriminated_role.select{|dr| instance.all_role_value.detect{|rv| rv.role == dr.role}}
+                raise "Discriminator has ambiguous value, with more than one candidate role" if drs.size > 1
+                value = drs[0].value.inspect if drs[0]
+
+              # The following types are not conceptual so will never have asserted facts
+              when MM::Injection,
+                   MM::Scoping,
+                   MM::SurrogateKey,
+                   MM::ValidFrom,
+                   MM::Mapping,
+                   MM::ComputedValue,
+                   MM::HashValue
+                break
+
+              else
+                raise "Unhandled Component type #{component.class.name} in composition"
+              end
+            end
+          end
+          value ? [column_name, value] : nil
+        end.compact
+      end
+
+      def trailer
+        ''
+      end
+
+      def stylise_column_name name
+        name.words.send(@column_case)*@column_joiner
+      end
+
+    end
+    publish_generator Population, "Generate SQL to insert or update records defined as a fact population"
+  end
+end

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

@@ -0,0 +1,81 @@
+#
+#       ActiveFacts Admin App Generator
+#
+# Copyright (c) 2018 Daniel Heath. Read the LICENSE file.
+#
+require 'digest/sha1'
+require 'activefacts/metamodel'
+require 'activefacts/compositions'
+require 'activefacts/generator'
+require 'activefacts/compositions/traits/rails'
+require 'activefacts/generator/rails/ruby_folder_generator'
+
+module ActiveFacts
+  module Generators
+    module Rails
+      class ActiveAdmin
+        include RubyFolderGenerator
+        def self.options
+          ({
+            keep:          ['Boolean', "Keep stale files"],
+            output:        [String,    "Write admin config files into this output directory"],
+          })
+        end
+
+        def self.compatibility
+          # REVISIT: We depend on the surrogate option being enabled if any PK is not Rails-friendly
+          [1, %i{relational}]   # one relational composition
+        end
+
+        def initialize constellation, composition, options = {}
+          @constellation = constellation
+          @composition = composition
+          @options = options
+          @option_keep = options.delete("keep")
+          @option_output = options.delete("output")
+          @option_output ||= 'app/admin'
+          @option_output = nil if @option_output == "-"
+        end
+
+        def generate_files
+          admins =
+            @composition.
+            all_composite.
+            sort_by {|composite| composite.mapping.name}.
+            reject {|composite| composite.mapping.object_type.is_static}.
+            map {|composite| generate_admin composite}.
+            compact * "\n"
+        end
+
+        def extant_files
+          Dir[@option_output+'/*.rb']
+        end
+
+        def generate_admin composite
+          columns = composite.mapping.all_leaf.flat_map do |component|
+            # Absorbed empty subtypes appear as leaves
+            next [] if component.is_a?(MM::Absorption) && component.parent_role.fact_type.is_a?(MM::TypeInheritance)
+            ':' + component.column_name.snakecase
+          end
+
+          model = "ActiveAdmin.register #{composite.rails.class_name} do\n  permit_params #{columns.join(', ')}\nend\n"
+
+          return model unless @option_output
+
+          filename = composite.rails.singular_name+'_admin.rb'
+          out = create_if_ok(@option_output, filename)
+          return nil unless out
+          out.puts "#{HEADER}\n" +
+            "\# #{([File.basename($0)]+ARGV)*' '}\n\n" +
+            model
+        ensure
+          out.close if out
+          nil
+        end
+
+        MM = ActiveFacts::Metamodel unless const_defined?(:MM)
+      end
+    end
+    publish_generator Rails::ActiveAdmin, "Generate models in Ruby for use with ActiveAdmin and Rails. Use a relational compositor"
+  end
+end

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

@@ -0,0 +1,78 @@
+#
+#       ActiveFacts Rails Models Generator
+#
+# Copyright (c) 2009-2016 Daniel Heath. Read the LICENSE file.
+#
+require 'digest/sha1'
+require 'activefacts/metamodel'
+require 'activefacts/compositions'
+require 'activefacts/generator'
+require 'activefacts/compositions/traits/rails'
+require 'activefacts/generator/rails/ruby_folder_generator'
+
+module ActiveFacts
+  module Generators
+    module Rails
+      class ApplicationRecordShell
+        include RubyFolderGenerator
+        def self.options
+          ({
+            keep:          ['Boolean', "Keep stale model files"],
+            validation:    ['Boolean', "Disable generation of validations"],
+            concern:       [String,    "Namespace for the concerns"],
+            output:        [String,    "Generate models in given directory (as well as concerns)"],
+          })
+        end
+
+        def self.compatibility
+          # REVISIT: We depend on the surrogate option being enabled if any PK is not Rails-friendly
+          [1, %i{relational}]   # one relational composition
+        end
+
+        def initialize constellation, composition, options = {}
+          @constellation = constellation
+          @composition = composition
+          @options = options
+          @option_keep = options.delete("keep")
+          @option_concern = options.delete("concern")
+
+          @option_output = options.delete("output")
+          if !@option_output
+            @option_output = "app/models"
+          end
+          @option_output = nil if @option_output == "-" # dash for stdout
+        end
+
+        def generate_files
+          @composition.
+          all_composite.
+          sort_by{|composite| composite.mapping.name}.
+          map{|composite| generate_model composite}.
+          compact*"\n"
+        end
+
+        def extant_files
+          Dir[@option_output+'/*.rb'] if @option_output
+        end
+
+        def generate_model composite
+          concern_module = @option_concern ? "#{@option_concern}::" : ""
+          model = "class #{composite.rails.class_name} < ApplicationRecord\n  include #{concern_module}#{composite.rails.class_name}\nend\n"
+
+          return model unless @option_output
+
+          filename = composite.rails.singular_name+'.rb'
+          out = create_if_ok(@option_output, filename)
+          return nil unless out
+          out.puts "#{HEADER}\n" +
+            "\# #{([File.basename($0)]+ARGV)*' '}\n\n" +
+            model
+        ensure
+          out.close if out
+          nil
+        end
+      end
+    end
+    publish_generator Rails::ApplicationRecordShell, "Generate ApplicationRecord shell in Ruby for use with ActiveRecord and Rails. Use a relational compositor"
+  end
+end

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

@@ -8,96 +8,53 @@ require 'activefacts/metamodel'
 require 'activefacts/compositions'
 require 'activefacts/generator'
 require 'activefacts/compositions/traits/rails'
+require 'activefacts/generator/rails/ruby_folder_generator'
 
 module ActiveFacts
   module Generators
     module Rails
       class Models
-        HEADER = "# Auto-generated from CQL, edits will be lost"
+        include RubyFolderGenerator
         def self.options
           ({
-            keep:       ['Boolean', "Keep stale model files"],
-            output:     [String,    "Overwrite model files into this output directory"],
-            concern:    [String,    "Namespace for the concerns"],
-            validation: ['Boolean', "Disable generation of validations"],
+            keep:          ['Boolean', "Keep stale model files"],
+            output:        [String,    "Overwrite model files into this output directory"],
+            concern:       [String,    "Namespace for the concerns"],
+            validation:    ['Boolean', "Disable generation of validations"],
           })
         end
 
-        def initialize composition, options = {}
+        def self.compatibility
+          # REVISIT: We depend on the surrogate option being enabled if any PK is not Rails-friendly
+          [1, %i{relational}]   # one relational composition
+        end
+
+        def initialize constellation, composition, options = {}
+          @constellation = constellation
           @composition = composition
           @options = options
           @option_keep = options.delete("keep")
-          @option_output = options.delete("output")
           @option_concern = options.delete("concern")
-          @option_validations = options.include?('validations') ? options.delete("validations") : true
-        end
-
-        def warn *a
-          $stderr.puts *a
-        end
-
-        def generate
-          list_extant_files if @option_output && !@option_keep
-
-          @ok = true
-          models =
-            @composition.
-            all_composite.
-            sort_by{|composite| composite.mapping.name}.
-            map{|composite| generate_composite composite}.
-            compact*"\n"
-
-          warn "\# #{@composition.name} generated with errors" unless @ok
-          delete_old_generated_files if @option_output && !@option_keep
-
-          models
-        end
 
-        def list_extant_files
-          @preexisting_files = Dir[@option_output+'/*.rb']
-        end
-
-        def delete_old_generated_files
-          remaining = []
-          cleaned = 0
-          @preexisting_files.each do |pathname|
-            if generated_file_exists(pathname) == true
-              File.unlink(pathname) 
-              cleaned += 1
-            else
-              remaining << pathname
-            end
+          @option_output = options.delete("output")
+          if !@option_output && @option_concern
+            @option_output = "app/models/#{ACTR::singular_name @option_concern}"
           end
-          $stderr.puts "Cleaned up #{cleaned} old generated files" if @preexisting_files.size > 0
-          $stderr.puts "Remaining non-generated files:\n\t#{remaining*"\n\t"}" if remaining.size > 0
+          @option_output = nil if @option_output == "-" # dash for stdout
+
+          @option_validations = options.include?('validations') ? options.delete("validations") : true
         end
 
-        def generated_file_exists pathname
-          File.open(pathname, 'r') do |existing|
-            first_lines = existing.read(1024)     # Make it possible to pass over a magic charset comment
-            if first_lines.length == 0 or first_lines =~ %r{^#{HEADER}}
-              return true
-            end
-          end
-          return false    # File exists, but is not generated
-        rescue Errno::ENOENT
-          return nil      # File does not exist
+        def generate_files
+          @composition.
+          all_composite.
+          sort_by{|composite| composite.mapping.name}.
+          map{|composite| generate_composite composite}.
+          compact*"\n"
         end
 
-        def create_if_ok filename
-          # Create a file in the output directory, being careful not to overwrite carelessly
-          out = $stdout
-          if @option_output
-            pathname = (@option_output+'/'+filename).gsub(%r{//+}, '/')
-            @preexisting_files.reject!{|f| f == pathname }    # Don't clean up this file
-            if generated_file_exists(pathname) == false
-              warn "not overwriting non-generated file #{pathname}"
-              @ok = false
-              return nil
-            end
-            out = File.open(pathname, 'w')
-          end
-          out
+        def extant_files
+          Dir[@option_output+'/*.rb'] if @option_output
         end
 
         def generate_composite composite
@@ -109,9 +66,11 @@ module ActiveFacts
           return model unless @option_output
 
           filename = composite.rails.singular_name+'.rb'
-          out = create_if_ok(filename)
+          out = create_if_ok(@option_output, filename)
           return nil unless out
-          out.puts "#{HEADER}\n\n"+model
+          out.puts "#{HEADER}\n" +
+            "\# #{([File.basename($0)]+ARGV)*' '}\n\n" +
+            model
         ensure
           out.close if out
           nil