k_domain 0.0.20 → 0.0.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de5fc8f220781026dd327f40da53eb3a424ec23f38785be8fddc8f1856970dc1
-  data.tar.gz: 5573e60dc8665ab146e0edeb291ebcd3db6b792180e05e24721df9d519038f86
+  metadata.gz: 56185cb3b21dcdc594e86e2f90a5700705e308210cf531371d717798ee7762c4
+  data.tar.gz: ec39dc47a6b40b875134431205d7d8da54e83aa7a1818c352dcde485e5f31682
 SHA512:
-  metadata.gz: 4ecaa0fef7e6d622f18d2dfe53bdddf2c17fa91e1c2796ee7bdddf5044880f742003d8cb6f7bb4007eeab4bd2f0becba6f8f0fb329f58776f807cd200bd4ced9
-  data.tar.gz: 76af19179f670d7e4b18121f031b77e18c366259526530b6623f988c5b3e2985ca3a993441e6caacfb7cb71da6afb05c99803234aa85045facdb2c8f09b1194b
+  metadata.gz: 639891b42099979c7955fa0586bc8e408900c97a3b0f4197704dd0f4e05765679b80ba83926c9b3c4307e8154f830ef90a4793097901007b11710f93010e1c04
+  data.tar.gz: 37c2f1076fddfd3c01da39dada2c579f62cda2af50aa1ba0105184c93c9f1442e4ec66d86e154b02d997310ec09d182991e9a054e5e340759bb11eead4d296bb

data/.builders/boot.rb

@@ -0,0 +1,40 @@
+# Boot Sequence
+
+include KLog::Logging
+
+CONFIG_KEY = :k_domain
+
+log.kv 'working folder', Dir.pwd
+
+Handlebars::Helpers.configure do |config|
+  config_file = File.join(Gem.loaded_specs['handlebars-helpers'].full_gem_path, '.handlebars_helpers.json')
+  config.helper_config_file = config_file
+
+  string_config_file = File.join(Gem.loaded_specs['handlebars-helpers'].full_gem_path, '.handlebars_string_formatters.json')
+  config.string_formatter_config_file = string_config_file
+end
+
+def builder
+  @builder ||= KBuilder::BaseBuilder.init(KConfig.configuration(CONFIG_KEY))
+end
+
+KConfig.configure(CONFIG_KEY) do |config|
+  global_template = File.expand_path('~/dev/kgems/k_templates/templates')
+  config.target_folders.add(:app, File.expand_path('../', Dir.pwd))
+  config.target_folders.add(:lib_config, :app, 'lib/k_domain/config')
+  config.template_folders.add(:global_template, global_template)
+  config.template_folders.add(:app_template, File.expand_path('.templates', Dir.pwd))
+end
+
+KConfig.configuration(CONFIG_KEY).debug
+
+area = KManager.add_area(CONFIG_KEY)
+resource_manager = area.resource_manager
+resource_manager.add_resource('https://raw.githubusercontent.com/klueless-io/k_playground/main/ruby/components/configuration/.builders/configuration_director.rb', content_type: :ruby)
+resource_manager
+  .fileset
+  .glob('*.rb', exclude: ['boot.rb'])
+  .glob('generators/**/*.rb')
+resource_manager.add_resources
+
+KManager.boot

data/.builders/generators/configuration_generator.rb

@@ -0,0 +1,22 @@
+KManager.action do
+  def on_action
+    puts '-' * 70
+    builder.cd(:lib_config)
+    director = ConfigurationDirector
+      .init(builder, on_exist: :compare)
+      .style(:single)
+      .name('Domain Configuration')
+      .main_namespace('KDomain', 'Config')
+      .add_config_key(:default_main_key, "nil")
+      .add_config_key(:default_traits, "%i[trait1 trait2 trait3]")
+      .add_config_key(:fallback_keys, "%i[]")
+      .add_config_key(:entities, "[]")
+      # .logit
+
+    # dom = director.dom
+    # data = director.data
+
+    director.add_config
+    # director.add_configuration
+  end
+end

data/.builders/run.rb

@@ -0,0 +1,16 @@
+# Run
+
+KManager.action do
+  def on_action
+  end
+end
+
+KManager.opts.app_name                    = 'KDomain Generator'
+KManager.opts.sleep                       = 5
+KManager.opts.reboot_on_kill              = 0
+KManager.opts.reboot_sleep                = 4
+KManager.opts.exception_style             = :short
+KManager.opts.show.time_taken             = true
+KManager.opts.show.finished               = true
+KManager.opts.show.finished_message       = 'FINISHED :)'
+

data/.github/workflows/main.yml

@@ -25,7 +25,9 @@ jobs:
       run: |
         gem install bundler -v 2.2.5
         bundle install
-    - name: Run tests
-      run: bundle exec rspec
     - name: Run rubocop
-      run: bundle exec rubocop
+      run: |
+        bundle exec rubocop -v
+        bundle exec rubocop
+    - name: Run tests
+      run: bundle exec rspec --tag ~skip_on_gha

data/.gitignore

@@ -23,6 +23,7 @@ k_domain.yml
 /doc/
 /pkg/
 /spec/reports/
+/spec/example_domain/advanced/
 /tmp/
 !/tmp/.keep
 *.bundle
@@ -30,6 +31,7 @@ k_domain.yml
 *.o
 *.a
 mkmf.log
+.vscode
 
 # Ruby Version
 .ruby-version

data/.rubocop.yml

@@ -1,16 +1,16 @@
 # require: rubocop-rake
 AllCops:
-  TargetRubyVersion: 2.5
+  TargetRubyVersion: 2.7
   DisplayCopNames: true
   ExtraDetails: true
   NewCops: enable
   Exclude:
     - "_/**/*"
-    - "spec/sample_input/**/*"
-    - "spec/sample_output/**/*"
+    - "spec/example_domain/**/*"
     - "templates/**/*"
     - "lib/k_domain/schemas/domain/old/**/*"
     - "spec/k_domain/ruby_loader/**/*"
+    - "hooks/**/*"
 
 Metrics/PerceivedComplexity:
   Exclude:
@@ -69,8 +69,6 @@ Metrics/MethodLength:
 
 Layout/LineLength:
   Max: 200
-  # Ignores annotate output
-  IgnoredPatterns: ['\A# \*\*']
   IgnoreCopDirectives: true
   Exclude:
     - "lib/k_domain/domain_model/transform_steps/*.rb"
@@ -117,6 +115,12 @@ Style/FormatStringToken:
 Style/Documentation:
   Enabled: false
 
+Style/OpenStructUse:
+  Enabled: false
+
 Layout/SpaceBeforeComma:
   Enabled: false
+
+Gemspec/RequireMFA:
+  Enabled: false
 # My Preferences - End

data/Gemfile

@@ -25,7 +25,7 @@ group :development, :test do
 end
 
 # If local dependency
-if ENV['KLUE_LOCAL_GEMS']&.to_s&.downcase == 'true'
+if ENV.fetch('KLUE_LOCAL_GEMS', 'false').downcase == 'true'
   group :development, :test do
     puts 'Using Local GEMs'
     gem 'k_log'                   , path: '../k_log'

data/Guardfile

@@ -19,6 +19,7 @@ group :green_pass_then_cop, halt_on_fail: true do
     # Ruby files
     ruby = dsl.ruby
     dsl.watch_spec_files_for(ruby.lib_files)
+    watch(%r{^lib/k_domain/domain_model/transform_steps/(.+).rb}) { 'spec/k_domain/domain_model/transform_spec.rb' }
     watch(%r{^lib/k_domain/**/(.+)\.rb$}) { |m| "spec/unit/#{m[1]}_spec.rb" }
     watch(%r{^lib/k_domain/commands/(.+)\.rb$}) { |m| "spec/unit/commands/#{m[1]}_spec.rb" }
   end

data/README.md

@@ -1,3 +1,18 @@
+# JSON Schema
+
+The following schemas were created using the following processes.
+
+```
+quicktype -o json-schema/database.json -t database -l schema spec/sample_output/printspeak/schema.json
+quicktype -o json-schema/database.rb   -t database -l ruby   json-schema/database-altered.json
+spec/sample_output/printspeak/schema.json
+json-schema/database-altered.json
+```
+
+remove statistics
+remove (or move rails structure)
+drop erd_location
+
 # K Domain
 
 > K Domain builds complex domain schemas by combining the database schema with a rich entity relationship DSLs

data/k_domain.gemspec

@@ -3,7 +3,7 @@
 require_relative 'lib/k_domain/version'
 
 Gem::Specification.new do |spec|
-  spec.required_ruby_version  = '>= 2.5'
+  spec.required_ruby_version  = '>= 2.7'
   spec.name                   = 'k_domain'
   spec.version                = KDomain::VERSION
   spec.authors                = ['David Cruwys']

data/lib/k_domain/config/_.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative './config'
+require_relative './configuration'

data/lib/k_domain/config/config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Usage: include KDomain::Config::
+
+module KDomain
+  module Config
+    def configuration
+      @configuration ||= KDomain::Config::Configuration.new
+    end
+
+    def reset
+      @configuration = KDomain::Config::Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+end

data/lib/k_domain/config/configuration.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module KDomain
+  module Config
+    # Configuration object for Domain Configuration
+    class Configuration
+      include KLog::Logging
+
+      ConfigModel = Struct.new(:name, :main_key, :traits)
+
+      attr_accessor :default_main_key
+      attr_accessor :default_traits
+      attr_accessor :fallback_keys
+      attr_accessor :models
+
+      def initialize
+        @default_main_key = nil
+        @default_traits = %i[trait1 trait2 trait3]
+        @fallback_keys = %i[]
+        @models = []
+      end
+
+      def model(name, main_key: nil, traits: nil)
+        @models << new_config_model(
+          name,
+          main_key: main_key || default_main_key,
+          traits: traits || default_traits
+        )
+      end
+
+      def find_model(table_name)
+        @find_model ||= Hash.new do |h, key|
+          h[key] = begin
+            entity = models.find { |e| e.name == key }
+            entity ||= new_config_model(key)
+            entity
+          end
+        end
+
+        @find_model[table_name]
+      end
+
+      def fallback_key(columns)
+        column_names = columns.each_with_object({}) do |column, hash|
+          hash[column.name.to_sym] = column.name.to_sym
+        end
+
+        fallback_keys.find { |key| column_names.key?(key) }
+      end
+
+      def debug(heading: 'Domain configuration')
+        log.structure(to_h, title: heading) # , line_width: 150, formatter: formatter)
+        ''
+      end
+
+      def to_h
+        {
+          default_main_key: default_main_key,
+          default_traits: default_traits,
+          fallback_keys: fallback_keys,
+          models: models.map(&:to_h)
+        }
+      end
+
+      private
+
+      def new_config_model(name, main_key: nil, traits: nil)
+        ConfigModel.new(
+          name,
+          main_key || default_main_key,
+          traits || default_traits
+        )
+      end
+    end
+  end
+end

data/lib/k_domain/domain_model/build_rich_models.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# Loads the db schema object and works through a series of enrichment steps to
+# that builds the domain modal
+
+module KDomain
+  module DomainModel
+    class BuildRichModels
+      include KLog::Logging
+
+      attr_reader :db_schema
+      attr_reader :target_step_file
+      attr_reader :query
+
+      def initialize(domain_model: , target_folder:)
+        @domain_model   = domain_model
+        @target_folder  = target_folder
+        @query          = KDomain::Queries::DomainModelQuery.new(domain_model)
+      end
+
+      def call
+        FileUtils.mkdir_p(target_folder)
+
+        export_domain_models(query.all.take(3))
+      end
+
+      def export_domain_models(models)
+        models.each do |model|
+          json = JSON.pretty_generate(build_rich_model(model))
+          target_file = File.join(target_folder, model.name + '.json')
+          File.write(target_file, json)
+        end
+      end
+    
+      def build_rich_model(model)
+        {
+          name: model.name,
+          name_plural: model.name_plural,
+          table_name: model.table_name,
+          type: model.type,
+          pk: model.pk.to_h,
+          file: model.file,
+          exist: model.ruby?,
+          main_key: model.main_key,
+          traits: model.traits,
+          columns: {
+            all: model.columns.map(&:to_h),
+            data: model.columns_data.map(&:to_h),
+            primary: model.columns_primary.map(&:to_h),
+            foreign_key: model.columns_foreign_key.map(&:to_h),
+            foreign_type: model.columns_foreign_type.map(&:to_h),
+            timestamp: model.columns_timestamp.map(&:to_h),
+            deleted_at: model.columns_deleted_at.map(&:to_h),
+            virtual: model.columns_virtual.map(&:to_h),
+            data_foreign: model.columns_data_foreign.map(&:to_h),
+            data_primary: model.columns_data_primary.map(&:to_h),
+            data_virtual: model.columns_data_virtual.map(&:to_h),
+            data_foreign_virtual: model.columns_data_foreign_virtual.map(&:to_h)
+          }
+        }
+      end
+    end
+  end
+end

data/lib/k_domain/domain_model/load.rb

@@ -22,7 +22,11 @@ module KDomain
         json = File.read(source_file)
         @raw_data = KUtil.data.json_parse(json, as: :hash_symbolized)
 
-        @data = KDomain::Schemas::DomainModel.new(@raw_data)
+        # This line is slow on big datasets
+        @data = KDomain::Schemas::MainDataset.new(@raw_data)
+
+        # This line is also slow on big datasets
+        enrichment
       end
 
       def to_h
@@ -30,6 +34,45 @@ module KDomain
 
         @raw_data
       end
+
+      private
+
+      def enrichment
+        attach_rails_model_to_domain_model
+      end
+
+      def attach_rails_model_to_domain_model
+        @data.domain.models.each do |domain_model|
+          domain_model.rails_model = @data.rails_structure.find_model(domain_model.name)
+
+          if domain_model.rails_model
+            attach_column_relations(domain_model)
+          else
+            log.error("Rails Model not found for #{domain_model.name}") unless domain_model.rails_model
+          end
+        end
+      end
+
+      def attach_column_relations(domain_model)
+        domain_model.columns.each do |column|
+          column.relationships = []
+          add_column_relations(domain_model.rails_model, column, :belongs_to)
+          add_column_relations(domain_model.rails_model, column, :has_one)
+          add_column_relations(domain_model.rails_model, column, :has_many)
+          add_column_relations(domain_model.rails_model, column, :has_and_belongs_to_many)
+        end
+      end
+
+      def add_column_relations(rails_model, column, relation_type)
+        relations = rails_model.behaviours.send(relation_type)
+
+        return if relations.nil?
+
+        relations = relations.map { |relation| { relation_type: relation_type }.merge(relation.to_h) }
+        relations.select { |relation| column[:name] == relation.dig(:opts, :foreign_key) }.each do |relation|
+          column.relationships << KDomain::Schemas::Domain::Model::Relationship.new(relation)
+        end
+      end
     end
   end
 end

data/lib/k_domain/domain_model/transform.rb

@@ -11,24 +11,36 @@ module KDomain
       attr_reader :db_schema
       attr_reader :target_step_file
       attr_reader :target_file
-      attr_reader :erd_path
+      attr_reader :model_path
+      attr_reader :controller_path
+      attr_reader :route_path
+      attr_reader :model_shim_loader
+      attr_reader :controller_shim_loader
 
-      def initialize(db_schema: , target_file: , target_step_file: , erd_path:)
-        @db_schema        = db_schema
-        @target_step_file = target_step_file
-        @target_file      = target_file
-        @erd_path         = erd_path
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(db_schema: , target_file: , target_step_file: , model_path:, route_path:, controller_path:, model_shim_loader: nil, controller_shim_loader: nil)
+        @db_schema              = db_schema
+        @target_step_file       = target_step_file
+        @target_file            = target_file
+        @model_path             = model_path
+        @controller_path        = controller_path
+        @route_path             = route_path
+        @model_shim_loader      = model_shim_loader
+        @controller_shim_loader = controller_shim_loader
       end
+      # rubocop:enable Metrics/ParameterLists
 
       # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
       def call
         valid = true
-        valid &&= Step1AttachDbSchema.run(domain_data, db_schema: db_schema, step_file: step_file('1-attach-db-schema'))
-        valid &&= Step2AttachModels.run(domain_data, erd_path: erd_path, step_file: step_file('2-attach-model'))
-        valid &&= Step3AttachColumns.run(domain_data, step_file: step_file('3-attach-columns'))
-        valid &&= Step4RailsResourceModels.run(domain_data, erd_path: erd_path, step_file: step_file('4-rails-resource-models'))
-        valid &&= Step5RailsModels.run(domain_data, erd_path: erd_path, step_file: step_file('5-rails-models'))
-        valid &&= Step6AttachDictionary.run(domain_data, erd_path: erd_path, step_file: step_file('6-attach-dictionary'))
+        valid &&= Step1DbSchema.run(domain_data, db_schema: db_schema, step_file: step_file('01-db-schema'))
+        valid &&= Step2DomainModels.run(domain_data, model_path: model_path, step_file: step_file('02-domain-model'))
+        valid &&= Step4RailsResourceModels.run(domain_data, model_path: model_path, step_file: step_file('04-rails-resource-models'))
+        valid &&= Step5RailsResourceRoutes.run(domain_data, route_path: route_path, controller_path: controller_path, step_file: step_file('05-rails-resource-routes'))
+        valid &&= Step6RailsStructureModels.run(domain_data, model_path: model_path, step_file: step_file('06-rails-structure-models'), shim_loader: model_shim_loader)
+        valid &&= Step7RailsStructureControllers.run(domain_data, controller_path: controller_path, step_file: step_file('07-rails-structure-controllers'), shim_loader: controller_shim_loader)
+        valid &&= Step8DomainColumns.run(domain_data, step_file: step_file('08-domain-columns'))
+        valid &&= Step20Dictionary.run(domain_data, step_file: step_file('20-dictionary'))
 
         raise 'DomainModal transform failed' unless valid
 
@@ -39,7 +51,7 @@ module KDomain
       # rubocop:enable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
       def step_file(step_name)
-        target_step_file % { step: step_name }
+        format(target_step_file, step: step_name)
       end
 
       def write
@@ -52,11 +64,11 @@ module KDomain
         # The initial domain model structure is created here, but populated during the workflows.
         @domain_data ||= {
           domain: {
-            models: [],
+            models: []
           },
           rails_resource: {
             models: [],
-            controllers: []
+            routes: []
           },
           rails_structure: {
             models: [],
@@ -69,6 +81,7 @@ module KDomain
             tables: [],
             indexes: [],
             foreign_keys: [],
+            views: [],
             meta: {}
           },
           investigate: {
@@ -76,7 +89,6 @@ module KDomain
           }
         }
       end
-
       # rubocop:enable Metrics/MethodLength
     end
   end

data/lib/k_domain/domain_model/transform_steps/_.rb

@@ -2,9 +2,11 @@
 
 # The require order is important due to dependencies
 require_relative './step'
-require_relative './step1_attach_db_schema'
-require_relative './step2_attach_models'
-require_relative './step3_attach_columns'
+require_relative './step1_db_schema'
+require_relative './step2_domain_models'
 require_relative './step4_rails_resource_models'
-require_relative './step5_rails_models'
-require_relative './step6_attach_dictionary'
+require_relative './step5_rails_resource_routes'
+require_relative './step6_rails_structure_models'
+require_relative './step7_rails_structure_controllers'
+require_relative './step8_domain_columns'
+require_relative './step20_dictionary'

data/lib/k_domain/domain_model/transform_steps/step.rb

@@ -33,6 +33,10 @@ module KDomain
         @valid = false
       end
 
+      def warning(message)
+        log.warn message
+      end
+
       def write(file)
         FileUtils.mkdir_p(File.dirname(file))
         File.write(file, JSON.pretty_generate(domain_data))
@@ -64,6 +68,14 @@ module KDomain
         rails_resource[:models] = value
       end
 
+      def rails_resource_routes
+        rails_resource[:routes]
+      end
+
+      def rails_resource_routes=(value)
+        rails_resource[:routes] = value
+      end
+
       def rails_resource_controllers
         rails_resource[:controllers]
       end
@@ -79,6 +91,10 @@ module KDomain
         rails_structure[:models]
       end
 
+      def find_rails_structure_models(model_name)
+        rails_structure_models.find { |model| model[:model_name] == model_name }
+      end
+
       def rails_structure_models=(value)
         rails_structure[:models] = value
       end
@@ -87,6 +103,10 @@ module KDomain
         rails_structure[:controllers]
       end
 
+      def rails_structure_controllers=(value)
+        rails_structure[:controllers] = value
+      end
+
       # Database Accessor/Helpers
       def database=(value)
         domain_data[:database] = value

data/lib/k_domain/domain_model/transform_steps/{step1_attach_db_schema.rb → step1_db_schema.rb}

@@ -2,12 +2,13 @@
 
 module KDomain
   module DomainModel
-    class Step1AttachDbSchema < KDomain::DomainModel::Step
+    class Step1DbSchema < KDomain::DomainModel::Step
       # Map database schema to domain model
       def call
         raise 'Schema not supplied' if opts[:db_schema].nil?
 
         self.database = opts[:db_schema].clone
+        database[:tables] = database[:tables] # .take(10) # .slice(156, 1)
 
         guard('tables are missing')               if database[:tables].nil?
         guard('indexes are missing')              if database[:indexes].nil?

data/lib/k_domain/domain_model/transform_steps/{step6_attach_dictionary.rb → step20_dictionary.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-# Attach data dictionary
-class Step6AttachDictionary < KDomain::DomainModel::Step
+#  data dictionary
+class Step20Dictionary < KDomain::DomainModel::Step
   attr_reader :dictionary
 
   def call
@@ -27,10 +27,10 @@ class Step6AttachDictionary < KDomain::DomainModel::Step
       entry[:model_count] = entry[:model_count] + 1
 
       unless entry[:types].include?(column_type)
-        investigate(step: :step5_attach_dictionary,
-          location: :process,
-          key: "#{model_name},#{column_name},#{column_type}",
-          message: "#{model_name} has a type mismatch for column name: #{column_name}")
+        investigate(step: :step5_dictionary,
+                    location: :process,
+                    key: "#{model_name},#{column_name},#{column_type}",
+                    message: "#{model_name} has a type mismatch for column name: #{column_name}")
 
         entry[:types] << column_type
         entry[:type_count] = entry[:type_count] + 1