k_domain 0.0.5 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92aebc822bef5bff0524221c4ca53f3bccdf4f3b4a134c2bcdd207f7c58e5609
-  data.tar.gz: db850d6a8d98ee6a5fd77f1cfe5a9e87d5da262ebec598c84f8ca70b3fb5a1cb
+  metadata.gz: 98e1d3eb1435f17ad91084519399234f0adc41e399d1350071147f0e58f694c6
+  data.tar.gz: 2797a698e87169816a6b612239b1c22b8d2fd0db2fd6df2fc8e078fbf8828e69
 SHA512:
-  metadata.gz: d31d1bd2e461d1a86b938eb043c9dda1c5f553e3a8a1ddd759e0ff24b349da2100f934feb0ac8b001da137086862145aa575be1a2b32a6070f1f82b5ff63a837
-  data.tar.gz: acd57f1f859401f1d0ff8f39fc7cc3eb69ee128a0c91b94f5ce92bb275ff82924663ce00beb58a25c19752934e2ccc70f1cf04a83e1b8de429e70bd403fb48eb
+  metadata.gz: 1e6cd0d3fa8354f83b5910dc961212acd0ae149b0b90c31338bf992b4f64500ae4fb05f63c605bf439d818bed8f6f4806939994c0cf8ee6fbd0c0a51d232b02f
+  data.tar.gz: 28d42c273b6fdae5db9b32e4cfcd4c1826e42f929efbc9713941b16bc4240cff22eed7e3260aec195beff43ae3ec20bf136bb6526988eccbd5f475c18ec2566a

data/.rubocop.yml

@@ -8,12 +8,15 @@ AllCops:
     - "_/**/*"
     - "spec/sample_input/**/*"
     - "spec/sample_output/**/*"
-    - "lib/k_domain/raw_db_schema/template.rb"
+    - "templates/**/*"
+    - "lib/k_domain/schemas/domain/old/**/*"
+    - "spec/k_domain/ruby_loader/**/*"
 
 Metrics/PerceivedComplexity:
   Exclude:
     - "lib/k_domain/domain_model/transform_steps/*.rb"
     - "lib/k_domain/domain_model/dtos/entity.rb"
+    - "lib/k_domain/domain_model/dtos/old/entity.rb"
 
 Metrics/AbcSize:
   Exclude:
@@ -21,16 +24,21 @@ Metrics/AbcSize:
     - "lib/k_domain/domain_model/dtos/rails_model.rb"
     - "lib/k_domain/domain_model/dtos/entity.rb"
     - "lib/k_domain/domain_model/dtos/column_old.rb"
+    - "lib/k_domain/domain_model/dtos/old/column_old.rb"
+    - "lib/k_domain/domain_model/dtos/old/rails_model.rb"
+    - "lib/k_domain/domain_model/dtos/old/entity.rb"
 
 Metrics/CyclomaticComplexity:
   Exclude:
     - "lib/k_domain/domain_model/transform_steps/*.rb"
     - "lib/k_domain/domain_model/dtos/entity.rb"
+    - "lib/k_domain/domain_model/dtos/old/entity.rb"
 
 Metrics/BlockLength:
   Exclude:
     - "**/spec/**/*"
     - "*.gemspec"
+    - 'lib/k_domain/domain_model/dtos/erd_file.rb'    
   IgnoredMethods:
     - configure
     - context
@@ -56,6 +64,8 @@ Metrics/MethodLength:
   Exclude:
     - "lib/k_domain/domain_model/transform_steps/*.rb"
     - "lib/k_domain/domain_model/dtos/rails_model.rb"
+    - "lib/k_domain/domain_model/dtos/old/entity.rb"
+    - "lib/k_domain/domain_model/dtos/old/rails_model.rb"
 
 Layout/LineLength:
   Max: 200

data/Gemfile

@@ -23,3 +23,13 @@ group :development, :test do
   gem 'rubocop-rake', require: false
   gem 'rubocop-rspec', require: false
 end
+
+# If local dependency
+if ENV['KLUE_LOCAL_GEMS']&.to_s&.downcase == 'true'
+  group :development, :test do
+    puts 'Using Local GEMs'
+    gem 'k_log'                   , path: '../k_log'
+    gem 'k_util'                  , path: '../k_util'
+    gem 'peeky'                   , path: '../peeky'
+  end
+end

data/Rakefile

@@ -26,7 +26,9 @@ task :publish do
   system 'gem build'
   system "gem push #{GEM_NAME}-#{KDomain::VERSION}.gem"
 end
-
+task :build do
+  system 'gem build'
+end
 desc 'Remove old *.gem files'
 task :clean do
   system 'rm *.gem'

data/STORIES.md

@@ -16,6 +16,21 @@ As a Developer, I can customize domain configuration, so that I can have opinion
 
 - Handle traits
 
+As a Developer, I can read native rails model data, so that I can leverage existing rails applications for ERD modeling
+
+- Use Meta Programming and re-implement ActiveRecord::Base
+
+### Tasks next on list
+
+Refactor / Simply
+
+- Replace complex objects an with structs for ancillary data structures such as investigate
+
+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

data/k_domain.gemspec

@@ -33,6 +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']
@@ -41,4 +42,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'activesupport'   , '~> 6'
   spec.add_dependency 'dry-struct', '~> 1'
   spec.add_dependency 'k_log' , '~> 0.0.0'
+  spec.add_dependency 'peeky' , '~> 0.0.0'
 end

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::DomainModel::Schema.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

@@ -13,13 +13,14 @@ module KDomain
       attr_reader :target_file
       attr_reader :erd_path
 
-      def initialize(db_schema, target_file, target_step_file, erd_path)
+      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
       end
 
+      # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
       def call
         valid = true
         valid &&= step1
@@ -27,6 +28,8 @@ module KDomain
         valid &&= step3
         valid &&= step4
         valid &&= step5
+        valid &&= step8
+        valid &&= step9
 
         raise 'DomainModal transform failed' unless valid
 
@@ -34,6 +37,7 @@ module KDomain
 
         nil
       end
+      # rubocop:enable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
       def step1
         Step1AttachDbSchema.run(domain_data, db_schema: db_schema)
@@ -60,6 +64,16 @@ module KDomain
         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
@@ -70,13 +84,24 @@ module KDomain
         File.write(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: [],
-            dictionary: []
+            erd_files: []
+          },
+          rails_resource: {
+            models: [],
+            controllers: []
+          },
+          rails_structure: {
+            models: [],
+            controllers: []
+          },
+          dictionary: {
+            items: []
           },
           database: {
             tables: [],
@@ -89,6 +114,8 @@ module KDomain
           }
         }
       end
+
+      # rubocop:enable Metrics/MethodLength
     end
   end
 end

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

@@ -7,3 +7,5 @@ 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'

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

@@ -43,6 +43,44 @@ module KDomain
         domain[:models]
       end
 
+      # Rails Resource File Accessor/Helpers
+      def rails_resource
+        guard('rails_resource is missing') if domain_data[:rails_resource].nil?
+
+        domain_data[:rails_resource]
+      end
+
+      def rails_resource_models
+        rails_resource[:models]
+      end
+
+      def rails_resource_models=(value)
+        rails_resource[:models] = 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 rails_structure_models=(value)
+        rails_structure[:models] = value
+      end
+
+      def rails_structure_controllers
+        rails_structure[:controllers]
+      end
+
       # Database Accessor/Helpers
       def database=(value)
         domain_data[:database] = value

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

@@ -13,7 +13,7 @@ module KDomain
         guard('indexes are missing')              if database[:indexes].nil?
         guard('foreign keys are missing')         if database[:foreign_keys].nil?
         guard('rails version is missing')         if database[:meta][:rails].nil?
-        guard('postgres extensions are missing')  if database[:meta][:database][:extensions].nil?
+        guard('postgres extensions are missing')  if database[:meta][:db_info][:extensions].nil?
         guard('unique keys are missing')          if database[:meta][:unique_keys].nil?
       end
     end

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

@@ -24,6 +24,9 @@ class Step4AttachErdFiles < KDomain::DomainModel::Step
   end
 
   def load_dsl(model)
+    # this should be a configuration
+    # print '.'
+
     reset_dsl
 
     dsl[:name]        = model[:name]
@@ -58,7 +61,7 @@ class Step4AttachErdFiles < KDomain::DomainModel::Step
       ruby: ruby_code,
       public: public_code,
       private: private_code,
-      methods: grab_methods(public_code, private_code)
+      all_methods: grab_methods(public_code, private_code)
     }
   end
 
@@ -348,7 +351,7 @@ class Step4AttachErdFiles < KDomain::DomainModel::Step
     instance_private  = all_instance.select { |method| method[:scope] == :private }
 
     {
-      class: class_methods,
+      klass: class_methods,
       instance: all_instance,
       instance_public: instance_public,
       instance_private: instance_private

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

@@ -13,7 +13,9 @@ class Step5AttachDictionary < KDomain::DomainModel::Step
       end
     end
 
-    domain[:dictionary] = dictionary.values
+    domain_data[:dictionary] = {
+      items: dictionary.values
+    }
   end
 
   private
@@ -25,7 +27,8 @@ 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}")
+        # ADD to investigate
+        # log.warn("#{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/step8_rails_resource_models.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Locate rails model files
+class Step8RailsResourceModels < KDomain::DomainModel::Step
+  attr_accessor :ruby_code
+
+  def call
+    raise 'ERD path not supplied' if opts[:erd_path].nil?
+
+    self.rails_resource_models = domain_models.map do |model|
+      locate_rails_model(model[:name], model[:table_name])
+    end
+  end
+
+  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_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(:non_conventional_name)
+    else
+      file = ''
+      file_exist = false
+      state.push(:model_not_found)
+    end
+
+    {
+      model_name: model_name,
+      table_name: table_name,
+      file: file,
+      exist: file_exist,
+      state: state.join(', ')
+    }
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Locate rails model files
+class Step9RailsStructureModels < KDomain::DomainModel::Step
+  attr_accessor :ruby_code
+
+  def call
+    raise 'ERD path not supplied' if opts[:erd_path].nil?
+
+    self.rails_structure_models = rails_resource_models.map do |resource|
+      process_resource(OpenStruct.new(resource))
+    end
+  end
+
+  private
+
+  def process_resource(resource)
+    erd_path = opts[:erd_path]
+    puts erd_path
+    @model = {
+      model_name: resource.model_name,
+      table_name: resource.table_name,
+      file: resource.file,
+      exist: resource.exist,
+      state: resource.state,
+      code: resource.exist ? File.read(resource.file) : '',
+      behaviours: {},
+      functions: {}
+    }
+
+    @model
+  end
+end

data/lib/k_domain/rails_code_extractor/extract_model.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Takes a Rails Model and extracts DSL behaviours and custom functions (instance, class and private methods)
+module KDomain
+  module RailsCodeExtractor
+    class ExtractModel
+      include KLog::Logging
+
+      attr_reader :source_file
+      attr_reader :data
+
+      def initialize(source_file)
+        @source_file = source_file
+      end
+
+      def call
+        log.kv 'source_file', source_file
+      end
+    end
+  end
+end

data/lib/k_domain/rails_code_extractor/load_shim.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Code extraction requires shims to be loaded before extraction
+#
+# This shims server two purposes
+#
+# 1. Inject data capture methods calls that intercept DSL macros so that data can be extracted
+# 2. Inject fake module/classes that would otherwise break code loading with various exceptions
+module KDomain
+  module RailsCodeExtractor
+    class LoadShim
+      include KLog::Logging
+
+      attr_reader :shim_files
+
+      attr_reader :dsl_shim_file
+      attr_reader :fake_module_file
+
+      def initialize
+        @shim_files = []
+      end
+
+      def call
+        log.kv 'preload', preload
+      end
+
+      def register(name, file)
+        @shim_files << { name: name, file: file, exist: File.exist?(file) }
+      end
+    end
+  end
+end

data/lib/k_domain/raw_db_schema/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::RawDbSchema::Schema.new(data)
+        @data = KDomain::Database::Schema.new(@raw_data)
+      end
+
+      def to_h
+        return nil unless defined? @raw_data
+
+        @raw_data
       end
     end
   end

data/lib/k_domain/raw_db_schema/transform.rb

@@ -14,10 +14,9 @@ module KDomain
       attr_reader :template_file
       attr_reader :schema_loader
 
-      # , target_file)
       def initialize(source_file)
         @source_file = source_file
-        @template_file = 'lib/k_domain/raw_db_schema/template.rb'
+        @template_file = KDomain::Gem.resource('templates/load_schema.rb')
       end
 
       def call
@@ -25,7 +24,6 @@ module KDomain
         # log.kv 'template_file', template_file
         # log.kv 'source_file?', File.exist?(source_file)
         # log.kv 'template_file?', File.exist?(template_file)
-
         log.error "Template not found: #{template_file}" unless File.exist?(template_file)
 
         content = File.read(source_file)
@@ -70,12 +68,13 @@ module KDomain
           return
         end
 
-        # load target_file
-        eval schema_loader
+        eval(schema_loader) # , __FILE__, __LINE__)
 
         loader = LoadSchema.new
         loader.load_schema
         loader.schema
+      rescue StandardError => e
+        log.exception(e)
       end
       # rubocop:enable Security/Eval
     end

data/lib/k_domain/schemas/_.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# log.warn 'models->domain' if AppDebug.require?
+
+module Types
+  include Dry.Types()
+end
+
+require_relative 'rails_resource'
+require_relative 'investigate'
+require_relative 'database/_'
+require_relative 'dictionary'
+require_relative 'domain/_'
+
+require_relative './domain_model'

data/lib/k_domain/{raw_db_schema/dtos → schemas/database}/_.rb

@@ -1,14 +1,7 @@
 # frozen_string_literal: true
 
-module Types
-  include Dry.Types()
-end
-
 # The require order is important due to dependencies
-require_relative './column'
-require_relative './database'
 require_relative './index'
 require_relative './table'
 require_relative './foreign_key'
-require_relative './unique_key'
 require_relative './schema'

data/lib/k_domain/{raw_db_schema/dtos → schemas/database}/foreign_key.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module KDomain
-  module RawDbSchema
+  module Database
     class ForeignKey < Dry::Struct
       attribute :left                 , Types::Strict::String
       attribute :right                , Types::Strict::String

data/lib/k_domain/{raw_db_schema/dtos → schemas/database}/index.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module KDomain
-  module RawDbSchema
+  module Database
     class Index < Dry::Struct
       attribute :name                 , Types::Strict::String
       attribute :fields               , Types::Nominal::Any.optional.default('xxxxx1')

data/lib/k_domain/schemas/database/schema.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module KDomain
+  module Database
+    class Schema < Dry::Struct
+      class DbInfo < Dry::Struct
+        attribute :type                 , Types::Strict::String
+        attribute :version              , Types::Nominal::Any.optional.default(nil)
+        attribute :extensions           , Types::Strict::Array
+      end
+
+      class UniqueKey < Dry::Struct
+        attribute :type                 , Types::Strict::String
+        attribute :category             , Types::Strict::String.optional
+        attribute :key                  , Types::Strict::String
+        attribute :keys                 , Types::Strict::Array
+      end
+
+      class Meta < Dry::Struct
+        attribute :rails                , Types::Strict::Integer
+        attribute :db_info              , KDomain::Database::Schema::DbInfo
+        attribute :unique_keys          , Types::Strict::Array.of(KDomain::Database::Schema::UniqueKey)
+      end
+
+      attribute :tables               , Types::Strict::Array.of(KDomain::Database::Table)
+      attribute :foreign_keys?        , Types::Strict::Array.of(KDomain::Database::ForeignKey)
+      attribute :indexes?             , Types::Strict::Array.of(KDomain::Database::Index)
+      attribute :meta                 , KDomain::Database::Schema::Meta
+    end
+  end
+end

data/lib/k_domain/schemas/database/table.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module KDomain
+  module Database
+    class Table < Dry::Struct
+      class RailsSchema < Dry::Struct
+        attribute :primary_key          , Types::Nominal::Any.optional.default(nil)
+        attribute :id                   , Types::Nominal::Any.optional.default(nil)
+        attribute :force                , Types::Nominal::Any.optional.default(nil)
+      end
+
+      class Column < Dry::Struct
+        attribute :name                 , Types::Strict::String
+        attribute :type                 , Types::Strict::String
+        attribute :precision?           , Types::Strict::Integer.optional.default(nil)
+        attribute :scale?               , Types::Strict::Integer.optional.default(nil)
+        attribute :default?             , Types::Nominal::Any.optional.default(nil)
+        attribute :array?               , Types::Strict::Bool.optional.default(nil)
+        attribute :null?                , Types::Strict::Bool.optional.default(nil)
+        attribute :limit?               , Types::Strict::Integer.optional.default(nil)
+      end
+
+      attribute :name                 , Types::Strict::String
+      attribute :primary_key          , Types::Strict::String.optional.default(nil)
+      attribute :primary_key_type     , Types::Strict::String.optional.default(nil)
+      attribute :id?                  , Types::Nominal::Any.optional.default(nil)
+      attribute :columns              , Types::Strict::Array.of(KDomain::Database::Table::Column)
+      attribute :indexes              , Types::Strict::Array.of(KDomain::Database::Index) # May want to have a Table::Index, but for now this is a shared scheam
+      attribute :rails_schema         , KDomain::Database::Table::RailsSchema
+    end
+  end
+end

data/lib/k_domain/schemas/dictionary.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Domain class holds a dictionary entry
+module KDomain
+  module Schemas
+    class Dictionary < Dry::Struct
+      attribute :items              , Types::Strict::Array do
+        attribute :name             , Types::Strict::String
+        attribute :type             , Types::Strict::String
+        attribute :label            , Types::Strict::String
+        attribute :segment          , Types::Strict::String
+        attribute :models           , Types::Strict::Array
+        attribute :model_count      , Types::Strict::Integer
+        attribute :types            , Types::Strict::Array
+        attribute :type_count       , Types::Strict::Integer
+      end
+    end
+  end
+end