k_domain 0.0.16 → 0.0.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98e1d3eb1435f17ad91084519399234f0adc41e399d1350071147f0e58f694c6
-  data.tar.gz: 2797a698e87169816a6b612239b1c22b8d2fd0db2fd6df2fc8e078fbf8828e69
+  metadata.gz: 86f877b2fd5644c7ebd211c662cb4cd1ff63213dcc3cc588d3485f698a2bc7b9
+  data.tar.gz: 9999ee5fa153fa7c1833cd21a0a5a145cbee4a97cd11284c1bb4440157ae6d0a
 SHA512:
-  metadata.gz: 1e6cd0d3fa8354f83b5910dc961212acd0ae149b0b90c31338bf992b4f64500ae4fb05f63c605bf439d818bed8f6f4806939994c0cf8ee6fbd0c0a51d232b02f
-  data.tar.gz: 28d42c273b6fdae5db9b32e4cfcd4c1826e42f929efbc9713941b16bc4240cff22eed7e3260aec195beff43ae3ec20bf136bb6526988eccbd5f475c18ec2566a
+  metadata.gz: 013e1f7524e395b9766831786cd1f4052eb6000fd35105c58bfb51869f9d1b93151f3fbc3e8fe349f59dd6819daf7d27e22a05ae5f95fba6826bf61af06eb235
+  data.tar.gz: c56d291ba618e70863e334bca9c1e817da700d6d0769e92ac5fb7d267b1f02068f6d4275e423264147066389d45dca831d3b3878eef45662d0f4ef8457d99e20

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/.gitignore

@@ -23,6 +23,7 @@ k_domain.yml
 /doc/
 /pkg/
 /spec/reports/
+/spec/example_domain/advanced/
 /tmp/
 !/tmp/.keep
 *.bundle

data/.rubocop.yml

@@ -6,8 +6,7 @@ AllCops:
   NewCops: enable
   Exclude:
     - "_/**/*"
-    - "spec/sample_input/**/*"
-    - "spec/sample_output/**/*"
+    - "spec/example_domain/**/*"
     - "templates/**/*"
     - "lib/k_domain/schemas/domain/old/**/*"
     - "spec/k_domain/ruby_loader/**/*"

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/STORIES.md

@@ -16,25 +16,54 @@ As a Developer, I can customize domain configuration, so that I can have opinion
 
 - Handle traits
 
+### Tasks next on list
+
+BUGs in domain_model load
+
+- spec/k_domain/domain_model/load_spec.rb:135
+- FIXED: module_name should be empty
+- FIXED: name mismatch (attr_accessor, attr_reader, attr_writer) in behaviours vs in (attr_accessors, attr_readers, attr_writers) functions
+- functions - (attr_accessors, attr_readers, attr_writers) are all empty
+
+External ruby process - ShimLoading and ExtractModel
+
+- You need a clear memory foot print for shim loading and model extraction, best to run these from inside a new ruby process
+
+Log Warning to Investigate Issues
+
+- FIXED: All the logged warnings in k_domain need to turn up in on the investigate issues register
+- Investigate needs a debug flag that when turned on, will write the issues to the console
+
+Print progress dot
+
+- Make this configurable
+- Decide what steps this should run for
+- Show step label via configuration
+
+## Stories and tasks
+
+### Stories - completed
+
 As a Developer, I can read native rails model data, so that I can leverage existing rails applications for ERD modeling
 
+- Proof of concept
 - Use Meta Programming and re-implement ActiveRecord::Base
 
-### Tasks next on list
+### Tasks - completed
 
 Refactor / Simply
 
-- Replace complex objects an with structs for ancillary data structures such as investigate
+- Replace complex objects with structs for ancillary data structures such as investigate
+
+Steps to support write methods on base class
+
+- Simplify lib/k_domain/domain_model/transform.rb
 
 User acceptance testing
 
 - Provide sample printers for each data structure to visually check data is loading
 - Point raw_db_schema loader towards a complex ERD and check how it performs
 
-## Stories and tasks
-
-### Tasks - completed
-
 Setup RubyGems and RubyDoc
 
 - Build and deploy gem to [rubygems.org](https://rubygems.org/gems/k_domain)

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/load.rb

@@ -23,6 +23,8 @@ module KDomain
         @raw_data = KUtil.data.json_parse(json, as: :hash_symbolized)
 
         @data = KDomain::Schemas::DomainModel.new(@raw_data)
+
+        enrichment
       end
 
       def to_h
@@ -30,6 +32,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,25 +11,34 @@ 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 :shim_loader
 
-      def initialize(db_schema: , target_file: , target_step_file: , erd_path:)
+      # 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
-        @erd_path         = erd_path
+        @model_path       = model_path
+        @controller_path  = controller_path
+        @route_path       = route_path
+        @shim_loader      = shim_loader
       end
+      # rubocop:enable Metrics/ParameterLists
 
       # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
       def call
         valid = true
-        valid &&= step1
-        valid &&= step2
-        valid &&= step3
-        valid &&= step4
-        valid &&= step5
-        valid &&= step8
-        valid &&= step9
+        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: shim_loader)
+        valid &&= Step7RailsStructureControllers.run(domain_data, controller_path: controller_path, step_file: step_file('07-rails-structure-controllers'), shim_loader: 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,49 +48,13 @@ module KDomain
       end
       # rubocop:enable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
-      def step1
-        Step1AttachDbSchema.run(domain_data, db_schema: db_schema)
-        write(step: '1-attach-db-schema')
+      def step_file(step_name)
+        format(target_step_file, step: step_name)
       end
 
-      def step2
-        Step2AttachModels.run(domain_data, erd_path: erd_path)
-        write(step: '2-attach-model')
-      end
-
-      def step3
-        Step3AttachColumns.run(domain_data)
-        write(step: '3-attach-columns')
-      end
-
-      def step4
-        Step4AttachErdFiles.run(domain_data, erd_path: erd_path)
-        write(step: '4-attach-erd-files')
-      end
-
-      def step5
-        Step5AttachDictionary.run(domain_data, erd_path: erd_path)
-        write(step: '5-attach-dictionary')
-      end
-
-      def step8
-        Step8RailsResourceModels.run(domain_data, erd_path: erd_path)
-        write(step: '8-rails-resource-models')
-      end
-
-      def step9
-        Step9RailsStructureModels.run(domain_data, erd_path: erd_path)
-        write(step: '8-rails-structure-models')
-      end
-
-      def write(step: nil)
-        file = if step.nil?
-                 target_file
-               else
-                 format(target_step_file, step: step)
-               end
-        FileUtils.mkdir_p(File.dirname(file))
-        File.write(file, JSON.pretty_generate(domain_data))
+      def write
+        FileUtils.mkdir_p(File.dirname(target_file))
+        File.write(target_file, JSON.pretty_generate(domain_data))
       end
 
       # rubocop:disable Metrics/MethodLength
@@ -89,12 +62,11 @@ module KDomain
         # The initial domain model structure is created here, but populated during the workflows.
         @domain_data ||= {
           domain: {
-            models: [],
-            erd_files: []
+            models: []
           },
           rails_resource: {
             models: [],
-            controllers: []
+            routes: []
           },
           rails_structure: {
             models: [],
@@ -107,6 +79,7 @@ module KDomain
             tables: [],
             indexes: [],
             foreign_keys: [],
+            views: [],
             meta: {}
           },
           investigate: {
@@ -114,7 +87,6 @@ module KDomain
           }
         }
       end
-
       # rubocop:enable Metrics/MethodLength
     end
   end

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

@@ -2,10 +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 './step4_attach_erd_files'
-require_relative './step5_attach_dictionary'
-require_relative './step8_rails_resource_models'
-require_relative './step9_rails_structure_models'
+require_relative './step1_db_schema'
+require_relative './step2_domain_models'
+require_relative './step4_rails_resource_models'
+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

@@ -24,7 +24,8 @@ module KDomain
       def self.run(domain_data, **opts)
         step = new(domain_data, **opts)
         step.call
-        step
+        step.write(opts[:step_file])
+        step.valid?
       end
 
       def guard(message)
@@ -32,6 +33,15 @@ 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))
+      end
+
       # Domain Model Accessor/Helpers
       def domain
         guard('domain is missing') if domain_data[:domain].nil?
@@ -58,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
@@ -73,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
@@ -81,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/{step5_attach_dictionary.rb → step20_dictionary.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-# Attach data dictionary
-class Step5AttachDictionary < KDomain::DomainModel::Step
+#  data dictionary
+class Step20Dictionary < KDomain::DomainModel::Step
   attr_reader :dictionary
 
   def call
@@ -27,8 +27,11 @@ class Step5AttachDictionary < KDomain::DomainModel::Step
       entry[:model_count] = entry[:model_count] + 1
 
       unless entry[:types].include?(column_type)
-        # ADD to investigate
-        # log.warn("#{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
       end