k_domain 0.0.20 → 0.0.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de5fc8f220781026dd327f40da53eb3a424ec23f38785be8fddc8f1856970dc1
-  data.tar.gz: 5573e60dc8665ab146e0edeb291ebcd3db6b792180e05e24721df9d519038f86
+  metadata.gz: cbbddfe9857696b7a3a02fc370c51205d584fd08aaad5f8b8605dccebab02bc1
+  data.tar.gz: c37fee293561e73b3ed4b4e31f9def8c13848217ee9c4d14efdcfc67a46d42ea
 SHA512:
-  metadata.gz: 4ecaa0fef7e6d622f18d2dfe53bdddf2c17fa91e1c2796ee7bdddf5044880f742003d8cb6f7bb4007eeab4bd2f0becba6f8f0fb329f58776f807cd200bd4ced9
-  data.tar.gz: 76af19179f670d7e4b18121f031b77e18c366259526530b6623f988c5b3e2985ca3a993441e6caacfb7cb71da6afb05c99803234aa85045facdb2c8f09b1194b
+  metadata.gz: 12d58c761198fe6fa8336871ab5a3475c0a1caf358c09af2005e8bab3192c82b864663b867b3f2a39d8ba7c20e58258a8981ddd6339dbdb4edec73e37bca4652
+  data.tar.gz: 0bfd25819a3425f2932ba751d9e4413b41ae2c617416751855ced16a7fc74f68eff64d87a92138c73b85b0df175f38b8b299f5912f67f8a78970926ff83a4df8

data/.builders/config/_.rb

@@ -0,0 +1,3 @@
+puts '_'
+
+#require 'config/_initialize'

data/.builders/setup.rb

@@ -0,0 +1,30 @@
+require 'config/_'
+require_relative "../lib/k_domain"
+
+db_schema_ruby_file = '/Users/davidcruwys/dev/printspeak/printspeak-master/db/schema.rb'
+
+# /Users/davidcruwys/dev/printspeak/printspeak/.builders/config/raw/schema_printspeak.rb
+output_folder = File.expand_path('../.output')
+db_schema_json_file = File.join(output_folder, 'db_schema.json')
+schema_loader_file = File.join(output_folder, 'schema_printspeak.rb')
+
+transformer = KDomain::RawDbSchema::Transform.new(db_schema_ruby_file)
+transformer.template_file = '/Users/davidcruwys/dev/kgems/k_domain/templates/old_printspeek_schema.rb'
+puts db_schema_ruby_file
+puts transformer.template_file
+transformer.call
+transformer.write_json(db_schema_json_file)
+transformer.write_schema_loader(schema_loader_file)
+# transformer.schema
+
+
+# transform = KDomain::DomainModel::Transform.new(
+#   db_schema: db_schema,
+#   target_file: target_file,
+#   target_step_file: target_step_file,
+#   model_path: model_path,
+#   controller_path: controller_path,
+#   route_path: route_path
+# )
+
+puts 'done'

data/.gitignore

@@ -23,6 +23,7 @@ k_domain.yml
 /doc/
 /pkg/
 /spec/reports/
+/spec/example_domain/advanced/
 /tmp/
 !/tmp/.keep
 *.bundle

data/.rubocop.yml

@@ -6,8 +6,7 @@ AllCops:
   NewCops: enable
   Exclude:
     - "_/**/*"
-    - "spec/sample_input/**/*"
-    - "spec/sample_output/**/*"
+    - "spec/example_domain/**/*"
     - "templates/**/*"
     - "lib/k_domain/schemas/domain/old/**/*"
     - "spec/k_domain/ruby_loader/**/*"

data/Guardfile

@@ -19,6 +19,7 @@ group :green_pass_then_cop, halt_on_fail: true do
     # Ruby files
     ruby = dsl.ruby
     dsl.watch_spec_files_for(ruby.lib_files)
+    watch(%r{^lib/k_domain/domain_model/transform_steps/(.+).rb}) { 'spec/k_domain/domain_model/transform_spec.rb' }
     watch(%r{^lib/k_domain/**/(.+)\.rb$}) { |m| "spec/unit/#{m[1]}_spec.rb" }
     watch(%r{^lib/k_domain/commands/(.+)\.rb$}) { |m| "spec/unit/commands/#{m[1]}_spec.rb" }
   end

data/README.md

@@ -1,3 +1,18 @@
+# JSON Schema
+
+The following schemas were created using the following processes.
+
+```
+quicktype -o json-schema/database.json -t database -l schema spec/sample_output/printspeak/schema.json
+quicktype -o json-schema/database.rb   -t database -l ruby   json-schema/database-altered.json
+spec/sample_output/printspeak/schema.json
+json-schema/database-altered.json
+```
+
+remove statistics
+remove (or move rails structure)
+drop erd_location
+
 # K Domain
 
 > K Domain builds complex domain schemas by combining the database schema with a rich entity relationship DSLs

data/lib/k_domain/domain_model/transform.rb

@@ -11,24 +11,34 @@ module KDomain
       attr_reader :db_schema
       attr_reader :target_step_file
       attr_reader :target_file
-      attr_reader :erd_path
+      attr_reader :model_path
+      attr_reader :controller_path
+      attr_reader :route_path
+      attr_reader :shim_loader
 
-      def initialize(db_schema: , target_file: , target_step_file: , erd_path:)
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(db_schema: , target_file: , target_step_file: , model_path:, route_path:, controller_path:, shim_loader: nil)
         @db_schema        = db_schema
         @target_step_file = target_step_file
         @target_file      = target_file
-        @erd_path         = erd_path
+        @model_path       = model_path
+        @controller_path  = controller_path
+        @route_path       = route_path
+        @shim_loader      = shim_loader
       end
+      # rubocop:enable Metrics/ParameterLists
 
       # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
       def call
         valid = true
-        valid &&= Step1AttachDbSchema.run(domain_data, db_schema: db_schema, step_file: step_file('1-attach-db-schema'))
-        valid &&= Step2AttachModels.run(domain_data, erd_path: erd_path, step_file: step_file('2-attach-model'))
-        valid &&= Step3AttachColumns.run(domain_data, step_file: step_file('3-attach-columns'))
-        valid &&= Step4RailsResourceModels.run(domain_data, erd_path: erd_path, step_file: step_file('4-rails-resource-models'))
-        valid &&= Step5RailsModels.run(domain_data, erd_path: erd_path, step_file: step_file('5-rails-models'))
-        valid &&= Step6AttachDictionary.run(domain_data, erd_path: erd_path, step_file: step_file('6-attach-dictionary'))
+        valid &&= Step1DbSchema.run(domain_data, db_schema: db_schema, step_file: step_file('01-db-schema'))
+        valid &&= Step2DomainModels.run(domain_data, model_path: model_path, step_file: step_file('02-domain-model'))
+        valid &&= Step4RailsResourceModels.run(domain_data, model_path: model_path, step_file: step_file('04-rails-resource-models'))
+        valid &&= Step5RailsResourceRoutes.run(domain_data, route_path: route_path, controller_path: controller_path, step_file: step_file('05-rails-resource-routes'))
+        valid &&= Step6RailsStructureModels.run(domain_data, model_path: model_path, step_file: step_file('06-rails-structure-models'), shim_loader: shim_loader)
+        valid &&= Step7RailsStructureControllers.run(domain_data, controller_path: controller_path, step_file: step_file('07-rails-structure-controllers'), shim_loader: shim_loader)
+        valid &&= Step8DomainColumns.run(domain_data, step_file: step_file('08-domain-columns'))
+        valid &&= Step20Dictionary.run(domain_data, step_file: step_file('20-dictionary'))
 
         raise 'DomainModal transform failed' unless valid
 
@@ -39,7 +49,7 @@ module KDomain
       # rubocop:enable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
       def step_file(step_name)
-        target_step_file % { step: step_name }
+        format(target_step_file, step: step_name)
       end
 
       def write
@@ -52,11 +62,11 @@ module KDomain
         # The initial domain model structure is created here, but populated during the workflows.
         @domain_data ||= {
           domain: {
-            models: [],
+            models: []
           },
           rails_resource: {
             models: [],
-            controllers: []
+            routes: []
           },
           rails_structure: {
             models: [],
@@ -69,6 +79,7 @@ module KDomain
             tables: [],
             indexes: [],
             foreign_keys: [],
+            views: [],
             meta: {}
           },
           investigate: {
@@ -76,7 +87,6 @@ module KDomain
           }
         }
       end
-
       # rubocop:enable Metrics/MethodLength
     end
   end

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

@@ -2,9 +2,11 @@
 
 # The require order is important due to dependencies
 require_relative './step'
-require_relative './step1_attach_db_schema'
-require_relative './step2_attach_models'
-require_relative './step3_attach_columns'
+require_relative './step1_db_schema'
+require_relative './step2_domain_models'
 require_relative './step4_rails_resource_models'
-require_relative './step5_rails_models'
-require_relative './step6_attach_dictionary'
+require_relative './step5_rails_resource_routes'
+require_relative './step6_rails_structure_models'
+require_relative './step7_rails_structure_controllers'
+require_relative './step8_domain_columns'
+require_relative './step20_dictionary'

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

@@ -33,6 +33,10 @@ module KDomain
         @valid = false
       end
 
+      def warning(message)
+        log.warn message
+      end
+
       def write(file)
         FileUtils.mkdir_p(File.dirname(file))
         File.write(file, JSON.pretty_generate(domain_data))
@@ -64,6 +68,14 @@ module KDomain
         rails_resource[:models] = value
       end
 
+      def rails_resource_routes
+        rails_resource[:routes]
+      end
+
+      def rails_resource_routes=(value)
+        rails_resource[:routes] = value
+      end
+
       def rails_resource_controllers
         rails_resource[:controllers]
       end
@@ -79,6 +91,10 @@ module KDomain
         rails_structure[:models]
       end
 
+      def find_rails_structure_models(model_name)
+        rails_structure_models.find { |model| model[:model_name] == model_name }
+      end
+
       def rails_structure_models=(value)
         rails_structure[:models] = value
       end
@@ -87,6 +103,10 @@ module KDomain
         rails_structure[:controllers]
       end
 
+      def rails_structure_controllers=(value)
+        rails_structure[:controllers] = value
+      end
+
       # Database Accessor/Helpers
       def database=(value)
         domain_data[:database] = value

data/lib/k_domain/domain_model/transform_steps/{step1_attach_db_schema.rb → step1_db_schema.rb}

@@ -2,12 +2,13 @@
 
 module KDomain
   module DomainModel
-    class Step1AttachDbSchema < KDomain::DomainModel::Step
+    class Step1DbSchema < KDomain::DomainModel::Step
       # Map database schema to domain model
       def call
         raise 'Schema not supplied' if opts[:db_schema].nil?
 
         self.database = opts[:db_schema].clone
+        database[:tables] = database[:tables] # .slice(156, 1)
 
         guard('tables are missing')               if database[:tables].nil?
         guard('indexes are missing')              if database[:indexes].nil?

data/lib/k_domain/domain_model/transform_steps/{step6_attach_dictionary.rb → step20_dictionary.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-# Attach data dictionary
-class Step6AttachDictionary < KDomain::DomainModel::Step
+#  data dictionary
+class Step20Dictionary < KDomain::DomainModel::Step
   attr_reader :dictionary
 
   def call
@@ -27,10 +27,10 @@ class Step6AttachDictionary < KDomain::DomainModel::Step
       entry[:model_count] = entry[:model_count] + 1
 
       unless entry[:types].include?(column_type)
-        investigate(step: :step5_attach_dictionary,
-          location: :process,
-          key: "#{model_name},#{column_name},#{column_type}",
-          message: "#{model_name} has a type mismatch for column name: #{column_name}")
+        investigate(step: :step5_dictionary,
+                    location: :process,
+                    key: "#{model_name},#{column_name},#{column_type}",
+                    message: "#{model_name} has a type mismatch for column name: #{column_name}")
 
         entry[:types] << column_type
         entry[:type_count] = entry[:type_count] + 1

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

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+# Schema is re-shaped into a format designed for domain modeling
+class Step2DomainModels < KDomain::DomainModel::Step
+  # Map database schema to domain model
+  def call
+    raise 'Rails model path not supplied' if opts[:model_path].nil?
+
+    domain[:models] = database_tables.map { |table| model(table) }
+  end
+
+  def model(table)
+    table_name = table[:name].to_s
+    model_name = table_name.singularize
+
+    model = {
+      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),
+      file: nil
+    }
+
+    attach_columns(model)
+  end
+
+  def primary_key(table)
+    {
+      name: table[:primary_key],
+      type: table[:primary_key_type],
+      exist: !table[:primary_key].nil?
+    }
+  end
+
+  def attach_columns(model)
+    table = find_table_for_model(model)
+    columns = columns(table[:columns])
+    columns = insert_primary_key(model, columns)
+    model[:columns] = columns
+    model
+  end
+
+  def columns(db_columns)
+    db_columns.map do |db_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]
+      )
+    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(column)
+    columns
+  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 column_data(name)
+    {
+      name: name,
+      name_plural: name.pluralize,
+      type: nil,
+      precision: nil,
+      scale: nil,
+      default: nil,
+      null: nil,
+      limit: nil,
+      array: nil
+    }
+  end
+
+  # # Location of source code
+  # def location(table_name, model_name)
+  #   file_normal = File.join(opts[:model_path], "#{model_name}.rb")
+  #   file_custom = File.join(opts[:model_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
+  #   }
+  # end
+end

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

@@ -5,7 +5,7 @@ class Step4RailsResourceModels < KDomain::DomainModel::Step
   attr_accessor :ruby_code
 
   def call
-    raise 'ERD path not supplied' if opts[:erd_path].nil?
+    raise 'Model path not supplied' if opts[:model_path].nil?
 
     self.rails_resource_models = domain_models.map do |model|
       locate_rails_model(model[:name], model[:table_name])
@@ -15,8 +15,8 @@ class Step4RailsResourceModels < KDomain::DomainModel::Step
   private
 
   def locate_rails_model(model_name, table_name)
-    file_normal = File.join(opts[:erd_path], "#{model_name}.rb")
-    file_custom = File.join(opts[:erd_path], "#{table_name}.rb")
+    file_normal = File.join(opts[:model_path], "#{model_name}.rb")
+    file_custom = File.join(opts[:model_path], "#{table_name}.rb")
     file_exist  = true
     state = []
 

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Locate rails model files
+class Step5RailsResourceRoutes < KDomain::DomainModel::Step
+  def call
+    return warning('Routes .json file not supplied') if opts[:route_path].nil?
+    return warning('Routes .json file not found') unless File.exist?(opts[:route_path])
+
+    warning('Controller path not supplied. Routes will be loaded but not paired with a controller') if opts[:controller_path].nil?
+
+    self.rails_resource_routes = load_routes(opts[:route_path], opts[:controller_path])
+  end
+
+  private
+
+  def load_routes(route_path, controller_path)
+    json = File.read(route_path)
+    root = JSON.parse(json, symbolize_names: true)
+    routes = root[:routes]
+
+    routes.map { |route| map_route(route, controller_path) }
+  end
+
+  def map_route(route, controller_path)
+    return route.merge({ file: '', exist: false }) if controller_path.nil?
+
+    controller_file = File.join(controller_path, route[:controller_file])
+
+    route.merge(
+      {
+        file: controller_file,
+        exist: File.exist?(controller_file)
+      }
+    )
+  end
+end

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