k_domain 0.0.1 → 0.0.14

data/lib/k_domain/schemas/domain/old/has_one.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class HasOne
+      # KEYS = [:model_name, :model_name_plural, :a_lambda, :class_name, :foreign_key, :primary_key, :infer_key]
+      KEYS = %i[a_lambda class_name foreign_key primary_key infer_key code_duplicate].freeze
+
+      attr_accessor :name
+
+      attr_accessor :model_name
+      attr_accessor :model_name_plural
+
+      attr_accessor :a_lambda
+      attr_accessor :class_name
+      attr_accessor :foreign_key
+      attr_accessor :primary_key
+
+      def infer_key
+        primary_key.nil? ? "#{name}_id" : primary_key
+      end
+
+      attr_accessor :related_entity
+      attr_accessor :code_duplicate
+
+      def to_h
+        {
+          name: name,
+          model_name: model_name,
+          model_name_plural: model_name_plural,
+          a_lambda: a_lambda,
+          class_name: class_name,
+          foreign_key: foreign_key,
+          primary_key: primary_key,
+          code_duplicate: code_duplicate,
+          related_entity: related_entity.to_h
+        }
+      end
+    end
+  end
+end

data/lib/k_domain/schemas/domain/old/name_options.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class NameOptions
+      attr_accessor :name
+      attr_accessor :options
+    end
+  end
+end

data/lib/k_domain/schemas/domain/old/rails_controller.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class RailsController
+      # ToDo
+      puts 'do soemtnhi'
+    end
+  end
+end

data/lib/k_domain/schemas/domain/old/rails_model.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    # Rails model represents information that is found the model.rb class in the rails project
+    class RailsModel
+      attr_accessor :name
+      attr_accessor :name_plural
+      attr_accessor :name_original
+      attr_accessor :documentation_rel_path
+      attr_accessor :model_path
+
+      # @param [Symbol] value The value of ID has different meanings
+      # @option value :true Id column exists and it uses an Integer type
+      # @option value :false Id column does not exist
+      # @option value :bigserial Id column exists and it uses a BigSerial type
+      attr_accessor :id
+
+      attr_accessor :force
+      attr_accessor :primary_key
+      attr_accessor :quirks
+
+      attr_accessor :ruby_raw
+      attr_accessor :ruby_code
+      attr_accessor :ruby_frozen
+      attr_accessor :ruby_header
+      attr_accessor :ruby_code_public
+      attr_accessor :ruby_code_private
+
+      attr_accessor :default_scope
+      attr_accessor :scopes
+      attr_accessor :public_class_methods
+      attr_accessor :public_instance_methods
+      attr_accessor :private_instance_methods
+
+      # stats
+      attr_accessor :time_stamp1
+      attr_accessor :time_stamp2
+      attr_accessor :time_stamp3
+
+      def code_length
+        ruby_raw&.length
+      end
+
+      def display_quirks
+        quirks.join(' ')
+      end
+
+      def exists?
+        File.exist?(model_path)
+      end
+
+      def initialize
+        @quirks = []
+      end
+
+      def add_quirk(quirk)
+        @quirks << quirk
+      end
+
+      def to_h
+        {
+          name: name,
+          name_plural: name_plural,
+          name_original: name_original,
+          documentation_rel_path: documentation_rel_path,
+          model_path: model_path,
+          id: id,
+          force: force,
+          primary_key: primary_key,
+          quirks: quirks,
+          ruby_raw: ruby_raw,
+          ruby_code: ruby_code,
+          ruby_frozen: ruby_frozen,
+          ruby_header: ruby_header,
+          ruby_code_public: ruby_code_public,
+          ruby_code_private: ruby_code_private,
+          default_scope: default_scope,
+          scopes: scopes,
+          public_class_methods: public_class_methods,
+          public_instance_methods: public_instance_methods,
+          private_instance_methods: private_instance_methods,
+          time_stamp1: time_stamp1,
+          time_stamp2: time_stamp2,
+          time_stamp3: time_stamp3,
+          code_length: code_length,
+          exists: exists?
+        }
+      end
+    end
+  end
+end

data/lib/k_domain/schemas/domain/old/related_entity.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class RelatedEntity
+      # Name of the entity model
+      attr_accessor :name
+      attr_accessor :name_plural
+      attr_accessor :main_key
+
+      attr_accessor :trait1
+      attr_accessor :trait2
+      attr_accessor :trait3
+
+      def initialize(entity)
+        @name        = entity.name
+        @name_plural = entity.name_plural
+        @main_key    = entity.main_key
+        @trait1      = entity.trait1
+        @trait2      = entity.trait2
+        @trait3      = entity.trait3
+      end
+
+      def to_h
+        {
+          name: name,
+          name_plural: name_plural,
+          main_key: main_key,
+          trait1: trait1,
+          trait2: trait2,
+          trait3: trait3
+        }
+      end
+    end
+  end
+end

data/lib/k_domain/schemas/domain/old/statistics.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+# module KDomain
+#   module DomainModel
+#     # Rails model represents information that is found the model.rb class in the rails project
+#     class Statistics
+#       attr_accessor :column_counts
+#       attr_accessor :code_counts
+#       attr_accessor :code_dsl_counts
+#       attr_accessor :data_counts
+#       attr_accessor :issues
+
+#       def initialize(meta)
+#         @column_counts = OpenStruct.new(meta[:column_counts])
+#         @code_counts = OpenStruct.new(meta[:code_counts])
+#         @code_dsl_counts = OpenStruct.new(meta[:code_dsl_counts])
+#         @data_counts = OpenStruct.new(meta[:data_counts])
+#         @issues = meta[:issues]
+#       end
+#     end
+#   end
+# end

data/lib/k_domain/schemas/domain/old/validate.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class Validate
+      KEYS = [:on].freeze
+
+      attr_accessor :methods
+
+      attr_accessor :on
+
+      def format_on
+        for_template(on)
+      end
+
+      def for_template(value)
+        return nil if value.nil?
+        return value.to_s if value.is_a?(Hash)
+        return ":#{value}" if value.is_a?(Symbol)
+
+        value
+      end
+    end
+  end
+end

data/lib/k_domain/schemas/domain/old/validates.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class Validates
+      KEYS = %i[length unless format presence].freeze
+
+      attr_accessor :name
+
+      attr_accessor :length
+      attr_accessor :unless
+      attr_accessor :format
+      attr_accessor :presence
+
+      def format_length
+        for_template(length)
+      end
+
+      def format_unless
+        for_template(self.unless)
+      end
+
+      def format_format
+        for_template(self.format)
+      end
+
+      def format_presence
+        for_template(presence)
+      end
+
+      def for_template(value)
+        return nil if value.nil?
+        return value.to_s if value.is_a?(Hash)
+        return ":#{value}" if value.is_a?(Symbol)
+
+        value
+      end
+
+      def to_h
+        {
+          name: name,
+          length: length,
+          unless: self.unless,
+          format: self.format,
+          presence: presence
+        }
+      end
+    end
+  end
+end

data/lib/k_domain/schemas/domain_model.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# DomainModel holds the entire domain model including database and ancillary information
+module KDomain
+  module Schemas
+    class DomainModel < Dry::Struct
+      attribute :domain         , KDomain::DomainModel::Domain
+      attribute :database       , KDomain::Database::Schema
+      attribute :dictionary     , KDomain::Schemas::Dictionary
+      attribute :rails_resource , KDomain::Schemas::RailsResource
+      attribute :investigate    , KDomain::Schemas::Investigate
+    end
+  end
+end

data/lib/k_domain/schemas/investigate.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Domain class holds a dictionary entry
+module KDomain
+  module Schemas
+    class Investigate < Dry::Struct
+      attribute :issues                 , Types::Strict::Array do
+        attribute :step                 , Types::Strict::String
+        attribute :location             , Types::Strict::String
+        attribute :key                  , Types::Strict::String.optional.default(nil)
+        attribute :message              , Types::Strict::String
+      end
+    end
+  end
+end

data/lib/k_domain/schemas/rails_resource.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Domain class holds a dictionary entry
+module KDomain
+  module Schemas
+    class RailsResource < Dry::Struct
+      attribute :models               , Types::Strict::Array do
+        attribute :model_name         , Types::Strict::String
+        attribute :table_name         , Types::Strict::String
+        attribute :file               , Types::Strict::String
+        attribute :exist              , Types::Strict::Bool
+        attribute :state              , Types::Strict::String
+      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.14'
 end

data/lib/k_domain.rb

@@ -1,14 +1,35 @@
 # frozen_string_literal: true
 
+require 'active_support/core_ext/string'
+require 'dry-struct'
 require 'k_log'
+require 'peeky'
 require 'k_domain/version'
+require 'k_domain/schemas/_'
+require 'k_domain/raw_db_schema/transform'
+require 'k_domain/raw_db_schema/load'
+require 'k_domain/domain_model/transform'
+require 'k_domain/domain_model/transform_steps/_'
+require 'k_domain/domain_model/load'
 
-
+# # This is useful if you want to initialize structures via Hash
+# class SymbolizeStruct < Dry::Struct
+#   transform_keys(&:to_sym)
+# end
 
 module KDomain
   # raise KDomain::Error, 'Sample message'
   class Error < StandardError; end
 
+  module Gem
+    def self.root
+      File.expand_path('..', File.dirname(__FILE__))
+    end
+    def self.resource(resource_path)
+      File.join(root, resource_path)
+    end
+  end
+
   # Your code goes here...
 end
 

data/templates/load_schema.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,
+        db_info: {
+          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[:db_info][: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[:db_info][: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][:db_info][: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