k_domain 0.0.11 → 0.0.20

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

@@ -3,10 +3,23 @@
 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 :database             , KDomain::Database::Database
-        attribute :unique_keys          , Types::Strict::Array.of(KDomain::Database::UniqueKey)
+        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)

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

@@ -3,19 +3,30 @@
 module KDomain
   module Database
     class Table < Dry::Struct
-      class Meta < 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
 
-      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) # Types::Strict::String.optional.default(nil)
-      attribute :columns              , Types::Strict::Array.of(KDomain::Database::Column)
-      attribute :indexes              , Types::Strict::Array.of(KDomain::Database::Index)
-      attribute :rails_schema         , KDomain::Database::Table::Meta
+      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

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

@@ -2,13 +2,10 @@
 
 # log.warn 'models->domain' if AppDebug.require?
 
-require_relative './dictionary'
-require_relative './investigate'
 require_relative './models/column'
 require_relative './models/model'
 require_relative './erd_file'
 require_relative './domain'
-require_relative './schema'
 
 module KDomain
   module DomainModel

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

@@ -5,8 +5,7 @@ module KDomain
   module DomainModel
     class Domain < Dry::Struct
       attribute :models               , Types::Strict::Array.of(KDomain::DomainModel::Model)
-      attribute :erd_files            , Types::Strict::Array.of(KDomain::DomainModel::ErdFile)
-      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

@@ -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/schemas/domain_model.rb

@@ -0,0 +1,15 @@
+# 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 :rails_structure  , KDomain::Schemas::RailsStructure
+      attribute :investigate      , KDomain::Schemas::Investigate
+    end
+  end
+end

data/lib/k_domain/schemas/{domain/investigate.rb → investigate.rb}

@@ -2,7 +2,7 @@
 
 # Domain class holds a dictionary entry
 module KDomain
-  module DomainModel
+  module Schemas
     class Investigate < Dry::Struct
       attribute :issues                 , Types::Strict::Array do
         attribute :step                 , Types::Strict::String

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/schemas/rails_structure.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# Domain class holds a dictionary entry
+module KDomain
+  module Schemas
+    class RailsStructure < Dry::Struct
+      class DefaultScope < Dry::Struct
+        attribute :block?                     , Types::Strict::String
+      end
+
+      class BaseType < Dry::Struct
+        attribute :name?                      , Types::Strict::String
+        attribute :opts?                      , Types::Strict::Hash
+        attribute :block?                     , Types::Strict::String.optional.default(nil)
+      end
+
+      class Scope < KDomain::Schemas::RailsStructure::BaseType
+      end
+
+      class BelongsTo < KDomain::Schemas::RailsStructure::BaseType
+      end
+
+      class HasOne < KDomain::Schemas::RailsStructure::BaseType
+      end
+
+      class HasMany < KDomain::Schemas::RailsStructure::BaseType
+      end
+
+      class HasAndBelongsToMany < KDomain::Schemas::RailsStructure::BaseType
+      end
+
+      class Validate < Dry::Struct
+        attribute :names?                     , Types::Array.of(Types::Strict::String)
+        attribute :opts?                      , Types::Strict::Hash
+        attribute :block?                     , Types::Strict::String.optional.default(nil)
+      end
+
+      class Validates < KDomain::Schemas::RailsStructure::BaseType
+      end
+
+      class Behaviours < Dry::Struct
+        attribute :class_name?                , Types::Strict::String
+        attribute :default_scope?             , KDomain::Schemas::RailsStructure::DefaultScope
+        attribute :scopes?                    , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::Scope)
+        attribute :belongs_to?                , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::BelongsTo)
+        attribute :has_one?                   , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::HasOne)
+        attribute :has_many?                  , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::HasMany)
+        attribute :has_and_belongs_to_many?   , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::HasAndBelongsToMany)
+        attribute :validate?                  , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::Validate)
+        attribute :validates?                 , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::Validates)
+        attribute :attr_accessor?             , Types::Array.of(Types::Strict::String)
+        attribute :attr_reader?               , Types::Array.of(Types::Strict::String)
+        attribute :attr_writer?               , Types::Array.of(Types::Strict::String)
+      end
+
+      class Method < Dry::Struct
+        attribute :name                       , Types::Strict::String
+      end
+
+      class Functions < Dry::Struct
+        attribute :class_name?                , Types::Strict::String
+        attribute :module_name?               , Types::Strict::String
+        attribute :class_full_name?           , Types::Strict::String
+        attribute :attr_accessor?             , Types::Array.of(Types::Strict::String)
+        attribute :attr_reader?               , Types::Array.of(Types::Strict::String)
+        attribute :attr_writer?               , Types::Array.of(Types::Strict::String)
+        attribute :klass?                     , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::Method)
+        attribute :instance_public?           , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::Method)
+        attribute :instance_private?          , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::Method)
+      end
+
+      class Model < Dry::Struct
+        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
+        attribute :code                       , Types::Strict::String
+        attribute :behaviours?                , KDomain::Schemas::RailsStructure::Behaviours
+        attribute :functions?                 , KDomain::Schemas::RailsStructure::Functions
+      end
+
+      class Controller < Dry::Struct
+      end
+
+      attribute :models                       , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::Model)
+      attribute :controllers                  , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::Controller)
+    end
+  end
+end
+
+# attribute :domain           , KDomain::DomainModel::Domain

data/lib/k_domain/version.rb

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

data/lib/k_domain.rb

@@ -5,14 +5,14 @@ require 'dry-struct'
 require 'k_log'
 require 'peeky'
 require 'k_domain/version'
-require 'k_domain/schemas/database/_'
-require 'k_domain/schemas/domain/_'
-
+require 'k_domain/schemas/_'
 require 'k_domain/raw_db_schema/transform'
 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/shim_loader'
+require 'k_domain/rails_code_extractor/extract_model'
 
 # # This is useful if you want to initialize structures via Hash
 # class SymbolizeStruct < Dry::Struct
@@ -23,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,368 @@
+module ActiveRecord
+  def self.current_class
+    @current_class ||= nil
+  end
+
+  def self.current_class=(value)
+    @current_class = value
+  end
+
+  class Base
+    def self.singleton_class
+      Class.new do
+        def send(*_p, **_o); end
+      end.new
+    end
+
+    def self.class_info
+      return ActiveRecord.current_class if ActiveRecord.current_class
+
+      ActiveRecord.current_class = {
+        class_name: name
+      }
+    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(*args)
+    #   args.each do |arg|
+    #     self.class_eval("def #{arg};@#{arg};end")
+    #     self.class_eval("def #{arg}=(val);@#{arg}=val;end")
+    #   end
+    # end
+    # def self.attr_reader(*args)
+    #   args.each do |arg|
+    #     self.class_eval("def #{arg};@#{arg};end")
+    #   end
+    # end
+    # def self.attr_writer(*args)
+    #   args.each do |arg|
+    #     self.class_eval("def #{arg};@#{arg};end")
+    #     self.class_eval("def #{arg}=(val);@#{arg}=val;end")
+    #   end
+    # end
+  
+    def self.attr_accessor(*names)
+      super(*names)
+      add(:attr_accessor, names)
+    end
+
+    def self.attr_reader(*names)
+      super(*names)
+      add(:attr_reader, names)
+    end
+
+    def self.attr_writer(*names)
+      super(*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?
+
+      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