k_domain 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee3ac6f9a2143cc6329183f38515615569399067e0919ba83eff7e5485a31b30
-  data.tar.gz: c5e8016c595b30265436ae90acdcd28cbd2db9def4ea83308cf479840b04b173
+  metadata.gz: a69b94955a43f91d71e034b94a5caf0d3fdbb7b130c480d4eabc45818bbe2262
+  data.tar.gz: 0f4a126ee7c9bed5d99ac7449e5f97ec558030b126dbaa3c6194cdb5ce8430bd
 SHA512:
-  metadata.gz: 1ccc3e4d22125ddebed3eb122d4dcd21392fcca079237ede44fb50b3ba351a780ebe894170e4e25bb08055d93f66ba7059127b4590e8c21f8956717fc5b78dec
-  data.tar.gz: 7ab779bf4c936bc7465fa0667d24b5c459475a0d4e00a57cc9276310f3fb84ddd44683d1262f40e79b5de712609d0aefffab954b2d6d0f97a90251290dbe0cd6
+  metadata.gz: 3a7a877e80c9f23cdb93ab7952e027bdddc89bd6e888212c6fc0622cc0d5ae6d9b73e3e9651949ecd1afa2f1323e6446045f579cb6e83c030c5d8d711979deaa
+  data.tar.gz: 434275e01ec2308d4a1407f5e8bd7ab9ec9708218510b6a719c144e2d9b6abb7e2caafa67efc617ac33295cd276c2326ccd961468ee4870b38266ef1b1295296

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)
 

data/STORIES.md

@@ -0,0 +1,44 @@
+# 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 DO_SOMETHING, so that I QUALITY_OF_LIFE
+
+- Subtask
+
+## 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/lib/k_domain/raw_schema/template.rb

@@ -0,0 +1,226 @@
+class LoadSchema
+  attr_reader :schema
+
+  def initialize
+    @unique_keys = {}
+    @current_table = nil
+    @rails_version = 4
+    @schema = {
+      tables: [],
+      foreign_keys: [],
+      indexes: [],
+      meta: {
+        rails: @rails_version,
+        database: {
+          type: 'postgres',
+          version: nil,         # TODO
+          extensions: []
+        },
+        unique_keys: []
+      }
+    }
+  end
+
+  # ----------------------------------------------------------------------
+  # Inject start
+  # original file: {{source_file}}
+  # ----------------------------------------------------------------------
+  def load_schema
+{{rails_schema}}
+  end
+
+  # ----------------------------------------------------------------------
+  # original file: {{source_file}}
+  # Inject 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[:database][: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[:database][: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][:database][: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 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

data/lib/k_domain/raw_schema/transform.rb

@@ -0,0 +1,67 @@
+# 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
+# frozen_string_literal: true
+
+module KDomain
+  module RawSchema
+    class Transform
+      include KLog::Logging
+
+      attr_reader :source_file
+      attr_reader :template_file
+      attr_reader :target_ruby_class
+    
+      def initialize(source_file)#, target_file)
+        @source_file = source_file
+        @template_file = 'lib/k_domain/raw_schema/template.rb'
+      end
+ 
+      def call
+        # log.kv 'source_file', source_file
+        # 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)
+        content
+          .gsub!(/ActiveRecord::Schema.define/, 'load')
+
+        lines = content.lines.map { |line| "    #{line}" }.join()
+
+        @target_ruby_class = File
+          .read(template_file)
+          .gsub('{{source_file}}', source_file)
+          .gsub('{{rails_schema}}', lines)
+      end
+
+      def write_target(target_file)
+        if target_ruby_class.nil?
+          puts '.call method has not been executed'
+          return
+        end
+
+        FileUtils.mkdir_p(File.dirname(target_file))
+        File.write(target_file, target_ruby_class)
+      end
+
+      def json
+        if target_ruby_class.nil?
+          puts '.call method has not been executed'
+          return
+        end
+
+        # load target_file
+        eval target_ruby_class
+    
+        loader = LoadSchema.new
+        loader.load_schema()
+        loader.schema
+      end
+    end
+  end
+end

data/lib/k_domain/version.rb

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

data/lib/k_domain.rb

@@ -2,8 +2,7 @@
 
 require 'k_log'
 require 'k_domain/version'
-
-
+require 'k_domain/raw_schema/transform'
 
 module KDomain
   # raise KDomain::Error, 'Sample message'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: k_domain
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - David Cruwys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-25 00:00:00.000000000 Z
+date: 2021-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: k_log
@@ -38,9 +38,12 @@ files:
 - ".rubocop.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- STORIES.md
+- USAGE.md
 - bin/console
 - bin/k
 - bin/kgitsync
@@ -50,6 +53,8 @@ files:
 - hooks/update-version
 - k_domain.gemspec
 - lib/k_domain.rb
+- lib/k_domain/raw_schema/template.rb
+- lib/k_domain/raw_schema/transform.rb
 - lib/k_domain/version.rb
 homepage: http://appydave.com/gems/k-domain
 licenses: