k_domain 0.0.2 → 0.0.15

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

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class ColumnOld
+      # DONE
+      RUBY_TYPE = {
+        string: 'String',
+        text: 'String',
+        primary_key: 'Integer', # this could be GUID in future
+        foreign_key: 'Integer', # this could be GUID in future
+        integer: 'Integer',
+        boolean: 'Boolean',
+        float: 'Float',
+        decimal: 'Decimal',
+        datetime: 'DateTime',
+        date: 'DateTime',
+        json: 'Hash',
+        jsonb: 'Hash',
+        hstore: 'Hash'
+      }.freeze
+
+      # DONE
+      CSHARP_TYPE = {
+        string: 'string',
+        text: 'string', # NEED TO DEAL WITH THIS BETTER
+        integer: 'int',
+        boolean: 'bool',
+        decimal: 'decimal',
+        float: 'double',
+        datetime: 'DateTime',
+        date: 'DateTime',
+        json: 'object',
+        jsonb: 'object',
+        hstore: 'object'
+      }.freeze
+
+      # this is used by the ruby migration files
+      # DONE
+      DB_TYPE = {
+        boolean: 'boolean',
+        primary_key: 'integer',
+        foreign_key: 'integer',
+        integer: 'integer',
+        decimal: 'decimal',
+        float: 'float',
+        datetime: 'datetime',
+        date: 'date',
+        text: 'text',
+        string: 'string',
+        json: 'json',
+        jsonb: 'jsonb',
+        hstore: 'hstore'
+      }.freeze
+
+      SIMPLE_ATTRIBS = %i[
+        name
+        name_plural
+        type
+        structure_type
+        foreign_key?
+        foreign_table
+        foreign_id
+      ].freeze
+
+      DETAILED_ATTRIBS = SIMPLE_ATTRIBS + %i[
+        title
+        required
+        reference_type
+        db_type
+        ruby_type
+        csharp_type
+        format_type
+        description
+        belongs_to
+      ]
+
+      EXTRA_ATTRIBS = DETAILED_ATTRIBS + %i[
+        precision
+        scale
+        default
+        null
+        limit
+        array
+      ]
+
+      # Name of the column
+      attr_accessor :name
+
+      # Name of the column in plural form
+      attr_accessor :name_plural
+
+      attr_accessor :type
+
+      # Human readable title
+      attr_accessor :title
+
+      # true
+      attr_accessor :required
+
+      attr_accessor :structure_type # :data, :foreign_key, :timestamp
+      attr_accessor :reference_type
+
+      # 'references' if foreign key, 'primary_key' if primary key, will map_from_type(type)) |
+      # attr_accessor :db_type
+
+      attr_accessor :format_type
+      attr_accessor :description
+
+      attr_accessor :foreign_key
+      alias foreign_key? foreign_key
+      attr_accessor :foreign_table
+      attr_accessor :belongs_to
+      # this may not always be accurate, should support override
+      attr_accessor :foreign_id
+      alias reference_table foreign_id
+
+      # Extra DB attributes
+      attr_accessor :precision
+      attr_accessor :scale
+      attr_accessor :default
+      attr_accessor :null
+      alias nullable null
+      attr_accessor :limit
+      attr_accessor :array
+
+      def format_default
+        return '' if default.nil?
+        return "\"#{default}\"" if default.is_a?(String)
+
+        #  || default.is_a?(Symbol)
+        default.to_s
+      end
+
+      def format_null
+        null.nil? ? '' : null.to_s
+      end
+
+      def format_array
+        array.nil? ? '' : array.to_s
+      end
+
+      # DONE
+      def db_type
+        return @db_type if defined? @db_type
+
+        @db_type = DB_TYPE[type] || '******'
+      end
+
+      # DONE
+      def ruby_type
+        return @ruby_type if defined? @ruby_type
+
+        @ruby_type = RUBY_TYPE[type] || '******'
+      end
+
+      # DONE
+      def csharp_type
+        return @csharp_type if defined? @csharp_type
+
+        @csharp_type = CSHARP_TYPE[type] || '******'
+      end
+
+      def debug(*flags)
+        debug_simple    if flags.include?(:simple)
+        debug_detailed  if flags.include?(:detailed)
+        debug_extra     if flags.include?(:extra)
+      end
+
+      private
+
+      def debug_simple
+        log.kv 'name'             , name
+        log.kv 'name_plural'      , name_plural
+        log.kv 'type'             , type
+        log.kv 'structure_type'   , structure_type
+      end
+
+      def debug_detailed
+        debug_simple
+        log.kv 'title'            , title
+        log.kv 'required'         , required
+        log.kv 'reference_type'   , reference_type
+        log.kv 'db_type'          , db_type
+        log.kv 'ruby_type'        , ruby_type
+        log.kv 'csharp_type'      , csharp_type
+        log.kv 'format_type'      , format_type
+        log.kv 'description'      , description
+
+        log.kv 'foreign_key?'     , foreign_key?
+        log.kv 'foreign_table'    , foreign_table
+        log.kv 'belongs_to'       , belongs_to
+        log.kv 'foreign_id'       , foreign_id
+      end
+
+      def debug_extra
+        debug_detailed
+
+        log.kv 'precision'        , precision
+        log.kv 'scale'            , scale
+        log.kv 'default'          , default
+        log.kv 'null'             , null
+        log.kv 'limit'            , limit
+        log.kv 'array'            , array
+      end
+    end
+
+    # ---------------------------------------------
+    # Available column keys that can be mapped from
+    # ---------------------------------------------
+    # name
+    # name_plural
+    # type
+    # foreign_key?
+    # foreign_table
+    # structure_type
+    # precision
+    # scale
+    # default
+    # null
+    # limit
+    # array
+    # belongs_to
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Rails model represents information that is found the model.rb class in the rails project
+module KDomain
+  module DomainModel
+    class DomainStatistics
+      attr_reader :domain
+      attr_accessor :column_counts
+      attr_accessor :code_counts
+      attr_accessor :code_dsl_counts
+      attr_accessor :data_counts
+      attr_accessor :issues
+
+      def initialize(domain)
+        @domain = domain
+        # @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
+
+      def print
+        log.warn('Statistics ::')
+        log.kv('Database Entities', domain.entities.length)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class Entity
+      # Name of the entity model
+      attr_accessor :name
+
+      # Name of the entity model in plural form
+      attr_accessor :name_plural
+
+      # @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
+
+      # Currently only has the value :cascade
+      attr_accessor :force
+
+      # Model columns
+      attr_accessor :columns
+
+      # Model relationships - one_to_one, one_to_many and many_to_many
+      attr_accessor :relations_one_to_one
+
+      # This entity has a main field that is useful for rendering and may be used for unique constraint, may also be called display_name
+      attr_accessor :main_key
+
+      attr_accessor :trait1
+      attr_accessor :trait2
+      attr_accessor :trait3
+
+      # investigate
+      attr_accessor :td_query
+
+      # Model type - :entity, :basic_user, :admin_user
+      attr_accessor :model_type
+
+      attr_accessor :rails_model
+      attr_accessor :statistics
+
+      def key?
+        !main_key.nil?
+      end
+
+      def no_key
+        main_key.nil?
+      end
+      alias keyless? no_key
+
+      # Can probably deprecate model_
+      alias model_name           name
+      alias names                name_plural
+
+      alias td_key1              trait1
+      alias td_key2              trait2
+      alias td_key3              trait3
+
+      # alias :name :student_name    # not wrong, only for getter
+      # alias :name= :student_name=  # add this for setter
+      # alias :name? :student_name?  # add this for boolean
+
+      attr_accessor :belongs_to
+      attr_accessor :has_one
+      attr_accessor :has_many
+      attr_accessor :has_and_belongs_to_many
+
+      # Needs to move into RailsModel
+      attr_accessor :validates
+      attr_accessor :validate
+
+      def relations?
+        # log.kv 'has_one', has_one.length
+        # log.kv 'has_many', has_many.length
+        # log.kv 'has_and_belongs_to_many', has_and_belongs_to_many.length
+        has_one.length.positive? || has_many.length.positive? || has_and_belongs_to_many.length.positive?
+      end
+
+      def initialize
+        @columns = []
+        @relations = []
+
+        @belongs_to = []
+        @has_one = []
+        @has_many = []
+        @has_and_belongs_to_many = []
+
+        @rails_model = nil
+        @statistics = nil
+      end
+
+      # Filter helpers
+      def filter_columns(type_of_columns)
+        case type_of_columns
+        when :columns_data
+          columns_data
+        when :columns_data_optional
+          columns_data_optional
+        when :columns_data_required
+          columns_data_required
+        when :columns_data_foreign
+          columns_data_foreign
+        when :columns_primary
+          columns_primary
+        when :columns_foreign
+          columns_foreign
+        when :columns_virtual
+          columns_virtual
+        when :columns_data_foreign_virtual
+          columns_data_foreign_virtual
+        when :columns_data_primary
+          columns_data_primary
+        when :columns_data_virtual
+          columns_data_virtual
+        else
+          columns
+        end
+      end
+
+      def to_h
+        {
+          name: name,
+          name_plural: name_plural,
+          type: type,
+          title: title,
+          required: required,
+          structure_type: structure_type,
+          reference_type: reference_type,
+          format_type: format_type,
+          description: description,
+          foreign_key: foreign_key,
+          foreign_table: foreign_table,
+          belongs_to: belongs_to,
+          foreign_id: foreign_id,
+          precision: precision,
+          scale: scale,
+          default: default,
+          null: null,
+          limit: limit,
+          array: array
+        }
+      end
+
+      # DONE
+      def columns_data
+        @columns_data ||= columns_for_structure_types(:data)
+      end
+      alias rows_fields columns_data
+
+      # TODO
+      def columns_data_optional
+        @columns_data_optional ||= columns_for_structure_types(:data).select { |_c| true }
+      end
+
+      # TODO
+      def columns_data_required
+        @columns_data_required ||= columns_for_structure_types(:data).select { |_c| false }
+      end
+
+      # DONE
+      def columns_primary
+        @columns_primary ||= columns_for_structure_types(:primary_key)
+      end
+
+      # DONE
+      def columns_foreign
+        @columns_foreign ||= columns_for_structure_types(:foreign_key)
+      end
+
+      # DONE
+      def columns_timestamp
+        @columns_data_timestamp ||= columns_for_structure_types(:timestamp)
+      end
+
+      # DONE
+      def columns_deleted_at
+        @columns_data_deleted_at ||= columns_for_structure_types(:deleted_at)
+      end
+
+      # DONE
+      def columns_virtual
+        @columns_virtual ||= columns_for_structure_types(:timestamp, :deleted_at)
+      end
+
+      # DONE
+      def columns_data_foreign
+        @columns_data_foreign ||= columns_for_structure_types(:data, :foreign_key)
+      end
+      alias rows_fields_and_fk columns_data_foreign
+
+      # DONE
+      def columns_data_primary
+        @columns_data_primary ||= columns_for_structure_types(:data, :primary_key)
+      end
+      alias rows_fields_and_pk columns_data_primary
+
+      # DONE
+      def columns_data_virtual
+        @columns_data_virtual ||= columns_for_structure_types(:data, :timestamp, :deleted_at)
+      end
+      alias rows_fields_and_virtual columns_data_virtual
+
+      # DONE
+      def columns_data_foreign_virtual
+        @columns_data_foreign_virtual ||= columns_for_structure_types(:data, :foreign_key, :timestamp, :deleted_at)
+      end
+
+      # DONE
+      def columns_for_structure_types(*structure_types)
+        columns.select { |column| structure_types.include?(column.structure_type) }
+      end
+
+      # Debug helpers
+
+      def debug(*flags)
+        debug_simple   if flags.include?(:simple)
+        debug_detailed if flags.include?(:detailed)
+        debug_extra    if flags.include?(:extra)
+
+        debug_columns(*flags)
+        debug_belongs_to(*flags)
+        debug_has_one(*flags)
+        debug_has_many(*flags)
+        debug_has_and_belongs_to_many(*flags)
+        # log.kv 'relations'    , relations
+      end
+
+      def debug_simple
+        log.kv 'name'         , name
+        log.kv 'name_plural'  , name_plural
+        log.kv 'main_key'     , main_key
+        log.kv 'model_type'   , model_type
+      end
+
+      def debug_detailed
+        debug_simple
+        log.kv 'id'           , id
+        log.kv 'trait1'       , trait1
+        log.kv 'trait2'       , trait2
+        log.kv 'trait3'       , trait3
+        log.kv 'td_query'     , td_query
+        log.kv 'key?'         , key?
+        log.kv 'no_key'       , no_key
+      end
+
+      def debug_extra
+        debug_detailed
+        log.kv 'force'        , force
+      end
+
+      def debug_columns(*flags, column_list: columns)
+        c_simple            = flags.include?(:columns_simple)
+        c_detailed          = flags.include?(:columns_detailed)
+        c_extra             = flags.include?(:columns_extra)
+        c_tabular           = flags.include?(:columns_tabular_simple) || flags.include?(:columns_tabular)
+        c_tabular_detailed  = flags.include?(:columns_tabular_detailed)
+        c_tabular_extra     = flags.include?(:columns_tabular_extra)
+
+        return unless c_simple || c_detailed || c_extra || c_tabular || c_tabular_detailed || c_tabular_extra
+
+        log.section_heading('columns')
+
+        column_list.each { |column| column.debug(:simple) }   if c_simple
+        column_list.each { |column| column.debug(:detailed) } if c_detailed
+        column_list.each { |column| column.debug(:extra) }    if c_extra
+        tp column_list, *Column::SIMPLE_ATTRIBS               if c_tabular
+        tp column_list, *Column::DETAILED_ATTRIBS             if c_tabular_detailed
+        tp column_list, *Column::EXTRA_ATTRIBS                if c_tabular_extra
+      end
+
+      def debug_belongs_to(*flags)
+        c_simple = flags.include?(:belongs_to_tabular)
+
+        return unless c_simple && belongs_to.length.positive?
+
+        log.section_heading('belongs_to')
+
+        tp belongs_to, :name, :model_name, :model_name_plural, *BelongsTo::KEYS
+      end
+
+      def debug_has_one(*flags)
+        c_simple = flags.include?(:has_one_tabular)
+
+        return unless c_simple && has_one.length.positive?
+
+        log.section_heading('has_one')
+
+        tp has_one, :name, :model_name, :model_name_plural, *HasOne::KEYS
+      end
+
+      def debug_has_many(*flags)
+        c_simple = flags.include?(:has_many_tabular)
+
+        return unless c_simple && has_many.length.positive?
+
+        log.section_heading('has_many')
+
+        tp has_many, :name, :model_name, :model_name_plural, *HasMany::KEYS
+      end
+
+      def debug_has_and_belongs_to_many(*flags)
+        c_simple = flags.include?(:has_and_belongs_to_many_tabular)
+
+        return unless c_simple && has_and_belongs_to_many.length.positive?
+
+        log.section_heading('has_and_belongs_to_many')
+
+        tp has_and_belongs_to_many, :name, :model_name, :model_name_plural, *HasAndBelongsToMany::KEYS
+      end
+    end
+    # ---------------------------------------------
+    # Available entity keys that can be mapped from
+    # ---------------------------------------------
+    # name
+    # name_plural
+    # id
+    # force
+    # created
+    # updated
+    # columns
+    # data_columns
+    # foreign_columns
+    # belongs
+    # has_one
+    # has_many
+    # has_and_belongs_to_many
+    # class_methods
+    # public_class_methods
+    # private_class_methods
+    # instance_methods
+    # public_instance_methods
+    # private_instance_methods
+    # default_scope
+    # scopes
+    # meta
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Rails model represents information that is found the model.rb class in the rails project
+module KDomain
+  module DomainModel
+    class EntityStatistics
+      attr_accessor :column_counts
+      attr_accessor :code_counts
+      attr_accessor :code_dsl_counts
+      attr_accessor :data_counts
+      attr_accessor :issues
+
+      def initialize(entity)
+        # @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/foreign_key.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class ForeignKey
+      KEYS = %i[column name on_update on_delete].freeze
+
+      attr_accessor :left
+      attr_accessor :right
+
+      attr_accessor :column
+      attr_accessor :name
+      attr_accessor :on_update
+      attr_accessor :on_delete
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class HasAndBelongsToMany
+      KEYS = %i[a_lambda autosave code_duplicate].freeze
+
+      attr_accessor :name
+
+      attr_accessor :model_name
+      attr_accessor :model_name_plural
+
+      attr_accessor :a_lambda
+      attr_accessor :autosave
+
+      attr_accessor :related_entity
+      attr_accessor :code_duplicate
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module KDomain
+  module DomainModel
+    class HasMany
+      KEYS = %i[a_lambda as dependent through class_name inverse_of primary_key foreign_key source code_duplicate].freeze
+
+      attr_accessor :name
+
+      attr_accessor :model_name
+      attr_accessor :model_name_plural
+
+      attr_accessor :a_lambda
+      attr_accessor :as
+      attr_accessor :dependent
+      attr_accessor :through
+      attr_accessor :class_name
+      attr_accessor :inverse_of
+      attr_accessor :primary_key
+      attr_accessor :foreign_key
+      attr_accessor :source
+
+      attr_accessor :related_entity
+      attr_accessor :code_duplicate
+    end
+  end
+end