k_domain 0.0.14 → 0.0.23

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# Locate rails model files
+class Step6RailsStructureModels < KDomain::DomainModel::Step
+  def call
+    raise 'Rails model path not supplied' unless opts[:model_path]
+
+    # THIS IS NOT WORKING YET
+    self.rails_structure_models = rails_resource_models.map do |resource|
+      process_resource(OpenStruct.new(resource))
+    end
+
+    attach_behavior_and_functions
+  end
+
+  private
+
+  def process_resource(resource)
+    {
+      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: {}
+    }
+
+    # return @model unless  resource.exist
+
+    # @model[:behaviours] = extract_behavior(resource.file)
+    # @model[:functions] = extract_functions(resource.file)
+
+    # @model
+  end
+
+  def attach_behavior_and_functions
+    rails_structure_models.select { |model| model[:exist] }.each do |model|
+      model[:behaviours] = extract_behavior(model[:file])
+      klass_name = model[:behaviours][:class_name]
+      model[:functions] = extract_functions(klass_name)
+    end
+  end
+
+  def extract_behavior(file)
+    extractor.extract(file)
+    extractor.model
+  end
+
+  def extract_functions(klass_name)
+    klass = klass_type(klass_name)
+
+    return {} if klass.nil?
+
+    Peeky.api.build_class_info(klass.new).to_h
+  rescue StandardError => e
+    log.exception(e)
+  end
+
+  def klass_type(klass_name)
+    Module.const_get(klass_name.classify)
+  rescue NameError
+    puts ''
+    puts klass_name
+    puts klass_name.classify
+    puts klass_name.pluralize
+    puts 'Trying the pluralized version: '
+    Module.const_get(klass_name.pluralize)
+  end
+
+  def extractor
+    @extractor ||= KDomain::RailsCodeExtractor::ExtractModel.new(shim_loader)
+  end
+
+  def shim_loader
+    return opts[:shim_loader] if !opts[:shim_loader].nil? && opts[:shim_loader].is_a?(KDomain::RailsCodeExtractor::ShimLoader)
+
+    shim_loader = KDomain::RailsCodeExtractor::ShimLoader.new
+    # Shims to attach generic class_info writers
+    shim_loader.register(:attach_class_info           , KDomain::Gem.resource('templates/ruby_code_extractor/attach_class_info.rb'))
+    shim_loader.register(:behaviour_accessors         , KDomain::Gem.resource('templates/ruby_code_extractor/behaviour_accessors.rb'))
+
+    # Shims to support standard active_record DSL methods
+    shim_loader.register(:active_record               , KDomain::Gem.resource('templates/rails/active_record.rb'))
+
+    # Shims to support application specific [module, class, method] implementations for suppression and exception avoidance
+    shim_loader
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# Locate rails controller files
+class Step7RailsStructureControllers < KDomain::DomainModel::Step
+  attr_accessor :controllers
+
+  def call
+    raise 'Rails controller path not supplied' unless opts[:controller_path]
+
+    @controllers = {}
+
+    rails_resource_routes.map do |route|
+      process_route(OpenStruct.new(route))
+    end
+
+    self.rails_structure_controllers = controllers.keys.map { |key| controllers[key] }
+
+    attach_behavior_and_functions
+  end
+
+  private
+
+  def process_route(route)
+    if new_controller?(route)
+      new_controller(route)
+    else
+      controller = @controllers[route[:controller_file]]
+      controller[:actions] << new_action(route)
+    end
+  end
+
+  def new_controller?(route)
+    !controllers.key?(route[:controller_file])
+  end
+
+  def new_controller(route)
+    controllers[route[:controller_file]] = {
+      name: route[:controller_name],
+      path: route[:controller_path],
+      namespace: route[:controller_namespace],
+      file: route[:controller_file],
+      exist: route[:controller_exist],
+      full_file: route[:file],
+      behaviours: {},
+      functions: {},
+      actions: [new_action(route)]
+    }
+  end
+
+  def new_action(route)
+    {
+      route_name: route[:name],
+      action: route[:action],
+      uri_path: route[:uri_path],
+      mime_match: route[:mime_match],
+      verbs: route[:verbs]
+    }
+  end
+
+  def attach_behavior_and_functions
+    rails_structure_controllers.select { |controller| controller[:exist] }.each do |controller|
+      unless File.exist?(controller[:full_file])
+        log.error 'Controller apparently exists but no file found, this means that you need re-run rake routes'
+        puts controller[:full_file]
+        next
+      end
+      controller[:behaviours] = extract_behavior(controller[:full_file])
+      klass_name = controller[:behaviours][:class_name]
+      controller[:functions] = extract_functions(klass_name)
+    end
+  end
+
+  def extract_behavior(file)
+    # puts file
+    extractor.extract(file)
+    extractor.controller
+  end
+
+  def extractor
+    @extractor ||= KDomain::RailsCodeExtractor::ExtractController.new(shim_loader)
+  end
+
+  def shim_loader
+    return opts[:shim_loader] if !opts[:shim_loader].nil? && opts[:shim_loader].is_a?(KDomain::RailsCodeExtractor::ShimLoader)
+
+    shim_loader = KDomain::RailsCodeExtractor::ShimLoader.new
+    # Shims to attach generic class_info writers
+    shim_loader.register(:attach_class_info           , KDomain::Gem.resource('templates/ruby_code_extractor/attach_class_info.rb'))
+    shim_loader.register(:behaviour_accessors         , KDomain::Gem.resource('templates/ruby_code_extractor/behaviour_accessors.rb'))
+
+    # Shims to support stand rails controller DSL methods
+    shim_loader.register(:action_controller           , KDomain::Gem.resource('templates/rails/action_controller.rb'))
+
+    # Shims to support application specific [module, class, method] implementations for suppression and exception avoidance
+    # shim_loader.register(:app_action_controller       , KDomain::Gem.resource('templates/advanced/action_controller.rb'))
+    # shim_loader.register(:app_controller_interceptors , KDomain::Gem.resource('templates/advanced/controller_interceptors.rb'))
+    shim_loader
+  end
+
+  def extract_functions(klass_name)
+    klass = Module.const_get(klass_name.classify)
+
+    class_info = Peeky.api.build_class_info(klass.new)
+
+    class_info.to_h
+  rescue StandardError => e
+    log.exception(e)
+  end
+end

data/lib/k_domain/domain_model/transform_steps/{step3_attach_columns.rb → step8_domain_columns.rb}

@@ -1,67 +1,36 @@
 # frozen_string_literal: true
 
-# Attach columns to models
-class Step3AttachColumns < KDomain::DomainModel::Step
-  attr_accessor :table
+#  columns to models
+class Step8DomainColumns < KDomain::DomainModel::Step
+  attr_reader :domain_model
+  attr_reader :domain_column
+  attr_reader :rails_model
   attr_reader :column_name
   attr_reader :column_symbol
 
   def call
-    build_columns
+    enrich_columns
   end
 
-  def build_columns
+  def enrich_columns
+    # .select {|m| m[:name] == 'app_user'}
     domain_models.each do |model|
-      @table = find_table_for_model(model)
-      columns = columns(table[:columns])
-      columns = insert_primary_key(model, columns)
-      model[:columns] = columns
-    end
-  end
-
-  def column_data(name)
-    @column_name   = name
-    @column_symbol = name.to_sym
-    {
-      name: name,
-      name_plural: name.pluralize,
-      type: nil,
-      precision: nil,
-      scale: nil,
-      default: nil,
-      null: nil,
-      limit: nil,
-      array: nil
-    }
-  end
-
-  def columns(db_columns)
-    db_columns.map do |db_column|
-      column = column_data(db_column[:name]).merge(
-        type: check_type(db_column[:type]),
-        precision: db_column[:precision],
-        scale: db_column[:scale],
-        default: db_column[:default],
-        null: db_column[:null],
-        limit: db_column[:limit],
-        array: db_column[:array]
-      )
-
-      expand_column(column)
+      @domain_model = model
+      # this will be nil if there is no rails model code
+      @rails_model = find_rails_structure_models(domain_model[:name])
+
+      # log.warn domain_model[:name]
+      domain_model[:columns].each do |column|
+        @domain_column = column
+        @column_name = column[:name]
+        @column_symbol = column[:name].to_sym
+
+        attach_foreign_key
+        column[:structure_type] = structure_type
+      end
     end
   end
 
-  def insert_primary_key(model, columns)
-    return columns unless model[:pk][:exist]
-
-    column = column_data('id').merge(
-      type: check_type(model[:pk][:type])
-    )
-
-    columns.unshift(expand_column(column))
-    columns
-  end
-
   def expand_column(column)
     foreign_table = lookup_foreign_table(column_name)
     is_foreign = !foreign_table.nil?
@@ -76,22 +45,6 @@ class Step3AttachColumns < KDomain::DomainModel::Step
                  })
   end
 
-  def check_type(type)
-    type = type.to_sym if type.is_a?(String)
-
-    return type if %i[string integer bigint bigserial boolean float decimal datetime date hstore text jsonb].include?(type)
-
-    if type.nil?
-      guard('nil type detected for db_column[:type]')
-
-      return :string
-    end
-
-    guard("new type detected for db_column[:type] - #{type}")
-
-    camel.parse(type.to_s).downcase
-  end
-
   def lookup_foreign_table(column_name)
     foreign_table = find_foreign_table(table[:name], column_name)
 
@@ -104,7 +57,7 @@ class Step3AttachColumns < KDomain::DomainModel::Step
       table_name_plural = table_name.pluralize
 
       if table_name_exist?(table_name_plural.to_s)
-        investigate(step: :step3_attach_columns,
+        investigate(step: :step8_columns,
                     location: :lookup_foreign_table,
                     key: column_name,
                     message: "#{@table[:name]}.#{column_name} => #{table_name_plural} - Relationship not found in DB, so have inferred this relationship. You may want to check that this relation is correct")
@@ -112,7 +65,7 @@ class Step3AttachColumns < KDomain::DomainModel::Step
         return table_name
       end
 
-      investigate(step: :step3_attach_columns,
+      investigate(step: :step8_columns,
                   location: :lookup_foreign_table,
                   key: column_name,
                   message: "#{@table[:name]}.#{column_name} => #{table_name_plural} - Table not found for a column that looks like foreign_key")
@@ -121,11 +74,25 @@ class Step3AttachColumns < KDomain::DomainModel::Step
     nil
   end
 
+  def attach_foreign_key
+    return if rails_model.nil? || rails_model[:behaviours].nil? || rails_model[:behaviours][:belongs_to].nil?
+
+    foreign = rails_model[:behaviours][:belongs_to].find { |belong| belong[:opts][:foreign_key].to_sym == domain_column[:name].to_sym }
+
+    return unless foreign
+
+    # NEED TO PRE-LOAD the table, table_plural and model
+    domain_column[:foreign_table] = 'xxx1'
+    domain_column[:foreign_table_plural] = 'xxx3'
+    domain_column[:foreign_model] = 'xxx2'
+  end
+
   # Need some configurable data dictionary where by
   # _token can be setup on a project by project basis
-  def structure_type(is_foreign)
-    return :foreign_key         if is_foreign
-    return :primary_key         if column_symbol == :id
+  def structure_type
+    return :primary_key         if domain_model[:pk][:name] == column_name
+    return :foreign_key         if domain_column[:foreign_table]
+
     return :timestamp           if column_symbol == :created_at || column_symbol == :updated_at
     return :timestamp           if column_symbol == :created_at || column_symbol == :updated_at
     return :deleted_at          if column_symbol == :deleted_at

data/lib/k_domain/rails_code_extractor/_.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative './shim_loader'
+require_relative './extract_model'
+require_relative './extract_controller'

data/lib/k_domain/rails_code_extractor/extract_controller.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# Takes a Rails controller and extracts DSL behaviours and custom functions (instance, class and private methods)
+module KDomain
+  module RailsCodeExtractor
+    class ExtractController
+      include KLog::Logging
+
+      attr_reader :shims_loaded
+      attr_reader :controller
+
+      def initialize(load_shim)
+        @load_shim = load_shim
+        @shims_loaded = false
+      end
+
+      def extract(file)
+        load_shims unless shims_loaded
+
+        ActionController.class_info = nil
+        # KDomain::RailsCodeExtractor.reset
+
+        load_retry(file, 10, nil)
+      rescue StandardError => e
+        log.exception(e)
+      end
+
+      private
+
+      def load_shims
+        @load_shim.call
+        @shims_loaded = true
+      end
+
+      # rubocop:disable Security/Eval,Style/EvalWithLocation,Style/DocumentDynamicEvalDefinition,Metrics/AbcSize
+      def load_retry(file, times, last_error)
+        return if times.negative?
+
+        # puts file
+        load(file)
+
+        @controller = ActionController::Base.class_info
+        # @controller = KDomain::RailsCodeExtractor.class_info
+
+        # get_method_info(File.base_name(file))
+      rescue StandardError => e
+        log.kv 'times', times
+        # puts e.message
+        if e.is_a?(NameError) && e.message != last_error&.message
+          log.kv('add module', e.name)
+          eval("module #{e.name}; end")
+          return load_retry(file, times - 1, e)
+        end
+        log.exception(e, style: :short, method_info: method(__callee__))
+      end
+      # rubocop:enable Security/Eval,Style/EvalWithLocation,Style/DocumentDynamicEvalDefinition,Metrics/AbcSize
+    end
+  end
+end

data/lib/k_domain/rails_code_extractor/extract_model.rb

@@ -0,0 +1,69 @@
+# 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 :shims_loaded
+      attr_reader :models
+      attr_reader :model
+
+      def initialize(load_shim)
+        @load_shim = load_shim
+        @shims_loaded = false
+        @models = []
+      end
+
+      def extract(file)
+        load_shims unless shims_loaded
+
+        ActiveRecord.class_info = nil
+
+        load_retry(file, 10, nil)
+      rescue StandardError => e
+        log.exception(e)
+      end
+
+      private
+
+      def load_shims
+        @load_shim.call
+        @shims_loaded = true
+      end
+
+      # rubocop:disable Security/Eval,Style/EvalWithLocation,Style/DocumentDynamicEvalDefinition,Metrics/AbcSize
+      def load_retry(file, times, last_error)
+        return if times.negative?
+
+        load(file)
+
+        @model = ActiveRecord.class_info
+
+        if @model.nil?
+          # puts ''
+          # puts file
+          # puts 'class probably has no DSL methods'
+          @model = {
+            class_name: File.basename(file, File.extname(file)).classify
+          }
+        end
+
+        @models << @model
+
+        # get_method_info(File.base_name(file))
+      rescue StandardError => e
+        log.kv 'times', times
+        # puts e.message
+        if e.is_a?(NameError) && e.message != last_error&.message
+          log.kv('add module', e.name)
+          eval("module #{e.name}; end")
+          return load_retry(file, times - 1, e)
+        end
+        log.exception(e, style: :short, method_info: method(__callee__))
+      end
+      # rubocop:enable Security/Eval,Style/EvalWithLocation,Style/DocumentDynamicEvalDefinition,Metrics/AbcSize
+    end
+  end
+end

data/lib/k_domain/rails_code_extractor/shim_loader.rb

@@ -0,0 +1,30 @@
+# 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 ShimLoader
+      include KLog::Logging
+
+      attr_reader :shim_files
+
+      def initialize
+        @shim_files = []
+      end
+
+      def call
+        # puts shim_files.map { |sf| sf[:file] }
+        shim_files.select { |sf| sf[:exist] }.each { |sf| require sf[:file] }
+      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::Database::Schema.new(data)
+        @data = KDomain::Schemas::Database.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

@@ -11,7 +11,7 @@ module KDomain
       include KLog::Logging
 
       attr_reader :source_file
-      attr_reader :template_file
+      attr_accessor :template_file
       attr_reader :schema_loader
 
       def initialize(source_file)
@@ -24,6 +24,7 @@ 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)
@@ -33,9 +34,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 +69,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/_.rb

@@ -7,9 +7,10 @@ module Types
 end
 
 require_relative 'rails_resource'
+require_relative 'rails_structure'
 require_relative 'investigate'
-require_relative 'database/_'
+require_relative 'database'
 require_relative 'dictionary'
-require_relative 'domain/_'
+require_relative 'domain'
 
 require_relative './domain_model'

data/lib/k_domain/schemas/database.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# KDomain::Schemas::Domain::Column
+# KDomain::Schemas::Domain::Model
+
+module KDomain
+  module Schemas
+    class Database < Dry::Struct
+      class ForeignKey < Dry::Struct
+        attribute :left                 , Types::Strict::String
+        attribute :right                , Types::Strict::String
+        attribute :name?                , Types::Strict::String.optional.default(nil)
+        attribute :on_update?           , Types::Strict::String.optional.default(nil)
+        attribute :on_delete?           , Types::Strict::String.optional.default(nil)
+        attribute :column?              , Types::Strict::String.optional.default(nil)
+      end
+
+      class Index < Dry::Struct
+        attribute :name                 , Types::Strict::String
+        attribute :fields               , Types::Nominal::Any.optional.default('xxxxx1')
+        attribute :using                , Types::Nominal::String
+        attribute :order?               , Types::Nominal::Hash
+        attribute :where?               , Types::Nominal::Any.optional.default(nil)
+        attribute :unique?              , Types::Nominal::Any.optional.default(nil)
+      end
+
+      class View < Dry::Struct
+        attribute :name                 , Types::Strict::String
+        attribute :materialized         , Types::Strict::Bool
+        attribute :sql_definition       , Types::Nominal::String
+      end
+
+      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::Schemas::Database::Table::Column)
+        attribute :indexes                , Types::Strict::Array.of(KDomain::Schemas::Database::Index)
+        attribute :rails_schema           , KDomain::Schemas::Database::Table::RailsSchema
+      end
+
+      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::Schemas::Database::DbInfo
+        attribute :unique_keys          , Types::Strict::Array.of(KDomain::Schemas::Database::UniqueKey)
+      end
+
+      attribute :tables               , Types::Strict::Array.of(KDomain::Schemas::Database::Table)
+      attribute :foreign_keys?        , Types::Strict::Array.of(KDomain::Schemas::Database::ForeignKey)
+      attribute :indexes?             , Types::Strict::Array.of(KDomain::Schemas::Database::Index)
+      attribute :views?               , Types::Strict::Array.of(KDomain::Schemas::Database::View)
+      attribute :meta                 , KDomain::Schemas::Database::Meta
+    end
+  end
+end