k_domain 0.0.20 → 0.0.23

data/lib/k_domain/schemas/rails_structure.rb

@@ -8,26 +8,26 @@ module KDomain
         attribute :block?                     , Types::Strict::String
       end
 
-      class BaseType < Dry::Struct
-        attribute :name?                      , Types::Strict::String
+      class NameOptsType < Dry::Struct
+        attribute :name?                      , Types::Strict::String | Types::Strict::Bool
         attribute :opts?                      , Types::Strict::Hash
         attribute :block?                     , Types::Strict::String.optional.default(nil)
       end
 
-      class Scope < KDomain::Schemas::RailsStructure::BaseType
+      class OptsType < Dry::Struct
+        attribute :opts?                      , Types::Strict::Hash
       end
 
-      class BelongsTo < KDomain::Schemas::RailsStructure::BaseType
-      end
+      # Model Behaviours
+      class Scope                 < KDomain::Schemas::RailsStructure::NameOptsType; end
 
-      class HasOne < KDomain::Schemas::RailsStructure::BaseType
-      end
+      class BelongsTo             < KDomain::Schemas::RailsStructure::NameOptsType; end
 
-      class HasMany < KDomain::Schemas::RailsStructure::BaseType
-      end
+      class HasOne                < KDomain::Schemas::RailsStructure::NameOptsType; end
 
-      class HasAndBelongsToMany < KDomain::Schemas::RailsStructure::BaseType
-      end
+      class HasMany               < KDomain::Schemas::RailsStructure::NameOptsType; end
+
+      class HasAndBelongsToMany   < KDomain::Schemas::RailsStructure::NameOptsType; end
 
       class Validate < Dry::Struct
         attribute :names?                     , Types::Array.of(Types::Strict::String)
@@ -35,10 +35,10 @@ module KDomain
         attribute :block?                     , Types::Strict::String.optional.default(nil)
       end
 
-      class Validates < KDomain::Schemas::RailsStructure::BaseType
+      class Validates < KDomain::Schemas::RailsStructure::NameOptsType
       end
 
-      class Behaviours < Dry::Struct
+      class ModelBehaviours < 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)
@@ -76,15 +76,95 @@ module KDomain
         attribute :exist                      , Types::Strict::Bool
         attribute :state                      , Types::Strict::String
         attribute :code                       , Types::Strict::String
-        attribute :behaviours?                , KDomain::Schemas::RailsStructure::Behaviours
+        attribute :behaviours?                , KDomain::Schemas::RailsStructure::ModelBehaviours
         attribute :functions?                 , KDomain::Schemas::RailsStructure::Functions
       end
 
+      # Controller Behaviours
+      class AfterAction                           < KDomain::Schemas::RailsStructure::NameOptsType; end
+
+      class AroundAction                          < KDomain::Schemas::RailsStructure::NameOptsType; end
+
+      class BeforeAction                          < KDomain::Schemas::RailsStructure::NameOptsType; end
+
+      # rubocop:disable Naming/ClassAndModuleCamelCase
+      class Prepend_beforeAction                  < KDomain::Schemas::RailsStructure::NameOptsType; end
+
+      class Skip_beforeAction                     < KDomain::Schemas::RailsStructure::NameOptsType; end
+      # rubocop:enable Naming/ClassAndModuleCamelCase
+
+      class BeforeFilter                          < KDomain::Schemas::RailsStructure::NameOptsType; end
+
+      class SkipBeforeFilter                      < KDomain::Schemas::RailsStructure::NameOptsType; end
+
+      class Layout                                < KDomain::Schemas::RailsStructure::NameOptsType; end
+
+      class HttpBasicAuthenticateWith             < KDomain::Schemas::RailsStructure::OptsType; end
+
+      class ProtectFromForgery                    < KDomain::Schemas::RailsStructure::OptsType; end
+
+      class RescueFrom < Dry::Struct
+        attribute :type                           , Types::Strict::String
+      end
+
+      class HelperMethod < Dry::Struct
+        attribute :names                          , Types::Strict::Array.of(Types::Strict::String)
+      end
+
+      class Helper < Dry::Struct
+        attribute :name                           , Types::Strict::String
+      end
+
+      class ControllerBehaviours < Dry::Struct
+        attribute :class_name?                    , Types::Strict::String
+        attribute :after_action?                  , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::AfterAction)
+        attribute :around_action?                 , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::AroundAction)
+        attribute :before_action?                 , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::BeforeAction)
+        attribute :prepend_before_action?         , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::Prepend_beforeAction)
+        attribute :skip_before_action?            , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::Skip_beforeAction)
+        attribute :before_filter?                 , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::BeforeFilter)
+        attribute :skip_before_filter?            , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::SkipBeforeFilter)
+        attribute :layout?                        , KDomain::Schemas::RailsStructure::Layout
+        attribute :http_basic_authenticate_with?  , KDomain::Schemas::RailsStructure::OptsType
+        attribute :protect_from_forgery?          , KDomain::Schemas::RailsStructure::OptsType
+
+        attribute :rescue_from?                   , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::RescueFrom)
+        attribute :helper_method?                 , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::HelperMethod)
+        attribute :helper?                        , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::Helper)
+      end
+
+      class ControllerActions < Dry::Struct
+        attribute :route_name?                    , Types::Strict::String
+        attribute :action?                        , Types::String.optional
+        attribute :uri_path?                      , Types::String
+        attribute :mime_match?                    , Types::String
+        attribute :verbs?                         , Types.Array(Types::Verb)
+      end
+
       class Controller < Dry::Struct
+        attribute :name                       , Types::String
+        attribute :path                       , Types::String
+        attribute :namespace                  , Types::String
+        attribute :file                       , Types::String
+        attribute :exist                      , Types::Bool
+        attribute :full_file                  , Types::String
+        attribute :behaviours?                , KDomain::Schemas::RailsStructure::ControllerBehaviours
+        attribute :functions?                 , KDomain::Schemas::RailsStructure::Functions
+        attribute :actions?                   , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::ControllerActions)
       end
 
       attribute :models                       , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::Model)
       attribute :controllers                  , Types::Strict::Array.of(KDomain::Schemas::RailsStructure::Controller)
+
+      def find_controller(path)
+        path = path.to_s
+        controllers.find { |controller| controller.path.to_s == path }
+      end
+
+      def find_model(name)
+        name = name.to_s
+        models.find { |model| model.model_name.to_s == name }
+      end
     end
   end
 end

data/lib/k_domain/version.rb

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

data/lib/k_domain.rb

@@ -11,8 +11,7 @@ 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'
+require 'k_domain/rails_code_extractor/_'
 
 # # This is useful if you want to initialize structures via Hash
 # class SymbolizeStruct < Dry::Struct

data/templates/custom/action_controller.rb

@@ -0,0 +1,36 @@
+module ActionController
+  class Base
+    def self.require(require)
+      add(:require, require)
+    end
+    # def self.rescue_from(type)#, &block)
+    #   # block_source = nil
+    #   # block_source = lambda_source(block, 'default_scope') if block_given?
+
+    #   add(:rescue_from, {
+    #         type: type#,
+    #         # block: block_source
+    #       })
+    # end
+    # def self.helper_method(*names)
+    #   add(:helper_method, {
+    #         names: names
+    #       })
+    # end
+    # def self.helper(name)
+    #   add(:helper, {
+    #         name: name
+    #       })
+    # end
+    # def self.http_basic_authenticate_with(**opts)
+    #   add(:http_basic_authenticate_with, {
+    #         opts: opts
+    #       })
+    # end
+    # def self.protect_from_forgery(**opts)
+    #   add(:protect_from_forgery, {
+    #         opts: opts
+    #       })
+    # end
+  end
+end

data/templates/custom/controller_interceptors.rb

@@ -0,0 +1,78 @@
+class Rails
+  def self.env; end
+
+  def self.application
+    OpenStruct.new(
+      secrets: OpenStruct.new(
+        credentials_secret_key: Base64.encode64('ABC'),
+        aws_secret_access_key: Base64.encode64('ABC')
+      )
+    )
+  end
+end
+class RegionConfig
+  def self.require_value(*_p, **_o, &block); end
+end
+
+class ApplicationController < ActionController::Base
+end
+
+module Admin
+  class BaseController < ActionController::Base
+  end
+end
+
+module Api
+  module V1
+    class BaseController < ActionController::Base
+    end
+  end
+end
+
+module Enterprises
+  class BaseController < ActionController::Base
+  end
+end
+
+module Portal
+  class BaseController < ApplicationController
+  end
+end
+
+module ActiveRecord
+  class RecordNotFound
+  end
+end
+
+module Aws
+  class Credentials
+    def initialize(*_p, **_o, &block); end
+  end
+  module S3
+    class Client
+      def initialize(*_p, **_o, &block); end
+    end
+  end
+end
+
+module Devise
+  class SessionsController < ActionController::Base
+  end
+  class Mapping
+    def self.find_scope!(*_p, **_o); end
+  end
+end
+
+module Respondable; end
+module ContactUpdateable; end
+module SalesRepUpdateable; end
+module MIME; end
+module MaterialIconsHelper; end
+module LocationUpdateable; end
+module WantedByUpdateable; end
+module FollowUpUpdateable; end
+module EstimateArchiveUpdateable; end
+module ContextContactUpdateable; end
+module ProofDateUpdateable; end
+module PoUpdateable; end
+module SalesRepUpdateable; end

data/templates/custom/model_interceptors.rb

@@ -0,0 +1,71 @@
+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
+
+class Thread
+  def initialize(*_p, **_o, &block); end
+end
+
+class ApplicationRecord < ActiveRecord::Base
+end
+
+class Email < ActiveRecord::Base
+  def self.ses_send(*_p, **_o); end
+end
+
+module Emails
+  class Task
+    def new_task(*_p, **_o); end
+  end
+  class Salesrep
+    def change_sales_rep(*_p, **_o); end
+  end
+end
+
+module EstimateConvertable; end
+module ApiLoggable; end
+module Excludable; end
+module Bookmarkable; end
+module Categorizable; end
+module PgSearch; end
+module Excludable; end
+module JsonbStore; 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

data/templates/load_schema.rb

@@ -1,6 +1,7 @@
 class LoadSchema
   attr_reader :schema
 
+  # XMEN
   def initialize
     @unique_keys = {}
     @current_table = nil
@@ -9,6 +10,7 @@ class LoadSchema
       tables: [],
       foreign_keys: [],
       indexes: [],
+      views: [],
       meta: {
         rails: @rails_version,
         db_info: {
@@ -131,6 +133,11 @@ class LoadSchema
     add_index(name, fields, **opts)
   end
 
+  def create_view(name, **opts)
+    row = { name: name, **opts }
+    schema[:views] << row
+    add_unique_keys(row.keys, type: :views)
+  end
 
   def add_foreign_key(left_table, right_table, **opts)
     # puts "add_foreign_key(#{left_table}, #{right_table})"

data/templates/old_printspeek_schema copy.rb

@@ -0,0 +1,231 @@
+# Store the raw schema for the tables that are used in the original PrintSpeak database
+class SchemaPrintspeak
+  def self.instance
+    @instance ||= SchemaPrintspeak.new
+  end
+
+  attr_accessor :tables
+
+  def initialize
+    @tables = []
+    @current_table = nil
+    load_tables
+  end
+  private
+
+  def add_table(table)
+    @tables.push(table)
+    @current_table = table
+  end
+
+  def add_index(_table_name, columns, **opts)
+    @current_table[:indexes] = [] if @current_table[:indexes].nil?
+
+    @current_table[:indexes].push({columns: columns}.merge(opts))
+  end
+
+  # ----------------------------------------------------------------------
+  # Inject start
+  # original file: {{source_file}}
+  # ----------------------------------------------------------------------
+  def load_tables
+{{rails_schema}}
+  end
+
+
+  def write_json(file)
+    schema[:meta][:rails] = @rails_version
+    File.write(file, JSON.pretty_generate(schema))
+  end
+
+  # This is the rails timestamp and will be replaced by the action rails version
+  def load(version:)
+    start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    # puts 'about to load'
+    yield if block_given?
+
+    schema[:meta][:rails] = @rails_version
+
+    sort
+    # code to time
+
+    # log.kv 'extensions', schema[:db_info][:extensions].length
+    # log.kv 'tables', schema[:tables].length
+    # log.kv 'indexes', schema[:indexes].length  
+    # # a low foreign_keys count is indicative of not using SQL referential integrity
+    # log.kv 'foreign_keys', schema[:foreign_keys].length
+    # log.kv 'Time Taken', (finish - start)
+
+    # puts schema[:db_info][:extensions]
+    # print_unique_keys(type: :foreign_keys, title: 'unique options for foreign_keys')
+    # print_unique_keys(type: :columns, title: 'unique options for columns')
+    # print_unique_keys(type: :fields, category: :integer , title: 'unique options for column - integer')
+    # print_unique_keys(type: :fields, category: :decimal , title: 'unique options for column - decimal')
+    # print_unique_keys(type: :fields, category: :string  , title: 'unique options for column - string')
+    # print_unique_keys(type: :fields, category: :datetime, title: 'unique options for column - datetime')
+    # print_unique_keys(type: :fields, category: :date    , title: 'unique options for column - date')
+    # print_unique_keys(type: :fields, category: :text    , title: 'unique options for column - text')
+    # print_unique_keys(type: :fields, category: :boolean , title: 'unique options for column - boolean')
+    # print_unique_keys(type: :fields, category: :jsonb   , title: 'unique options for column - jsonb')
+    # print_unique_keys(type: :fields, category: :hstore  , title: 'unique options for column - hstore')
+    # print_unique_keys(type: :fields, category: :float   , title: 'unique options for column - float')
+  end
+
+  def enable_extension(name)
+    # puts "enable_extension(#{name})"
+    schema[:meta][:db_info][:extensions] << name
+  end
+
+  def create_table(name, **opts)
+    id = opts[:id]
+    primary_key = opts[:primary_key] || (id == false ? nil : "id")
+    primary_key_type = if id == false
+                         nil
+                       elsif id.nil?
+                         "bigint"
+                       else
+                         id
+                       end
+
+    @current_table = {
+      name: name,
+      primary_key: primary_key,                           # infer the actual value that should be in the database
+      primary_key_type: primary_key_type,                 # infer the actual value that should be in the database
+      columns: [],
+      indexes: [],
+      rails_schema: {                                     # as reported by the rails schema
+        primary_key: opts[:primary_key],
+        id: id,
+        force: opts[:force]
+      }
+    }
+    # schema[:tables][name] = @current_table
+    schema[:tables] << @current_table
+    
+    yield(self) if block_given?
+  end
+
+  def add_field(name, type, **opts)
+    # puts "add_field(#{name}, #{type})"
+    row = { name: name, type: type, **opts }
+    @current_table[:columns] << row
+
+    add_unique_keys(row.keys, type: :columns)
+    add_unique_keys(row.keys, type: :fields, category: type)
+  end
+
+  def add_index(name, fields, **opts)
+    # puts "add_index(#{name})"
+    row = { name: name, fields: fields, **opts }
+    @current_table[:indexes] << row
+    schema[:indexes] << row
+    add_unique_keys(row.keys, type: :indexes)
+  end
+
+  # This method was introduced onto the schema in rails 5
+  def index(fields, **opts)
+    @rails_version = 5
+    name = opts[:name]
+    opts.delete(:name)
+    add_index(name, fields, **opts)
+  end
+
+  def create_view(name, **opts)
+    row = { name: name, **opts }
+    schema[:views] << row
+    add_unique_keys(row.keys, type: :views)
+  end
+
+  def add_foreign_key(left_table, right_table, **opts)
+    # puts "add_foreign_key(#{left_table}, #{right_table})"
+    row = { left: left_table, right: right_table, **opts }
+    schema[:foreign_keys] << row
+    add_unique_keys(row.keys, type: :foreign_keys)
+  end
+
+  def add_unique_keys(keys, type:, category: nil)
+    key = [type, category, keys.join('-')].compact.join('|')
+    return if @unique_keys.key?(key)
+
+    @unique_keys[key] = key
+    schema[:meta][:unique_keys] << { type: type, category: category, key: keys.join(','), keys: keys }
+  end
+
+  def print_unique_keys(type:, category: nil, title: )
+    log.section_heading(title)
+
+    filter_key_infos = schema[:meta][:unique_keys].select { |key_info| key_info[:type] == type && (category.nil? || key_info[:category] == category) }
+
+    # log.kv 'all', filter_key_infos.flat_map { |key_info| key_info[:keys] }.uniq, 50
+
+    filter_key_infos.each do |key_info|
+      log.kv key_info[:key], key_info[:keys], 50
+    end
+  end
+
+  def integer(name, **opts)
+    add_field(name, :integer, **opts)
+  end
+
+  def bigint(name, **opts)
+    add_field(name, :bigint, **opts)
+  end
+
+  def decimal(name, **opts)
+    add_field(name, :decimal, **opts)
+  end
+
+  def string(name, **opts)
+    add_field(name, :string, **opts)
+  end
+
+  def datetime(name, **opts)
+    add_field(name, :datetime, **opts)
+  end
+
+  def date(name, **opts)
+    add_field(name, :date, **opts)
+  end
+
+  def text(name, **opts)
+    add_field(name, :text, **opts)
+  end
+
+  def boolean(name, **opts)
+    add_field(name, :boolean, **opts)
+  end
+
+  def jsonb(name, **opts)
+    add_field(name, :jsonb, **opts)
+  end
+
+  def hstore(name, **opts)
+    add_field(name, :hstore, **opts)
+  end
+
+  def float(name, **opts)
+    add_field(name, :float, **opts)
+  end
+
+  def sort
+    schema[:indexes].sort_by! { |i| i[:name] }
+    schema[:tables].each { |table| table[:indexes].sort_by! { |i| i[:name] } }
+
+    # Insert a key that represents all unique keys, and then sort
+    unique_keys_per_group = schema[:meta][:unique_keys]
+      .group_by { |key_info| [key_info[:type], key_info[:category]] }
+      .map do |group, values|
+        all_keys = values.flat_map { |key_info| key_info[:keys] }.uniq
+        { 
+          type: group[0],
+          category: group[01],
+          key: 'all',
+          keys: all_keys
+        }
+      end
+
+    schema[:meta][:unique_keys].concat(unique_keys_per_group)
+    schema[:meta][:unique_keys].sort! { |a,b| ([a[:type], a[:category],a[:key]] <=> [b[:type], b[:category],b[:key]]) }
+  end
+
+end