k_domain 0.0.14 → 0.0.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c236bd2b714a21b40f5727765bc2b9c049f0c265e7c592e5864a6a6e34330b37
-  data.tar.gz: 8ecf79ec6e1805ad6660218ac6aa6931ef67a48b3ca56dd339c7a6a0f6c50886
+  metadata.gz: cbbddfe9857696b7a3a02fc370c51205d584fd08aaad5f8b8605dccebab02bc1
+  data.tar.gz: c37fee293561e73b3ed4b4e31f9def8c13848217ee9c4d14efdcfc67a46d42ea
 SHA512:
-  metadata.gz: 4b3a6c9c9af39c37fdeba462a209a0bd395a72c1887505c0852f1f37a58406c929cc080c63bb9ed5b4de937be51d722e0511a6194d7de389840cb5ca831e7135
-  data.tar.gz: f71d09378bf35ec9146692bd137b02176095ba934fbba711c6204896541af27365aeeeb67997d89d43cea7498f2d7361322cba566dd0c31ed1674fb190656968
+  metadata.gz: 12d58c761198fe6fa8336871ab5a3475c0a1caf358c09af2005e8bab3192c82b864663b867b3f2a39d8ba7c20e58258a8981ddd6339dbdb4edec73e37bca4652
+  data.tar.gz: 0bfd25819a3425f2932ba751d9e4413b41ae2c617416751855ced16a7fc74f68eff64d87a92138c73b85b0df175f38b8b299f5912f67f8a78970926ff83a4df8

data/.builders/config/_.rb

@@ -0,0 +1,3 @@
+puts '_'
+
+#require 'config/_initialize'

data/.builders/setup.rb

@@ -0,0 +1,30 @@
+require 'config/_'
+require_relative "../lib/k_domain"
+
+db_schema_ruby_file = '/Users/davidcruwys/dev/printspeak/printspeak-master/db/schema.rb'
+
+# /Users/davidcruwys/dev/printspeak/printspeak/.builders/config/raw/schema_printspeak.rb
+output_folder = File.expand_path('../.output')
+db_schema_json_file = File.join(output_folder, 'db_schema.json')
+schema_loader_file = File.join(output_folder, 'schema_printspeak.rb')
+
+transformer = KDomain::RawDbSchema::Transform.new(db_schema_ruby_file)
+transformer.template_file = '/Users/davidcruwys/dev/kgems/k_domain/templates/old_printspeek_schema.rb'
+puts db_schema_ruby_file
+puts transformer.template_file
+transformer.call
+transformer.write_json(db_schema_json_file)
+transformer.write_schema_loader(schema_loader_file)
+# transformer.schema
+
+
+# transform = KDomain::DomainModel::Transform.new(
+#   db_schema: db_schema,
+#   target_file: target_file,
+#   target_step_file: target_step_file,
+#   model_path: model_path,
+#   controller_path: controller_path,
+#   route_path: route_path
+# )
+
+puts 'done'

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,9 +6,10 @@ AllCops:
   NewCops: enable
   Exclude:
     - "_/**/*"
-    - "spec/sample_input/**/*"
-    - "spec/sample_output/**/*"
-    - "lib/k_domain/raw_db_schema/template.rb"
+    - "spec/example_domain/**/*"
+    - "templates/**/*"
+    - "lib/k_domain/schemas/domain/old/**/*"
+    - "spec/k_domain/ruby_loader/**/*"
 
 Metrics/PerceivedComplexity:
   Exclude:

data/Gemfile

@@ -28,8 +28,8 @@ end
 if ENV['KLUE_LOCAL_GEMS']&.to_s&.downcase == 'true'
   group :development, :test do
     puts 'Using Local GEMs'
-    gem 'peeky'                   , path: '../peeky'
     gem 'k_log'                   , path: '../k_log'
     gem 'k_util'                  , path: '../k_util'
+    gem 'peeky'                   , path: '../peeky'
   end
 end

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/k_domain.gemspec

@@ -33,7 +33,7 @@ Gem::Specification.new do |spec|
       f.match(%r{^(test|spec|features)/})
     end
   end
-  
+
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']

data/lib/k_domain/domain_model/load.rb

@@ -20,9 +20,15 @@ module KDomain
 
       def call
         json = File.read(source_file)
-        data = KUtil.data.json_parse(json, as: :hash_symbolized)
+        @raw_data = KUtil.data.json_parse(json, as: :hash_symbolized)
 
-        @data = KDomain::Schemas::DomainModel.new(data)
+        @data = KDomain::Schemas::DomainModel.new(@raw_data)
+      end
+
+      def to_h
+        return nil unless defined? @raw_data
+
+        @raw_data
       end
     end
   end

data/lib/k_domain/domain_model/transform.rb

@@ -11,23 +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 # NOT SURE WHERE THIS BELONGS
+        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
 
@@ -35,61 +46,31 @@ module KDomain
 
         nil
       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
-        Step8LocateRailsModels.run(domain_data, erd_path: erd_path)
-        write(step: '8-rails-files-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
       def domain_data
         # The initial domain model structure is created here, but populated during the workflows.
         @domain_data ||= {
           domain: {
-            models: [],
-            erd_files: [],
+            models: []
           },
-          rails: {
+          rails_resource: {
             models: [],
-            controllers: [],
+            routes: []
           },
-          rails_resource: {
+          rails_structure: {
             models: [],
-            controllers: [],
+            controllers: []
           },
           dictionary: {
             items: []
@@ -98,6 +79,7 @@ module KDomain
             tables: [],
             indexes: [],
             foreign_keys: [],
+            views: [],
             meta: {}
           },
           investigate: {
@@ -105,6 +87,7 @@ module KDomain
           }
         }
       end
+      # rubocop:enable Metrics/MethodLength
     end
   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 './step4_attach_erd_files'
-require_relative './step5_attach_dictionary'
-require_relative './step8_locate_rails_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?
@@ -43,7 +53,7 @@ module KDomain
         domain[:models]
       end
 
-      # Rails File Accessor/Helpers
+      # Rails Resource File Accessor/Helpers
       def rails_resource
         guard('rails_resource is missing') if domain_data[:rails_resource].nil?
 
@@ -58,10 +68,45 @@ 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
 
+      # Rails Structure File Accessor/Helpers
+      def rails_structure
+        guard('rails_structure is missing') if domain_data[:rails_structure].nil?
+
+        domain_data[:rails_structure]
+      end
+
+      def rails_structure_models
+        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
+
+      def rails_structure_controllers
+        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] # .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,7 +27,11 @@ class Step5AttachDictionary < KDomain::DomainModel::Step
       entry[:model_count] = entry[:model_count] + 1
 
       unless entry[:types].include?(column_type)
-        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

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# Schema is re-shaped into a format designed for domain modeling
+class Step2DomainModels < KDomain::DomainModel::Step
+  # Map database schema to domain model
+  def call
+    raise 'Rails model path not supplied' if opts[:model_path].nil?
+
+    domain[:models] = database_tables.map { |table| model(table) }
+  end
+
+  def model(table)
+    table_name = table[:name].to_s
+    model_name = table_name.singularize
+
+    model = {
+      name: model_name,
+      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
+    }
+
+    attach_columns(model)
+  end
+
+  def primary_key(table)
+    {
+      name: table[:primary_key],
+      type: table[:primary_key_type],
+      exist: !table[:primary_key].nil?
+    }
+  end
+
+  def attach_columns(model)
+    table = find_table_for_model(model)
+    columns = columns(table[:columns])
+    columns = insert_primary_key(model, columns)
+    model[:columns] = columns
+    model
+  end
+
+  def columns(db_columns)
+    db_columns.map do |db_column|
+      column_data(db_column[:name]).merge(
+        type: check_type(db_column[:type]),
+        precision: db_column[:precision],
+        scale: db_column[:scale],
+        default: db_column[:default],
+        null: db_column[:null],
+        limit: db_column[:limit],
+        array: db_column[:array]
+      )
+    end
+  end
+
+  def insert_primary_key(model, columns)
+    return columns unless model[:pk][:exist]
+
+    column = column_data('id').merge(
+      type: check_type(model[:pk][:type])
+    )
+
+    columns.unshift(column)
+    columns
+  end
+
+  def check_type(type)
+    type = type.to_sym if type.is_a?(String)
+
+    return type if %i[string integer bigint bigserial boolean float decimal datetime date hstore text jsonb].include?(type)
+
+    if type.nil?
+      guard('nil type detected for db_column[:type]')
+
+      return :string
+    end
+
+    guard("new type detected for db_column[:type] - #{type}")
+
+    camel.parse(type.to_s).downcase
+  end
+
+  def column_data(name)
+    {
+      name: name,
+      name_plural: name.pluralize,
+      type: nil,
+      precision: nil,
+      scale: nil,
+      default: nil,
+      null: nil,
+      limit: nil,
+      array: nil
+    }
+  end
+
+  # # Location of source code
+  # def location(table_name, model_name)
+  #   file_normal = File.join(opts[:model_path], "#{model_name}.rb")
+  #   file_custom = File.join(opts[:model_path], "#{table_name}.rb")
+  #   file_exist  = true
+  #   state = []
+
+  #   if File.exist?(file_normal)
+  #     file = file_normal
+  #     state.push(:has_ruby_model)
+  #   elsif File.exist?(file_custom)
+  #     file = file_custom
+  #     state.push(:has_ruby_model)
+  #     state.push(:nonconventional_name)
+  #   else
+  #     file = ''
+  #     file_exist = false
+  #   end
+
+  #   {
+  #     file: file,
+  #     exist: file_exist,
+  #     state: state
+  #   }
+  # end
+end

data/lib/k_domain/domain_model/transform_steps/{step8_locate_rails_models.rb → step4_rails_resource_models.rb}

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 # Locate rails model files
-class Step8LocateRailsModels < KDomain::DomainModel::Step
+class Step4RailsResourceModels < KDomain::DomainModel::Step
   attr_accessor :ruby_code
 
   def call
-    raise 'ERD path not supplied' if opts[:erd_path].nil?
+    raise 'Model path not supplied' if opts[:model_path].nil?
 
     self.rails_resource_models = domain_models.map do |model|
       locate_rails_model(model[:name], model[:table_name])
@@ -15,8 +15,8 @@ class Step8LocateRailsModels < KDomain::DomainModel::Step
   private
 
   def locate_rails_model(model_name, table_name)
-    file_normal = File.join(opts[:erd_path], "#{model_name}.rb")
-    file_custom = File.join(opts[:erd_path], "#{table_name}.rb")
+    file_normal = File.join(opts[:model_path], "#{model_name}.rb")
+    file_custom = File.join(opts[:model_path], "#{table_name}.rb")
     file_exist  = true
     state = []
 

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Locate rails model files
+class Step5RailsResourceRoutes < KDomain::DomainModel::Step
+  def call
+    return warning('Routes .json file not supplied') if opts[:route_path].nil?
+    return warning('Routes .json file not found') unless File.exist?(opts[:route_path])
+
+    warning('Controller path not supplied. Routes will be loaded but not paired with a controller') if opts[:controller_path].nil?
+
+    self.rails_resource_routes = load_routes(opts[:route_path], opts[:controller_path])
+  end
+
+  private
+
+  def load_routes(route_path, controller_path)
+    json = File.read(route_path)
+    root = JSON.parse(json, symbolize_names: true)
+    routes = root[:routes]
+
+    routes.map { |route| map_route(route, controller_path) }
+  end
+
+  def map_route(route, controller_path)
+    return route.merge({ file: '', exist: false }) if controller_path.nil?
+
+    controller_file = File.join(controller_path, route[:controller_file])
+
+    route.merge(
+      {
+        file: controller_file,
+        exist: File.exist?(controller_file)
+      }
+    )
+  end
+end