k_domain 0.0.2 → 0.0.15

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.2'
+  VERSION = '0.0.15'
 end

data/lib/k_domain.rb

@@ -1,13 +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/raw_schema/transform'
+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/{lib/k_domain/raw_schema/template.rb → templates/load_schema.rb}

@@ -11,7 +11,7 @@ class LoadSchema
       indexes: [],
       meta: {
         rails: @rails_version,
-        database: {
+        db_info: {
           type: 'postgres',
           version: nil,         # TODO
           extensions: []
@@ -50,14 +50,14 @@ class LoadSchema
     sort
     # code to time
 
-    # log.kv 'extensions', schema[:database][:extensions].length
+    # 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[:database][:extensions]
+    # 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')
@@ -74,7 +74,7 @@ class LoadSchema
 
   def enable_extension(name)
     # puts "enable_extension(#{name})"
-    schema[:meta][:database][:extensions] << name
+    schema[:meta][:db_info][:extensions] << name
   end
 
   def create_table(name, **opts)

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: k_domain
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.15
 platform: ruby
 authors:
 - David Cruwys
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-26 00:00:00.000000000 Z
+date: 2021-10-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: k_log
   requirement: !ruby/object:Gem::Requirement
@@ -24,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.0.0
+- !ruby/object:Gem::Dependency
+  name: peeky
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.0
 description: "    K Domain builds complex domain schemas by combining the database
   schema with a rich entity relationship DSLs\n"
 email:
@@ -53,9 +95,51 @@ 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/domain_model/load.rb
+- 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/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/dictionary.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
+- lib/k_domain/schemas/domain/old/entity.rb
+- lib/k_domain/schemas/domain/old/entity_statistics.rb
+- lib/k_domain/schemas/domain/old/foreign_key.rb
+- lib/k_domain/schemas/domain/old/has_and_belongs_to_many.rb
+- lib/k_domain/schemas/domain/old/has_many.rb
+- lib/k_domain/schemas/domain/old/has_one.rb
+- lib/k_domain/schemas/domain/old/name_options.rb
+- lib/k_domain/schemas/domain/old/rails_controller.rb
+- lib/k_domain/schemas/domain/old/rails_model.rb
+- lib/k_domain/schemas/domain/old/related_entity.rb
+- lib/k_domain/schemas/domain/old/statistics.rb
+- lib/k_domain/schemas/domain/old/validate.rb
+- lib/k_domain/schemas/domain/old/validates.rb
+- lib/k_domain/schemas/domain_model.rb
+- lib/k_domain/schemas/investigate.rb
+- lib/k_domain/schemas/rails_resource.rb
 - lib/k_domain/version.rb
+- templates/load_schema.rb
 homepage: http://appydave.com/gems/k-domain
 licenses:
 - MIT