k_domain 0.0.5 → 0.0.16

data/lib/k_domain/{domain_model/dtos → schemas/domain}/_.rb

@@ -2,33 +2,10 @@
 
 # log.warn 'models->domain' if AppDebug.require?
 
-require_relative './dictionary/dictionary'
-require_relative './investigate/issue'
-require_relative './investigate/investigate'
 require_relative './models/column'
 require_relative './models/model'
+require_relative './erd_file'
 require_relative './domain'
-require_relative './schema'
-
-# require_relative './helper/domain_config'
-# require_relative './helper/main_key'
-# require_relative './helper/traits'
-
-# require_relative './belongs_to'
-# require_relative './domain_statistics'
-# # require_relative './domain_mapper'
-# require_relative './entity'
-# require_relative './entity_statistics'
-# require_relative './foreign_key'
-# require_relative './has_and_belongs_to_many'
-# require_relative './has_many'
-# require_relative './has_one'
-# require_relative './name_options'
-# require_relative './rails_model'
-# require_relative './related_entity'
-# require_relative './statistics'
-# require_relative './validate'
-# require_relative './validates'
 
 module KDomain
   module DomainModel

data/lib/k_domain/{domain_model/dtos → schemas/domain}/domain.rb

@@ -5,7 +5,7 @@ module KDomain
   module DomainModel
     class Domain < Dry::Struct
       attribute :models               , Types::Strict::Array.of(KDomain::DomainModel::Model)
-      attribute :dictionary           , Types::Strict::Array.of(KDomain::DomainModel::Dictionary)
+      attribute :erd_files            , Types::Strict::Array.of(KDomain::DomainModel::ErdFile)
     end
   end
 end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# 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
+      attribute :dsl_file                     , Types::Strict::String
+
+      attribute? :source                      , Dry::Struct.optional.default(nil) do
+        attribute :ruby                       , Types::Strict::String
+        attribute :public                     , Types::Strict::String.optional.default(nil)
+        attribute :private                    , Types::Strict::String.optional.default(nil)
+
+        attribute? :all_methods               , Dry::Struct.optional.default(nil) do
+          attribute? :klass                   , Types::Strict::Array do
+            attribute :name                   , Types::Strict::String
+            attribute :scope                  , Types::Strict::String # .optional.default(nil)
+            attribute :class_method           , Types::Strict::Bool
+            attribute :arguments              , Types::Strict::String
+          end
+          attribute? :instance                , Types::Strict::Array do
+            attribute :name                   , Types::Strict::String
+            attribute :scope                  , Types::Strict::String # .optional.default(nil)
+            attribute :class_method           , Types::Strict::Bool
+            attribute :arguments              , Types::Strict::String
+          end
+          attribute? :instance_public         , Types::Strict::Array do
+            attribute :name                   , Types::Strict::String
+            attribute :scope                  , Types::Strict::String # .optional.default(nil)
+            attribute :class_method           , Types::Strict::Bool
+            attribute :arguments              , Types::Strict::String
+          end
+          attribute? :instance_private        , Types::Strict::Array do
+            attribute :name                   , Types::Strict::String
+            attribute :scope                  , Types::Strict::String # .optional.default(nil)
+            attribute :class_method           , Types::Strict::Bool
+            attribute :arguments              , Types::Strict::String
+          end
+        end
+      end
+      attribute? :dsl                       , Dry::Struct.optional.default(nil) do
+        attribute :default_scope            , Types::Strict::String.optional.default(nil)
+
+        attribute? :scopes                  , Types::Strict::Array do
+          attribute :name                   , Types::Strict::String
+          attribute :scope                  , Types::Strict::String # .optional.default(nil)
+        end
+        attribute? :belongs_to              , Types::Strict::Array do
+          attribute :name                   , Types::Strict::String
+          attribute :options                , Types::Strict::Hash.optional.default({}.freeze)
+          attribute :raw_options            , Types::Strict::String
+        end
+        attribute? :has_one                 , Types::Strict::Array do
+          attribute :name                   , Types::Strict::String
+          attribute :options                , Types::Strict::Hash.optional.default({}.freeze)
+          attribute :raw_options            , Types::Strict::String
+        end
+        attribute? :has_many                , Types::Strict::Array do
+          attribute :name                   , Types::Strict::String
+          attribute :options                , Types::Strict::Hash.optional.default({}.freeze)
+          attribute :raw_options            , Types::Strict::String
+        end
+        attribute? :has_and_belongs_to_many , Types::Strict::Array do
+          attribute :name                   , Types::Strict::String
+          attribute :options                , Types::Strict::Hash.optional.default({}.freeze)
+          attribute :raw_options            , Types::Strict::String
+        end
+        attribute? :validate_on             , Types::Strict::Array do
+          attribute :line                   , Types::Strict::String
+        end
+        attribute? :validates_on            , Types::Strict::Array do
+          attribute :name                   , Types::Strict::String
+          attribute :raw_options            , Types::Strict::String
+        end
+      end
+    end
+    # rubocop:enable Metrics/BlockLength
+  end
+end

data/lib/k_domain/schemas/domain_model.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# DomainModel holds the entire domain model including database and ancillary information
+module KDomain
+  module Schemas
+    class DomainModel < Dry::Struct
+      attribute :domain         , KDomain::DomainModel::Domain
+      attribute :database       , KDomain::Database::Schema
+      attribute :dictionary     , KDomain::Schemas::Dictionary
+      attribute :rails_resource , KDomain::Schemas::RailsResource
+      attribute :investigate    , KDomain::Schemas::Investigate
+    end
+  end
+end

data/lib/k_domain/schemas/investigate.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Domain class holds a dictionary entry
+module KDomain
+  module Schemas
+    class Investigate < Dry::Struct
+      attribute :issues                 , Types::Strict::Array do
+        attribute :step                 , Types::Strict::String
+        attribute :location             , Types::Strict::String
+        attribute :key                  , Types::Strict::String.optional.default(nil)
+        attribute :message              , Types::Strict::String
+      end
+    end
+  end
+end

data/lib/k_domain/schemas/rails_resource.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Domain class holds a dictionary entry
+module KDomain
+  module Schemas
+    class RailsResource < Dry::Struct
+      attribute :models               , Types::Strict::Array do
+        attribute :model_name         , Types::Strict::String
+        attribute :table_name         , Types::Strict::String
+        attribute :file               , Types::Strict::String
+        attribute :exist              , Types::Strict::Bool
+        attribute :state              , Types::Strict::String
+      end
+    end
+  end
+end

data/lib/k_domain/version.rb

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

data/lib/k_domain.rb

@@ -3,14 +3,16 @@
 require 'active_support/core_ext/string'
 require 'dry-struct'
 require 'k_log'
+require 'peeky'
 require 'k_domain/version'
-require 'k_domain/raw_db_schema/dtos/_'
+require 'k_domain/schemas/_'
 require 'k_domain/raw_db_schema/transform'
 require 'k_domain/raw_db_schema/load'
-require 'k_domain/domain_model/dtos/_'
 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
@@ -21,6 +23,16 @@ module KDomain
   # raise KDomain::Error, 'Sample message'
   class Error < StandardError; end
 
+  module Gem
+    def self.root
+      File.expand_path('..', File.dirname(__FILE__))
+    end
+
+    def self.resource(resource_path)
+      File.join(root, resource_path)
+    end
+  end
+
   # Your code goes here...
 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