k_domain 0.0.14 → 0.0.23

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: k_domain
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.23
 platform: ruby
 authors:
 - David Cruwys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-02 00:00:00.000000000 Z
+date: 2021-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -74,6 +74,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".builders/config/_.rb"
+- ".builders/setup.rb"
 - ".github/workflows/main.yml"
 - ".gitignore"
 - ".rspec"
@@ -99,26 +101,26 @@ files:
 - lib/k_domain/domain_model/transform.rb
 - lib/k_domain/domain_model/transform_steps/_.rb
 - lib/k_domain/domain_model/transform_steps/step.rb
-- lib/k_domain/domain_model/transform_steps/step1_attach_db_schema.rb
-- lib/k_domain/domain_model/transform_steps/step2_attach_models.rb
-- 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/step1_db_schema.rb
+- lib/k_domain/domain_model/transform_steps/step20_dictionary.rb
+- lib/k_domain/domain_model/transform_steps/step2_domain_models.rb
+- lib/k_domain/domain_model/transform_steps/step4_rails_resource_models.rb
+- lib/k_domain/domain_model/transform_steps/step5_rails_resource_routes.rb
+- lib/k_domain/domain_model/transform_steps/step6_rails_structure_models.rb
+- lib/k_domain/domain_model/transform_steps/step7_rails_structure_controllers.rb
+- lib/k_domain/domain_model/transform_steps/step8_domain_columns.rb
+- lib/k_domain/rails_code_extractor/_.rb
+- lib/k_domain/rails_code_extractor/extract_controller.rb
+- lib/k_domain/rails_code_extractor/extract_model.rb
+- lib/k_domain/rails_code_extractor/shim_loader.rb
 - lib/k_domain/raw_db_schema/load.rb
 - lib/k_domain/raw_db_schema/transform.rb
 - lib/k_domain/schemas/_.rb
-- lib/k_domain/schemas/database/_.rb
-- lib/k_domain/schemas/database/foreign_key.rb
-- lib/k_domain/schemas/database/index.rb
-- lib/k_domain/schemas/database/schema.rb
-- lib/k_domain/schemas/database/table.rb
+- lib/k_domain/schemas/database.rb
 - lib/k_domain/schemas/dictionary.rb
+- lib/k_domain/schemas/domain.rb
 - lib/k_domain/schemas/domain/_.rb
-- lib/k_domain/schemas/domain/domain.rb
 - lib/k_domain/schemas/domain/erd_file.rb
-- lib/k_domain/schemas/domain/models/column.rb
-- lib/k_domain/schemas/domain/models/model.rb
 - lib/k_domain/schemas/domain/old/belongs_to.rb
 - lib/k_domain/schemas/domain/old/column_old.rb
 - lib/k_domain/schemas/domain/old/domain_statistics.rb
@@ -138,8 +140,19 @@ files:
 - lib/k_domain/schemas/domain_model.rb
 - lib/k_domain/schemas/investigate.rb
 - lib/k_domain/schemas/rails_resource.rb
+- lib/k_domain/schemas/rails_structure.rb
 - lib/k_domain/version.rb
+- templates/custom/action_controller.rb
+- templates/custom/controller_interceptors.rb
+- templates/custom/model_interceptors.rb
 - templates/load_schema.rb
+- templates/old_printspeek_schema copy.rb
+- templates/old_printspeek_schema.rb
+- templates/rails/action_controller.rb
+- templates/rails/active_record.rb
+- templates/ruby_code_extractor/attach_class_info.rb
+- templates/ruby_code_extractor/behaviour_accessors.rb
+- templates/simple/controller_interceptors.rb
 homepage: http://appydave.com/gems/k-domain
 licenses:
 - MIT
@@ -162,7 +175,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.7
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: K Domain builds complex domain schemas by combining the database schema with

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

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-# Loop through the db_schema tables and build up a
-# basic model for each table
-class Step2AttachModels < KDomain::DomainModel::Step
-  # Map database schema to domain model
-  def call
-    raise 'ERD path not supplied' if opts[:erd_path].nil?
-
-    # Schema is re-shaped into a format designed for domain modeling
-    domain[:models] = database_tables.map { |table| model(table) }
-  end
-
-  def model(table)
-    table_name = table[:name].to_s
-    model_name = table_name.singularize
-
-    {
-      name: model_name,
-      name_plural: table_name, # need to check if this is correct as I know it is wrong for account_history_datum
-      table_name: table_name,
-      pk: primary_key(table),
-      erd_location: location(table_name, model_name),
-      statistics: {},                                   # Load in future step
-      columns: []                                       # Load in future step
-    }
-  end
-
-  def primary_key(table)
-    {
-      name: table[:primary_key],
-      type: table[:primary_key_type],
-      exist: !table[:primary_key].nil?
-    }
-  end
-
-  # Location of source code
-  def location(table_name, model_name)
-    file_normal = File.join(opts[:erd_path], "#{model_name}.rb")
-    file_custom = File.join(opts[:erd_path], "#{table_name}.rb")
-    file_exist  = true
-    state = []
-
-    if File.exist?(file_normal)
-      file = file_normal
-      state.push(:has_ruby_model)
-    elsif File.exist?(file_custom)
-      file = file_custom
-      state.push(:has_ruby_model)
-      state.push(:nonconventional_name)
-    else
-      file = ''
-      file_exist = false
-    end
-
-    {
-      file: file,
-      exist: file_exist,
-      state: state                      # display_state: state.join(' ')
-    }
-  end
-end

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

@@ -1,454 +0,0 @@
-# frozen_string_literal: true
-
-# Attach source code found in rails model definitions to models
-class Step4AttachErdFiles < KDomain::DomainModel::Step
-  attr_accessor :ruby_code
-
-  # NOTE: This code could be rewritten using monkey patched modules and peak
-  def call
-    domain[:erd_files] = domain_models.map { |model| load_dsl(model) }
-  end
-
-  private
-
-  def reset_dsl
-    @ruby_code = nil
-    @dsl = nil
-  end
-
-  def dsl
-    @dsl ||= {
-      name: '',
-      name_plural: ''
-    }
-  end
-
-  def load_dsl(model)
-    reset_dsl
-
-    dsl[:name]        = model[:name]
-    dsl[:name_plural] = model[:name_plural]
-    dsl[:dsl_file]    = model[:erd_location][:exist] ? model[:erd_location][:file] : ''
-
-    return dsl unless File.exist?(dsl[:dsl_file])
-
-    @ruby_code = File.read(dsl[:dsl_file])
-
-    dsl[:source]  = read_dsl_source
-    dsl[:dsl]     = build_dsl
-    dsl[:todo]    = todo
-
-    dsl
-  end
-
-  def read_dsl_source
-    regex_split_private_public = /(?<public>.+?)(?=\bprivate\b)(?<private>.*)/m
-
-    split_code = regex_split_private_public.match(ruby_code)
-
-    public_code = nil
-    private_code = nil
-
-    if split_code
-      public_code = split_code[:public]
-      private_code = split_code[:private]
-    end
-
-    {
-      ruby: ruby_code,
-      public: public_code,
-      private: private_code,
-      all_methods: grab_methods(public_code, private_code)
-    }
-  end
-
-  def build_dsl
-    return if ruby_code.nil?
-
-    # need to support options as hash instead of options as string in the future
-    {
-      default_scope: grab_default_scope,
-      scopes: grab_scopes,
-      belongs_to: grab_belongs_to,
-      has_one: grab_has_one,
-      has_many: grab_has_many,
-      has_and_belongs_to_many: grab_has_and_belongs_to_many,
-      validate_on: grab_validate,
-      validates_on: grab_validates
-    }
-
-    # ^(?<spaces>\s*)(?<event_type>before_create|before_save|before_destroy|after_create|after_save|after_destroy) (:(?<name>\w*)[, ]?(?<scope>.*)|(?<scope>\{.*?\}.*$))
-  end
-
-  def grab_default_scope
-    regex = /default_scope \{(?<scope>.*?)\}/m
-
-    m = regex.match(ruby_code)
-
-    return "{ #{m[:scope].strip.gsub('\n', '')} }" if m
-
-    nil
-  end
-
-  def grab_scopes
-    entries = []
-    # Start from beginning of line and capture
-    # - number of spaces scope
-    # - name of scope
-    # - value of scope to end of line
-    regex = /^(?<spaces>\s*)scope :(?<name>\w*)[, ]?(?<scope>.*)/
-
-    # rubocop:disable Metrics/BlockLength
-    ruby_code.scan(regex) do
-      m = $LAST_MATCH_INFO
-      spaces = m[:spaces] # .delete("\n")
-      last_lf = spaces.rindex("\n")
-      spaces = last_lf ? spaces[spaces.rindex("\n") + 1..-1] : spaces
-      name = m[:name]
-      scope = m[:scope].strip
-
-      # Found a valid one liner
-      if scope.ends_with?('}') && (scope.scan(/{/).count == scope.scan(/}/).count)
-        scope = escape_single_quote(scope)
-        entries << { name: name, scope: scope }
-      else
-        # Have a multiline scope, lets see if it is cleanly formatted
-
-        start_anchor = "#{spaces}scope :#{name}"
-        end_anchor = "#{spaces}}"
-
-        # log.kv 'spaces', spaces.length
-        # log.kv 'name', name
-        # log.kv 'start_anchor', start_anchor
-        # log.kv 'end_anchor', end_anchor
-
-        start_index = ruby_code.index(/#{start_anchor}/)
-
-        if start_index.nil?
-          log.error("[#{@current_entity[:name]}] could not find [start] anchor index for [#{name}]")
-        else
-          ruby_section = ruby_code[start_index..-1]
-          end_index = ruby_section.index(/^#{end_anchor}/) # Add ^ start of line
-          if end_index.nil?
-            log.error("[#{@current_entity[:name]}] could not find [end] anchor index for [#{name}]")
-          else
-            scope = ruby_section[start_anchor.length + 1..end_index].strip
-            scope = escape_single_quote("#{scope}#{end_anchor}")
-            entries << { name: name, scope: scope }
-          end
-        end
-      end
-    end
-    entries
-  rescue StandardError => e
-    # bin ding.pry
-    puts e.message
-  end
-  # rubocop:enable Metrics/BlockLength
-
-  def grab_belongs_to
-    entries = []
-
-    # Start from beginning of line and capture
-    # - number of spaces before belongs_to
-    # - name of the belongs_to
-    # - value of belongs_to to end of line
-    regex = /^(?<spaces>\s*)belongs_to :(?<name>\w*)[, ]?(?<options>.*)/
-
-    ruby_code.scan(regex) do
-      m = $LAST_MATCH_INFO
-
-      # spaces = m[:spaces] # .delete("\n")
-      # last_lf = spaces.rindex("\n")
-      # spaces = last_lf ? spaces[spaces.rindex("\n") + 1..-1] : spaces
-      name = m[:name]
-
-      options = m[:options]
-                .gsub(':polymorphic => ', 'polymorphic: ')
-                .gsub(':class_name => ', 'class_name: ')
-                .gsub(':foreign_key => ', 'foreign_key: ')
-                .strip
-
-      options = clean_lambda(options)
-
-      entries << { name: name, options: extract_options(options), raw_options: options }
-    end
-    entries
-  rescue StandardError => e
-    # bin ding.pry
-    puts e.message
-  end
-
-  def grab_has_one
-    entries = []
-
-    # Start from beginning of line and capture
-    # - number of spaces before has_one
-    # - name of the has_one
-    # - value of has_one to end of line
-    regex = /^(?<spaces>\s*)has_one :(?<name>\w*)[, ]?(?<options>.*)/
-
-    ruby_code.scan(regex) do
-      m = $LAST_MATCH_INFO
-
-      # spaces = m[:spaces] # .delete("\n")
-      # last_lf = spaces.rindex("\n")
-      # spaces = last_lf ? spaces[spaces.rindex("\n") + 1..-1] : spaces
-      name = m[:name]
-      options = m[:options]
-                .strip
-      # .gsub(':polymorphic => ', 'polymorphic: ')
-      # .gsub(':class_name => ', 'class_name: ')
-      # .gsub(':foreign_key => ', 'foreign_key: ')
-
-      options = clean_lambda(options)
-
-      entries << { name: name, options: extract_options(options), raw_options: options }
-    end
-    entries
-  rescue StandardError => e
-    # bin ding.pry
-    puts e.message
-  end
-
-  def grab_has_many
-    entries = []
-    # Start from beginning of line and capture
-    # - number of spaces before has_many
-    # - name of the has_many
-    # - value of has_many to end of line
-    regex = /^(?<spaces>\s*)has_many :(?<name>\w*)[, ]?(?<options>.*)/
-
-    ruby_code.scan(regex) do
-      m = $LAST_MATCH_INFO
-
-      # spaces = m[:spaces] # .delete("\n")
-      # last_lf = spaces.rindex("\n")
-      # spaces = last_lf ? spaces[spaces.rindex("\n") + 1..-1] : spaces
-      name = m[:name]
-      options = m[:options]
-                .gsub(':dependent => ', 'dependent: ')
-                .gsub(':class_name => ', 'class_name: ')
-                .gsub(':foreign_key => ', 'foreign_key: ')
-                .gsub(':primary_key => ', 'primary_key: ')
-                .strip
-
-      options = clean_lambda(options)
-
-      entries << { name: name, options: extract_options(options), raw_options: options }
-    end
-    entries
-  rescue StandardError => e
-    # bin ding.pry
-    puts e.message
-  end
-
-  def grab_has_and_belongs_to_many
-    entries = []
-    # Start from beginning of line and capture
-    # - number of spaces before has_and_belongs_to_many
-    # - name of the has_and_belongs_to_many
-    # - value of has_and_belongs_to_many to end of line
-    regex = /^(?<spaces>\s*)has_and_belongs_to_many :(?<name>\w*)[, ]?(?<options>.*)/
-
-    ruby_code.scan(regex) do
-      m = $LAST_MATCH_INFO
-
-      # spaces = m[:spaces] # .delete("\n")
-      # last_lf = spaces.rindex("\n")
-      # spaces = last_lf ? spaces[spaces.rindex("\n") + 1..-1] : spaces
-      name = m[:name]
-      options = m[:options]
-                .gsub(':dependent => ', 'dependent: ')
-                .gsub(':class_name => ', 'class_name: ')
-                .gsub(':foreign_key => ', 'foreign_key: ')
-                .gsub(':primary_key => ', 'primary_key: ')
-                .strip
-
-      options = clean_lambda(options)
-
-      entries << { name: name, options: {}, raw_options: options }
-    end
-    entries
-  rescue StandardError => e
-    # bin ding.pry
-    puts e.message
-  end
-
-  def grab_validates
-    entries = []
-    # Start from beginning of line and capture
-    # - number of spaces before validates
-    # - name of the validates
-    # - value of validates to end of line
-    regex = /^(?<spaces>\s*)validates :(?<name>\w*)[, ]?(?<options>.*)/
-
-    ruby_code.scan(regex) do
-      m = $LAST_MATCH_INFO
-
-      # spaces = m[:spaces] # .delete("\n")
-      # last_lf = spaces.rindex("\n")
-      # spaces = last_lf ? spaces[spaces.rindex("\n") + 1..-1] : spaces
-      name = m[:name]
-
-      options = m[:options].strip
-
-      options = clean_lambda(options)
-
-      entries << { name: name, raw_options: options }
-    end
-    entries
-  rescue StandardError => e
-    # bin ding.pry
-    puts e.message
-  end
-
-  def grab_validate
-    entries = []
-    # Start from beginning of line and capture
-    # - number of spaces before validate
-    # - list of methods to call until to end of line
-    # regex = /^(?<spaces>\s*)validate :(?<name>\w*)[, ]?(?<options>.*)/
-    regex = /^(?<spaces>\s*)validate (?<line>:.*)/
-    # puts @current_entity[:name]
-
-    ruby_code.scan(regex) do
-      m = $LAST_MATCH_INFO
-
-      # spaces = m[:spaces] # .delete("\n")
-      # last_lf = spaces.rindex("\n")
-      # spaces = last_lf ? spaces[spaces.rindex("\n") + 1..-1] : spaces
-      line = m[:line]
-
-      entries << { line: line }
-      # puts @current_entity[:validate]
-    end
-    entries
-  rescue StandardError => e
-    # bin ding.pry
-    puts e.message
-  end
-
-  def grab_methods(public_code = ruby_code, private_code = nil)
-    # public_code = ruby_code_public.nil? ? ruby_code : ruby_code_public
-    # private_code = ruby_code_private
-
-    regex = /def (?<method>.*)/
-
-    # log.info(@current_entity[:name])
-
-    public_methods    = parse_methods(:public, public_code&.scan(regex)&.flatten || [])
-    private_methods   = parse_methods(:private, private_code&.scan(regex)&.flatten || [])
-    methods           = (public_methods + private_methods)
-
-    class_methods     = methods.select { |method| method[:class_method] == true }
-
-    all_instance      = methods.select { |method| method[:class_method] == false }
-    instance_public   = all_instance.select { |method| method[:scope] == :public }
-    instance_private  = all_instance.select { |method| method[:scope] == :private }
-
-    {
-      klass: class_methods,
-      instance: all_instance,
-      instance_public: instance_public,
-      instance_private: instance_private
-    }
-  end
-
-  def parse_methods(scope, methods)
-    methods.map do |value|
-      class_method = value.starts_with?('self.')
-      name = class_method ? value[5..-1] : value
-      arguments = nil
-      arguments_index = name.index('(')
-
-      if arguments_index
-        arguments = name[arguments_index..-1]
-        name = name[0..arguments_index - 1]
-      end
-
-      arguments = escape_single_quote(arguments)
-
-      {
-        name: name,
-        scope: scope,
-        class_method: class_method,
-        arguments: arguments&.strip.to_s
-      }
-    end
-  end
-
-  def todo
-    {
-      after_destroy: [], # to do
-      before_save: [], # to do
-      after_save: [], # to do
-      before_create: [], # to do
-      after_create: [], # to do
-      enum: [], # to do
-      attr_encrypted: [], # to do
-      validates_uniqueness_of: [], # to do
-      validates_confirmation_of: [], # to do
-      attr_accessor: [], # to do
-      attr_reader: [], # to do
-      attr_writer: [] # to do
-    }
-  end
-
-  def escape_single_quote(value)
-    return nil if value.nil?
-
-    value.gsub("'", "\\\\'")
-  end
-
-  # rubocop:disable Style/EvalWithLocation, Security/Eval, Style/DocumentDynamicEvalDefinition
-  def extract_options(options)
-    eval("{ #{options} }")
-  rescue StandardError => e
-    investigate(
-      step: :step4_attach_erd_files_models,
-      location: :extract_options,
-      key: nil,
-      message: e.message
-    )
-    {}
-  rescue SyntaxError => e
-    # may be the issue is from a comment at the off the line
-    comment_index = options.rindex('#') - 1
-
-    if comment_index.positive?
-      options_minus_comment = options[0..comment_index].squish
-      return extract_options(options_minus_comment)
-    end
-
-    investigate(
-      step: :step4_attach_erd_files_models,
-      location: :extract_options,
-      key: nil,
-      message: e.message
-    )
-    {}
-  end
-  # rubocop:enable Style/EvalWithLocation, Security/Eval, Style/DocumentDynamicEvalDefinition
-
-  def clean_lambda(options)
-    if /^->/.match?(options)
-      index = options.index(/}\s*,/)
-      if index.nil?
-        if options.count('{') == options.count('}')
-          index = options.rindex(/}/)
-          options = "a_lambda: '#{escape_single_quote(options[0..index])}'"
-        else
-          log.error(options)
-          options = "a_lambda: '#{escape_single_quote(options)}'"
-        end
-      else
-        options = "a_lambda: '#{escape_single_quote(options[0..index])}', #{options[index + 2..-1]}"
-      end
-    end
-    options
-  rescue StandardError => e
-    # bin ding.pry
-    puts e.message
-  end
-end

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

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-# The require order is important due to dependencies
-require_relative './index'
-require_relative './table'
-require_relative './foreign_key'
-require_relative './schema'

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

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module KDomain
-  module Database
-    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
-  end
-end

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

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module KDomain
-  module Database
-    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
-  end
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-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 :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)
-      attribute :foreign_keys?        , Types::Strict::Array.of(KDomain::Database::ForeignKey)
-      attribute :indexes?             , Types::Strict::Array.of(KDomain::Database::Index)
-      attribute :meta                 , KDomain::Database::Schema::Meta
-    end
-  end
-end