k_domain 0.0.1 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee3ac6f9a2143cc6329183f38515615569399067e0919ba83eff7e5485a31b30
-  data.tar.gz: c5e8016c595b30265436ae90acdcd28cbd2db9def4ea83308cf479840b04b173
+  metadata.gz: c236bd2b714a21b40f5727765bc2b9c049f0c265e7c592e5864a6a6e34330b37
+  data.tar.gz: 8ecf79ec6e1805ad6660218ac6aa6931ef67a48b3ca56dd339c7a6a0f6c50886
 SHA512:
-  metadata.gz: 1ccc3e4d22125ddebed3eb122d4dcd21392fcca079237ede44fb50b3ba351a780ebe894170e4e25bb08055d93f66ba7059127b4590e8c21f8956717fc5b78dec
-  data.tar.gz: 7ab779bf4c936bc7465fa0667d24b5c459475a0d4e00a57cc9276310f3fb84ddd44683d1262f40e79b5de712609d0aefffab954b2d6d0f97a90251290dbe0cd6
+  metadata.gz: 4b3a6c9c9af39c37fdeba462a209a0bd395a72c1887505c0852f1f37a58406c929cc080c63bb9ed5b4de937be51d722e0511a6194d7de389840cb5ca831e7135
+  data.tar.gz: f71d09378bf35ec9146692bd137b02176095ba934fbba711c6204896541af27365aeeeb67997d89d43cea7498f2d7361322cba566dd0c31ed1674fb190656968

data/.rubocop.yml

@@ -6,12 +6,37 @@ AllCops:
   NewCops: enable
   Exclude:
     - "_/**/*"
-    - "spec/samples/**/*"
+    - "spec/sample_input/**/*"
+    - "spec/sample_output/**/*"
+    - "lib/k_domain/raw_db_schema/template.rb"
+
+Metrics/PerceivedComplexity:
+  Exclude:
+    - "lib/k_domain/domain_model/transform_steps/*.rb"
+    - "lib/k_domain/domain_model/dtos/entity.rb"
+    - "lib/k_domain/domain_model/dtos/old/entity.rb"
+
+Metrics/AbcSize:
+  Exclude:
+    - "lib/k_domain/domain_model/transform_steps/*.rb"
+    - "lib/k_domain/domain_model/dtos/rails_model.rb"
+    - "lib/k_domain/domain_model/dtos/entity.rb"
+    - "lib/k_domain/domain_model/dtos/column_old.rb"
+    - "lib/k_domain/domain_model/dtos/old/column_old.rb"
+    - "lib/k_domain/domain_model/dtos/old/rails_model.rb"
+    - "lib/k_domain/domain_model/dtos/old/entity.rb"
+
+Metrics/CyclomaticComplexity:
+  Exclude:
+    - "lib/k_domain/domain_model/transform_steps/*.rb"
+    - "lib/k_domain/domain_model/dtos/entity.rb"
+    - "lib/k_domain/domain_model/dtos/old/entity.rb"
 
 Metrics/BlockLength:
   Exclude:
     - "**/spec/**/*"
     - "*.gemspec"
+    - 'lib/k_domain/domain_model/dtos/erd_file.rb'    
   IgnoredMethods:
     - configure
     - context
@@ -34,12 +59,19 @@ Metrics/BlockLength:
 
 Metrics/MethodLength:
   Max: 25
+  Exclude:
+    - "lib/k_domain/domain_model/transform_steps/*.rb"
+    - "lib/k_domain/domain_model/dtos/rails_model.rb"
+    - "lib/k_domain/domain_model/dtos/old/entity.rb"
+    - "lib/k_domain/domain_model/dtos/old/rails_model.rb"
 
 Layout/LineLength:
   Max: 200
   # Ignores annotate output
   IgnoredPatterns: ['\A# \*\*']
   IgnoreCopDirectives: true
+  Exclude:
+    - "lib/k_domain/domain_model/transform_steps/*.rb"
 
 Lint/UnusedMethodArgument:
   AllowUnusedKeywordArguments: true
@@ -77,6 +109,12 @@ Lint/AmbiguousBlockAssociation:
 Style/AccessorGrouping:
   Enabled: false
 
+Style/FormatStringToken:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
 Layout/SpaceBeforeComma:
   Enabled: false
 # My Preferences - End

data/Gemfile

@@ -23,3 +23,13 @@ group :development, :test do
   gem 'rubocop-rake', require: false
   gem 'rubocop-rspec', require: false
 end
+
+# If local dependency
+if ENV['KLUE_LOCAL_GEMS']&.to_s&.downcase == 'true'
+  group :development, :test do
+    puts 'Using Local GEMs'
+    gem 'peeky'                   , path: '../peeky'
+    gem 'k_log'                   , path: '../k_log'
+    gem 'k_util'                  , path: '../k_util'
+  end
+end

data/Guardfile

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+guard :bundler, cmd: 'bundle install' do
+  watch('Gemfile')
+  watch('k_domain.gemspec')
+end
+
+group :green_pass_then_cop, halt_on_fail: true do
+  guard :rspec, cmd: 'bundle exec rspec -f doc' do
+    require 'guard/rspec/dsl'
+    dsl = Guard::RSpec::Dsl.new(self)
+
+    # RSpec files
+    rspec = dsl.rspec
+    watch(rspec.spec_helper) { rspec.spec_dir }
+    watch(rspec.spec_support) { rspec.spec_dir }
+    watch(rspec.spec_files)
+
+    # Ruby files
+    ruby = dsl.ruby
+    dsl.watch_spec_files_for(ruby.lib_files)
+    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
+
+  # guard :rubocop, all_on_start: false, cli: ['--format', 'clang'] do
+  #   watch(/{.+\.rb$/)
+  #   watch(%r{(?:.+/)?\.rubocop(?:_todo)?\.yml$}) { |m| File.dirname(m[0]) }
+  # end
+end

data/Rakefile

@@ -7,11 +7,8 @@ GEM_NAME = 'k_domain'
 require 'pry'
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
-puts 'xxxxxxxxxx'
 require 'k_domain'
 require 'k_domain/version'
-puts 'xxxxxxxxxx2'
-binding.pry
 
 RSpec::Core::RakeTask.new(:spec)
 
@@ -29,7 +26,9 @@ task :publish do
   system 'gem build'
   system "gem push #{GEM_NAME}-#{KDomain::VERSION}.gem"
 end
-
+task :build do
+  system 'gem build'
+end
 desc 'Remove old *.gem files'
 task :clean do
   system 'rm *.gem'

data/STORIES.md

@@ -0,0 +1,63 @@
+# K Domain
+
+> K Domain builds complex domain schemas by combining the database schema with a rich entity relationship DSLs
+
+As an Application Developer, I need a rich and configurable ERD schema, so I can generate enterprise applications quickly
+
+## Development radar
+
+### Stories next on list
+
+As a Developer, I can print any of the domain structures, so that I can visually my domain
+
+- Hook up log.structure
+
+As a Developer, I can customize domain configuration, so that I can have opinions about names and types
+
+- Handle traits
+
+As a Developer, I can read native rails model data, so that I can leverage existing rails applications for ERD modeling
+
+- Use Meta Programming and re-implement ActiveRecord::Base
+
+### Tasks next on list
+
+Refactor / Simply
+
+- Replace complex objects an with structs for ancillary data structures such as investigate
+
+User acceptance testing
+
+- Provide sample printers for each data structure to visually check data is loading
+- Point raw_db_schema loader towards a complex ERD and check how it performs
+
+## Stories and tasks
+
+### Tasks - completed
+
+Setup RubyGems and RubyDoc
+
+- Build and deploy gem to [rubygems.org](https://rubygems.org/gems/k_domain)
+- Attach documentation to [rubydoc.info](https://rubydoc.info/github/to-do-/k_domain/master)
+
+Setup project management, requirement and SCRUM documents
+
+- Setup readme file
+- Setup user stories and tasks
+- Setup a project backlog
+- Setup an examples/usage document
+
+Setup GitHub Action (test and lint)
+
+- Setup Rspec action
+- Setup RuboCop action
+
+Setup new Ruby GEM
+
+- Build out a standard GEM structure
+- Add automated semantic versioning
+- Add Rspec unit testing framework
+- Add RuboCop linting
+- Add Guard for automatic watch and test
+- Add GitFlow support
+- Add GitHub Repository

data/USAGE.md

@@ -0,0 +1,19 @@
+# K Domain
+
+> K Domain builds complex domain schemas by combining the database schema with a rich entity relationship DSLs
+
+As an Application Developer, I need a rich and configurable ERD schema, so I can generate enterprise applications quickly
+
+## Usage
+
+### Sample Classes
+
+#### Simple example
+
+Description for a simple example that shows up in the USAGE.MD
+
+```ruby
+class SomeRuby
+  def initialize; end
+end
+```

data/k_domain.gemspec

@@ -33,10 +33,14 @@ Gem::Specification.new do |spec|
       f.match(%r{^(test|spec|features)/})
     end
   end
+  
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
   # spec.extensions    = ['ext/k_domain/extconf.rb']
 
+  spec.add_dependency 'activesupport'   , '~> 6'
+  spec.add_dependency 'dry-struct', '~> 1'
   spec.add_dependency 'k_log' , '~> 0.0.0'
+  spec.add_dependency 'peeky' , '~> 0.0.0'
 end

data/lib/k_domain/domain_model/load.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Annotates the original schema with methods that implement existing method calls
+# that are already in the schema so that we can build a hash.
+#
+# Writes a new annotated schema.rb file with a public method called load that
+# builds the hash
+
+module KDomain
+  module DomainModel
+    class Load
+      include KLog::Logging
+
+      attr_reader :source_file
+      attr_reader :data
+
+      def initialize(source_file)
+        @source_file = source_file
+      end
+
+      def call
+        json = File.read(source_file)
+        data = KUtil.data.json_parse(json, as: :hash_symbolized)
+
+        @data = KDomain::Schemas::DomainModel.new(data)
+      end
+    end
+  end
+end

data/lib/k_domain/domain_model/transform.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+# Loads the db schema object and works through a series of enrichment steps to
+# that builds the domain modal
+
+module KDomain
+  module DomainModel
+    class Transform
+      include KLog::Logging
+
+      attr_reader :db_schema
+      attr_reader :target_step_file
+      attr_reader :target_file
+      attr_reader :erd_path
+
+      def initialize(db_schema: , target_file: , target_step_file: , erd_path:)
+        @db_schema        = db_schema
+        @target_step_file = target_step_file
+        @target_file      = target_file
+        @erd_path         = erd_path
+      end
+
+      def call
+        valid = true
+        valid &&= step1
+        valid &&= step2
+        valid &&= step3
+        valid &&= step4
+        valid &&= step5
+        valid &&= step8 # NOT SURE WHERE THIS BELONGS
+
+        raise 'DomainModal transform failed' unless valid
+
+        write
+
+        nil
+      end
+
+      def step1
+        Step1AttachDbSchema.run(domain_data, db_schema: db_schema)
+        write(step: '1-attach-db-schema')
+      end
+
+      def step2
+        Step2AttachModels.run(domain_data, erd_path: erd_path)
+        write(step: '2-attach-model')
+      end
+
+      def step3
+        Step3AttachColumns.run(domain_data)
+        write(step: '3-attach-columns')
+      end
+
+      def step4
+        Step4AttachErdFiles.run(domain_data, erd_path: erd_path)
+        write(step: '4-attach-erd-files')
+      end
+
+      def step5
+        Step5AttachDictionary.run(domain_data, erd_path: erd_path)
+        write(step: '5-attach-dictionary')
+      end
+
+      def step8
+        Step8LocateRailsModels.run(domain_data, erd_path: erd_path)
+        write(step: '8-rails-files-models')
+      end
+
+      def write(step: nil)
+        file = if step.nil?
+                 target_file
+               else
+                 format(target_step_file, step: step)
+               end
+        FileUtils.mkdir_p(File.dirname(file))
+        File.write(file, JSON.pretty_generate(domain_data))
+      end
+
+      def domain_data
+        # The initial domain model structure is created here, but populated during the workflows.
+        @domain_data ||= {
+          domain: {
+            models: [],
+            erd_files: [],
+          },
+          rails: {
+            models: [],
+            controllers: [],
+          },
+          rails_resource: {
+            models: [],
+            controllers: [],
+          },
+          dictionary: {
+            items: []
+          },
+          database: {
+            tables: [],
+            indexes: [],
+            foreign_keys: [],
+            meta: {}
+          },
+          investigate: {
+            issues: []
+          }
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# 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 './step4_attach_erd_files'
+require_relative './step5_attach_dictionary'
+require_relative './step8_locate_rails_models'

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class Step
+      include KLog::Logging
+
+      attr_reader :domain_data
+      attr_reader :opts
+      attr_reader :valid
+      alias valid? valid
+
+      def initialize(domain_data, **opts)
+        # Useful for debugging
+        # log.info "Initialize #{self.class.name}"
+
+        @domain_data  = domain_data
+        @opts         = opts
+        @valid        = true
+      end
+
+      def call; end
+
+      def self.run(domain_data, **opts)
+        step = new(domain_data, **opts)
+        step.call
+        step
+      end
+
+      def guard(message)
+        log.error message
+        @valid = false
+      end
+
+      # Domain Model Accessor/Helpers
+      def domain
+        guard('domain is missing') if domain_data[:domain].nil?
+
+        domain_data[:domain]
+      end
+
+      def domain_models
+        domain[:models]
+      end
+
+      # Rails File Accessor/Helpers
+      def rails_resource
+        guard('rails_resource is missing') if domain_data[:rails_resource].nil?
+
+        domain_data[:rails_resource]
+      end
+
+      def rails_resource_models
+        rails_resource[:models]
+      end
+
+      def rails_resource_models=(value)
+        rails_resource[:models] = value
+      end
+
+      def rails_resource_controllers
+        rails_resource[:controllers]
+      end
+
+      # Database Accessor/Helpers
+      def database=(value)
+        domain_data[:database] = value
+      end
+
+      def database
+        guard('database is missing') if domain_data[:database].nil?
+
+        domain_data[:database]
+      end
+
+      def database_tables
+        guard('database_tables is missing') if database[:tables].nil?
+
+        database[:tables]
+      end
+
+      def database_foreign_keys
+        guard('database_foreign_keys is missing') if database[:foreign_keys].nil?
+
+        database[:foreign_keys]
+      end
+
+      def find_table_for_model(model)
+        database_tables.find { |table| table[:name] == model[:table_name] }
+      end
+
+      def table_name_exist?(table_name)
+        if table_name.nil?
+          guard('table_name_exist? was provided with a table_name: nil')
+          return false
+        end
+        database_table_name_hash.key?(table_name)
+      end
+
+      def find_foreign_table(lhs_table_name, column_name)
+        fk = database_foreign_keys.find { |foreign_key| foreign_key[:left] == lhs_table_name && foreign_key[:column] == column_name }
+        return fk[:right] if fk
+
+        nil
+      end
+
+      def investigate(step:, location:, key:, message:)
+        unique_key = build_key(step, location, key)
+
+        return if issue_hash.key?(unique_key)
+
+        value = { step: step, location: location, key: key, message: message }
+
+        issues << value                   # list
+        issue_hash[unique_key] = value    # lookup
+      end
+
+      def issues
+        domain_data[:investigate][:issues]
+      end
+
+      private
+
+      def database_table_name_hash
+        @database_table_name_hash ||= database_tables.to_h { |table| [table[:name], table[:name]] }
+      end
+
+      def build_key(*values)
+        values.join('-')
+      end
+
+      def issue_hash
+        return @issue_hash if defined? @issue_hash
+
+        @issue_hash = issues.to_h do |issue|
+          unique_key = build_key(issue[:step], issue[:location], issue[:key])
+          [unique_key, issue]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class Step1AttachDbSchema < 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
+
+        guard('tables are missing')               if database[:tables].nil?
+        guard('indexes are missing')              if database[:indexes].nil?
+        guard('foreign keys are missing')         if database[:foreign_keys].nil?
+        guard('rails version is missing')         if database[:meta][:rails].nil?
+        guard('postgres extensions are missing')  if database[:meta][:db_info][:extensions].nil?
+        guard('unique keys are missing')          if database[:meta][:unique_keys].nil?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# 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