k_domain 0.0.15 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a50df0535cc32830a2035c2d2ddd328454efcef8aa97199485ae4db1dc7d64e7
-  data.tar.gz: 34824c4725142b76154a256d6466e7c83e8fc684178f6cb589552ea508d49dfa
+  metadata.gz: 98e1d3eb1435f17ad91084519399234f0adc41e399d1350071147f0e58f694c6
+  data.tar.gz: 2797a698e87169816a6b612239b1c22b8d2fd0db2fd6df2fc8e078fbf8828e69
 SHA512:
-  metadata.gz: 404ae56ada4ee46644d0c562b97dc86e9ce64164e25d1f66119399c4a053e41c183ff5c28184e5de493c76218bfb7f71ff548df02f9b374cb5d57b38c4ceaf3c
-  data.tar.gz: 27c472902e4ca2ea1dfb4803489cf5719356d02a2e64bfcee27ac0179bec5d42bb8c684cbf7196e77dd26a737f8c427bf4aa6809a3a7b930d19acaf269ab9247
+  metadata.gz: 1e6cd0d3fa8354f83b5910dc961212acd0ae149b0b90c31338bf992b4f64500ae4fb05f63c605bf439d818bed8f6f4806939994c0cf8ee6fbd0c0a51d232b02f
+  data.tar.gz: 28d42c273b6fdae5db9b32e4cfcd4c1826e42f929efbc9713941b16bc4240cff22eed7e3260aec195beff43ae3ec20bf136bb6526988eccbd5f475c18ec2566a

data/.rubocop.yml

@@ -8,7 +8,9 @@ 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:

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

@@ -20,6 +20,7 @@ module KDomain
         @erd_path         = erd_path
       end
 
+      # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
       def call
         valid = true
         valid &&= step1
@@ -27,7 +28,8 @@ module KDomain
         valid &&= step3
         valid &&= step4
         valid &&= step5
-        valid &&= step8 # NOT SURE WHERE THIS BELONGS
+        valid &&= step8
+        valid &&= step9
 
         raise 'DomainModal transform failed' unless valid
 
@@ -35,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)
@@ -62,8 +65,13 @@ module KDomain
       end
 
       def step8
-        Step8LocateRailsModels.run(domain_data, erd_path: erd_path)
-        write(step: '8-rails-files-models')
+        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)
@@ -76,20 +84,21 @@ 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: [],
+            erd_files: []
           },
-          rails: {
+          rails_resource: {
             models: [],
-            controllers: [],
+            controllers: []
           },
-          rails_resource: {
+          rails_structure: {
             models: [],
-            controllers: [],
+            controllers: []
           },
           dictionary: {
             items: []
@@ -105,6 +114,8 @@ module KDomain
           }
         }
       end
+
+      # rubocop:enable Metrics/MethodLength
     end
   end
 end

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

@@ -7,4 +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_locate_rails_models'
+require_relative './step8_rails_resource_models'
+require_relative './step9_rails_structure_models'

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

@@ -43,7 +43,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?
 
@@ -62,6 +62,25 @@ module KDomain
         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/step4_attach_erd_files.rb

@@ -24,7 +24,8 @@ class Step4AttachErdFiles < KDomain::DomainModel::Step
   end
 
   def load_dsl(model)
-    print '.'
+    # this should be a configuration
+    # print '.'
 
     reset_dsl
 

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

@@ -27,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_locate_rails_models.rb → step8_rails_resource_models.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Locate rails model files
-class Step8LocateRailsModels < KDomain::DomainModel::Step
+class Step8RailsResourceModels < KDomain::DomainModel::Step
   attr_accessor :ruby_code
 
   def call

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

@@ -33,9 +33,9 @@ module KDomain
         lines = content.lines.map { |line| "    #{line}" }.join
 
         @schema_loader = File
-          .read(template_file)
-          .gsub('{{source_file}}', source_file)
-          .gsub('{{rails_schema}}', lines)
+                         .read(template_file)
+                         .gsub('{{source_file}}', source_file)
+                         .gsub('{{rails_schema}}', lines)
       end
 
       # rename to target_ruby
@@ -68,13 +68,13 @@ module KDomain
           return
         end
 
-        eval(schema_loader)#, __FILE__, __LINE__)
+        eval(schema_loader) # , __FILE__, __LINE__)
 
         loader = LoadSchema.new
         loader.load_schema
-        return loader.schema
-      rescue => ex
-        log.exception(ex)
+        loader.schema
+      rescue StandardError => e
+        log.exception(e)
       end
       # rubocop:enable Security/Eval
     end

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

@@ -15,7 +15,7 @@ module KDomain
         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

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

@@ -19,7 +19,7 @@ module KDomain
         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)

data/lib/k_domain/schemas/domain/erd_file.rb

@@ -3,6 +3,7 @@
 # Domain class holds a list of the entities
 module KDomain
   module DomainModel
+    # rubocop:disable Metrics/BlockLength
     class ErdFile < Dry::Struct
       attribute :name                         , Types::Strict::String
       attribute :name_plural                  , Types::Strict::String
@@ -76,5 +77,6 @@ module KDomain
         end
       end
     end
+    # rubocop:enable Metrics/BlockLength
   end
 end

data/lib/k_domain/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module KDomain
-  VERSION = '0.0.15'
+  VERSION = '0.0.16'
 end

data/lib/k_domain.rb

@@ -11,6 +11,8 @@ require 'k_domain/raw_db_schema/load'
 require 'k_domain/domain_model/transform'
 require 'k_domain/domain_model/transform_steps/_'
 require 'k_domain/domain_model/load'
+require 'k_domain/rails_code_extractor/load_shim'
+# require 'k_domain/rails_code_extractor/extract_model'
 
 # # This is useful if you want to initialize structures via Hash
 # class SymbolizeStruct < Dry::Struct
@@ -25,6 +27,7 @@ module KDomain
     def self.root
       File.expand_path('..', File.dirname(__FILE__))
     end
+
     def self.resource(resource_path)
       File.join(root, resource_path)
     end

data/templates/active_record_shims.rb

@@ -0,0 +1,355 @@
+module ActiveRecord
+  def self.all_loaded_classes
+    @all_loaded_classes ||= []
+  end
+
+  def self.last_loaded_class
+    @last_loaded_class ||= nil
+  end
+
+  class Base
+    def self.singleton_class
+      Class.new do
+        def send(*_p, **_o); end
+      end.new
+    end
+
+    def self.class_info
+      return @class_info if defined? @class_info
+
+      ActiveRecord.last_loaded_class = name
+
+      @class_info = {
+        class_name: name
+      }
+
+      ActiveRecord.all_loaded_classes << class_info
+
+      @class_info
+    end
+
+    def self.set(key, value)
+      class_info[key] = class_info[key] || {}
+      class_info[key] = value
+    end
+
+    def self.add(key, value)
+      class_info[key] = class_info[key] || []
+      if value.is_a?(Array)
+        class_info[key] = class_info[key] + value
+      else
+        class_info[key] << value
+      end
+    end
+
+    def self.custom_set(key, value = {})
+      class_info[:custom] = {} unless class_info[:custom]
+      class_info[:custom][key] = class_info[:custom][key] || {}
+      class_info[:custom][key] = value
+    end
+
+    def self.custom_add(key, value)
+      class_info[:custom] = {} unless class_info[:custom]
+      class_info[:custom][key] = class_info[:custom][key] || []
+      if value.is_a?(Array)
+        class_info[:custom][key] = class_info[:custom][key] + value
+      else
+        class_info[:custom][key] << value
+      end
+    end
+
+    # examples:
+    # enum status: { active: 0, archived: 1 }
+    # enum status: [:active, :archived]
+    # enum status: [:active, :archived], _suffix: true
+    # enum comments_status: [:active, :inactive], _prefix: :comments
+    def self.enum(**opts)
+      add(:enum, opts)
+    end
+
+    def self.attr_accessor(*names)
+      add(:attr_accessor, names)
+    end
+
+    def self.attr_reader(*names)
+      add(:attr_reader, names)
+    end
+
+    def self.attr_writer(*names)
+      add(:attr_writer, names)
+    end
+
+    def self.lambda_source(a_lambda, prefix = nil)
+      return nil unless a_lambda
+
+      puts 'NOT A LAMBDA' unless a_lambda.is_a?(Proc)
+
+      result = a_lambda&.source&.strip
+      result = result&.delete_prefix(prefix) if prefix
+      result&.strip
+    end
+
+    # examples
+    # default_scope where(:published => true) # NOT supported
+    # default_scope { where(:published_at => Time.now - 1.week) }
+    # default_scope -> { order(:external_updated_at) }
+    # default_scope -> { where(:published => true) }, all_queries: true
+    def self.default_scope(**opts, &block)
+      block_source = nil
+      block_source = lambda_source(block, 'default_scope') if block_given?
+
+      set(:default_scope, opts.merge(block: block_source))
+    end
+
+    # examples
+    # scope :red, where(:color => 'red') # NOT SUPPORTED
+    # scope :dry_clean_only, joins(:washing_instructions).where('washing_instructions.dry_clean_only = ?', true) # NOT SUPPORTED
+    #
+    def self.scope(name, on_the_lamb = nil, **opts)
+      lamb_source = lambda_source(on_the_lamb, "scope :#{name},")
+
+      add(:scopes, {
+            name: name,
+            opts: opts,
+            block: lamb_source
+          })
+    end
+
+    def self.belongs_to(name, on_the_lamb = nil, **opts)
+      lamb_source = lambda_source(on_the_lamb, "belongs_to :#{name},")
+
+      add(:belongs_to, {
+            name: name,
+            opts: opts,
+            block: lamb_source
+          })
+    end
+
+    def self.has_many(name, on_the_lamb = nil, **opts)
+      lamb_source = lambda_source(on_the_lamb, "has_many :#{name},")
+
+      add(:has_many, {
+            name: name,
+            opts: opts,
+            block: lamb_source
+          })
+    end
+
+    def self.has_one(name, on_the_lamb = nil, **opts)
+      lamb_source = lambda_source(on_the_lamb, "has_one :#{name},")
+
+      add(:has_one, {
+            name: name,
+            opts: opts,
+            block: lamb_source
+          })
+    end
+
+    def self.has_and_belongs_to_many(name, on_the_lamb = nil, **opts)
+      lamb_source = lambda_source(on_the_lamb, "has_and_belongs_to_many :#{name},")
+
+      add(:has_and_belongs_to_many, {
+            name: name,
+            opts: opts,
+            block: lamb_source
+          })
+    end
+
+    def self.validate(*names, **opts, &block)
+      block_source = nil
+      block_source = lambda_source(block, 'validate') if block_given?
+
+      set(:default_scope, opts.merge(block: block_source))
+
+      add(:validate, {
+            names: names,
+            opts: opts,
+            block: block_source
+          })
+    end
+
+    def self.validates(name, **opts)
+      add(:validates, {
+            name: name,
+            opts: opts
+          })
+    end
+
+    def self.alias_attribute(left, right)
+      add(:alias_attribute, {
+            left: left,
+            right: right
+          })
+    end
+
+    def self.before_create(name)
+      add(:before_create, {
+            name: name
+          })
+    end
+
+    def self.before_save(name)
+      add(:before_save, {
+            name: name
+          })
+    end
+
+    def self.before_destroy(name)
+      add(:before_destroy, {
+            name: name
+          })
+    end
+
+    def self.before_validation(name = nil, &block)
+      block_source = nil
+      block_source = lambda_source(block, 'before_validation') if block_given?
+
+      add(:before_validation, {
+            name: name,
+            block: block_source
+          })
+    end
+
+    def self.after_create(name)
+      add(:after_create, {
+            name: name
+          })
+    end
+
+    def self.after_save(name)
+      add(:after_save, {
+            name: name
+          })
+    end
+
+    def self.after_destroy(name = nil, &block)
+      block_source = nil
+      block_source = lambda_source(block, 'after_destroy') if block_given?
+
+      add(:after_destroy, {
+            name: name,
+            block: block_source
+          })
+    end
+
+    def self.after_commit(name)
+      add(:after_commit, {
+            name: name
+          })
+    end
+
+    def self.accepts_nested_attributes_for(name, **opts)
+      add(:accepts_nested_attributes_for, {
+            name: name,
+            opts: opts
+          })
+    end
+
+    def self.has_secure_token(name)
+      add(:has_secure_token, {
+            name: name
+          })
+    end
+
+    # CAN THESE BE AUTOMATED LIKE INCLUDE MODULES
+    def self.establish_connection(connection)
+      class_info[:establish_connection] = connection
+    end
+
+    def self.store_accessor(*names)
+      class_info[:store_accessor] = *names
+    end
+
+    def self.table_name=(table_name)
+      class_info[:table_name] = table_name
+    end
+
+    def self.primary_key=(primary_key)
+      class_info[:primary_key] = primary_key
+    end
+
+    def self.require(require)
+      add(:require, require)
+    end
+
+    def self.devise(*names)
+      add(:devise, names)
+    end
+
+    def self.pg_search_scope(name, **opts)
+      custom_set(:pg_search_scope, {
+                   name: name,
+                   opts: opts
+                 })
+    end
+
+    def self.acts_as_readable(**opts)
+      custom_set(:acts_as_readable, {
+                   opts: opts
+                 })
+    end
+
+    def self.acts_as_reader
+      custom_set(:acts_as_reader, {})
+    end
+
+    def self.acts_as_commentable
+      custom_set(:acts_as_commentable, {})
+    end
+
+    def self.acts_as_list(**opts)
+      custom_set(:acts_as_list, {
+                   opts: opts
+                 })
+    end
+
+    def self.has_paper_trail
+      custom_set(:has_paper_trail)
+    end
+
+    def self.validates_uniqueness_of(name, **opts)
+      custom_set(:validates_uniqueness_of, {
+                   name: name,
+                   opts: opts
+                 })
+    end
+
+    def self.validates_presence_of(name, **opts)
+      custom_set(:validates_presence_of, {
+                   name: name,
+                   opts: opts
+                 })
+    end
+
+    def self.validates_length_of(name, **opts)
+      custom_set(:validates_length_of, {
+                   name: name,
+                   opts: opts
+                 })
+    end
+
+    def self.attr_encrypted(name, **opts)
+      custom_set(:attr_encrypted, {
+                   name: name,
+                   opts: opts
+                 })
+    end
+
+    def self.validates_confirmation_of(name, **opts)
+      custom_set(:validates_confirmation_of, {
+                   name: name,
+                   opts: opts
+                 })
+    end
+
+    def self.with_options(opts, &block)
+      block_source = nil
+      block_source = lambda_source(block) if block_given?
+
+      custom_add(:with_options, {
+                   opts: opts,
+                   block: block_source
+                 })
+    end
+  end
+end

data/templates/fake_module_shims.rb

@@ -0,0 +1,42 @@
+class Rails
+  def self.env; end
+
+  def self.application
+    OpenStruct.new(secrets: OpenStruct.new(credentials_secret_key: Base64.encode64('ABC')))
+  end
+end
+
+module ActsAsCommentable
+  module Comment
+  end
+end
+
+module Scopes
+  module CompanyScopes
+  end
+end
+
+module ActionView
+  module Helpers
+    module NumberHelper
+    end
+  end
+end
+
+module RailsUpgrade
+  def rails4?
+    true
+  end
+
+  def rails5?
+    true
+  end
+
+  def rails6?
+    true
+  end
+
+  def belongs_to_required
+    {}
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: k_domain
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.16
 platform: ruby
 authors:
 - David Cruwys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-02 00:00:00.000000000 Z
+date: 2021-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -104,7 +104,10 @@ files:
 - lib/k_domain/domain_model/transform_steps/step3_attach_columns.rb
 - lib/k_domain/domain_model/transform_steps/step4_attach_erd_files.rb
 - lib/k_domain/domain_model/transform_steps/step5_attach_dictionary.rb
-- lib/k_domain/domain_model/transform_steps/step8_locate_rails_models.rb
+- lib/k_domain/domain_model/transform_steps/step8_rails_resource_models.rb
+- lib/k_domain/domain_model/transform_steps/step9_rails_structure_models.rb
+- lib/k_domain/rails_code_extractor/extract_model.rb
+- lib/k_domain/rails_code_extractor/load_shim.rb
 - lib/k_domain/raw_db_schema/load.rb
 - lib/k_domain/raw_db_schema/transform.rb
 - lib/k_domain/schemas/_.rb
@@ -139,6 +142,8 @@ files:
 - lib/k_domain/schemas/investigate.rb
 - lib/k_domain/schemas/rails_resource.rb
 - lib/k_domain/version.rb
+- templates/active_record_shims.rb
+- templates/fake_module_shims.rb
 - templates/load_schema.rb
 homepage: http://appydave.com/gems/k-domain
 licenses: