k_domain 0.0.23 → 0.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cbbddfe9857696b7a3a02fc370c51205d584fd08aaad5f8b8605dccebab02bc1
-  data.tar.gz: c37fee293561e73b3ed4b4e31f9def8c13848217ee9c4d14efdcfc67a46d42ea
+  metadata.gz: 2206bc03f809354e7cacb541a081491e1ce06c8eb82eb655cd81fdc7d16a69e7
+  data.tar.gz: 9e5f99803fee97745f11e870b79039510e0b0c733d43191c1cf5557d8e138b65
 SHA512:
-  metadata.gz: 12d58c761198fe6fa8336871ab5a3475c0a1caf358c09af2005e8bab3192c82b864663b867b3f2a39d8ba7c20e58258a8981ddd6339dbdb4edec73e37bca4652
-  data.tar.gz: 0bfd25819a3425f2932ba751d9e4413b41ae2c617416751855ced16a7fc74f68eff64d87a92138c73b85b0df175f38b8b299f5912f67f8a78970926ff83a4df8
+  metadata.gz: 2576e2e9f17587883e1edea8b8b32cbab53530574657511870de4bb679cb0b32822970937efab04ee7ca15a689ec8b3ffaf7856872e96e9696a8775ce00aaf8d
+  data.tar.gz: ecd8d2f12229d9cf422515be37091ee8e13b893712f7ba15e236a515319b31b301fb468ab75e6034233cd028bb0cc0c98e0216d9c12bbae60b4a66f20584e8db

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

@@ -31,6 +31,7 @@ k_domain.yml
 *.o
 *.a
 mkmf.log
+.vscode
 
 # Ruby Version
 .ruby-version

data/.rubocop.yml

@@ -1,6 +1,6 @@
 # require: rubocop-rake
 AllCops:
-  TargetRubyVersion: 2.5
+  TargetRubyVersion: 2.7
   DisplayCopNames: true
   ExtraDetails: true
   NewCops: enable
@@ -10,6 +10,7 @@ AllCops:
     - "templates/**/*"
     - "lib/k_domain/schemas/domain/old/**/*"
     - "spec/k_domain/ruby_loader/**/*"
+    - "hooks/**/*"
 
 Metrics/PerceivedComplexity:
   Exclude:
@@ -68,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"
@@ -116,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

@@ -16,7 +16,7 @@ group :development, :test do
   gem 'guard-bundler'
   gem 'guard-rspec'
   gem 'guard-rubocop'
-  gem 'rake', '~> 12.0'
+  gem 'rake'
   gem 'rake-compiler', require: false
   gem 'rspec', '~> 3.0'
   gem 'rubocop'
@@ -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/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,83 @@
+# 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_folder
+      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)
+        puts 'export domain models'
+        models.each do |model|
+          # write a single dot to the console in the color red
+          print "\e[31m.\e[0m"
+
+          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?,
+          create_update_timestamp: model.create_update_timestamp?,
+          main_key: model.main_key,
+          traits: model.traits,
+          column_names: {
+            all: model.columns.map(&:name),
+            data: model.columns_data.map(&:name),
+            primary: model.columns_primary.map(&:name),
+            foreign_key: model.columns_foreign_key.map(&:name),
+            foreign_type: model.columns_foreign_type.map(&:name),
+            timestamp: model.columns_timestamp.map(&:name),
+            deleted_at: model.columns_deleted_at.map(&:name),
+            virtual: model.columns_virtual.map(&:name),
+            data_foreign: model.columns_data_foreign.map(&:name),
+            data_primary: model.columns_data_primary.map(&:name),
+            data_virtual: model.columns_data_virtual.map(&:name),
+            data_foreign_virtual: model.columns_data_foreign_virtual.map(&:name)
+          },
+          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

@@ -14,17 +14,19 @@ module KDomain
       attr_reader :model_path
       attr_reader :controller_path
       attr_reader :route_path
-      attr_reader :shim_loader
+      attr_reader :model_shim_loader
+      attr_reader :controller_shim_loader
 
       # rubocop:disable Metrics/ParameterLists
-      def initialize(db_schema: , target_file: , target_step_file: , model_path:, route_path:, controller_path:, 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
-        @shim_loader      = shim_loader
+      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
 
@@ -35,8 +37,8 @@ module KDomain
         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: shim_loader)
-        valid &&= Step7RailsStructureControllers.run(domain_data, controller_path: controller_path, step_file: step_file('07-rails-structure-controllers'), shim_loader: shim_loader)
+        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'))
 

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

@@ -8,7 +8,7 @@ module KDomain
         raise 'Schema not supplied' if opts[:db_schema].nil?
 
         self.database = opts[:db_schema].clone
-        database[:tables] = database[:tables] # .slice(156, 1)
+        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/step2_domain_models.rb

@@ -18,7 +18,7 @@ class Step2DomainModels < KDomain::DomainModel::Step
       name_plural: table_name, # need to check if this is correct as I know it is wrong for account_history_datum
       table_name: table_name,
       pk: primary_key(table),
-      file: nil
+      file: nil                # will be set in step8_domain_columns
     }
 
     attach_columns(model)

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

@@ -37,6 +37,7 @@ class Step6RailsStructureModels < KDomain::DomainModel::Step
 
   def attach_behavior_and_functions
     rails_structure_models.select { |model| model[:exist] }.each do |model|
+      # puts "model: #{model[:model_name]}"
       model[:behaviours] = extract_behavior(model[:file])
       klass_name = model[:behaviours][:class_name]
       model[:functions] = extract_functions(klass_name)

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

@@ -58,7 +58,10 @@ class Step7RailsStructureControllers < KDomain::DomainModel::Step
   end
 
   def attach_behavior_and_functions
+    rails_structure_controllers.sort_by! { |controller| controller[:full_file] }
+
     rails_structure_controllers.select { |controller| controller[:exist] }.each do |controller|
+      # puts "controller: #{controller[:full_file]}"
       unless File.exist?(controller[:full_file])
         log.error 'Controller apparently exists but no file found, this means that you need re-run rake routes'
         puts controller[:full_file]
@@ -66,7 +69,7 @@ class Step7RailsStructureControllers < KDomain::DomainModel::Step
       end
       controller[:behaviours] = extract_behavior(controller[:full_file])
       klass_name = controller[:behaviours][:class_name]
-      controller[:functions] = extract_functions(klass_name)
+      controller[:functions] = extract_functions(klass_name, controller[:full_file])
     end
   end
 
@@ -97,13 +100,15 @@ class Step7RailsStructureControllers < KDomain::DomainModel::Step
     shim_loader
   end
 
-  def extract_functions(klass_name)
+  def extract_functions(klass_name, controller_file)
     klass = Module.const_get(klass_name.classify)
 
     class_info = Peeky.api.build_class_info(klass.new)
 
     class_info.to_h
   rescue StandardError => e
-    log.exception(e)
+    log.kv 'controller_file', controller_file
+    log.exception(e, style: :short)
+    {}
   end
 end