database_consistency 1.3.3 → 1.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 857156332ffa36d32216953b8bd1f798ae27dcb2037e873c93d08fa55a01bd47
-  data.tar.gz: f1aa19a34377de90e606b1e8272d9444992e44f6487c0ac28d913298d5ef6df9
+  metadata.gz: 8f935ca51faca06dad689d217e897a035253f4ce9884f1826befdf1bcbbee3b5
+  data.tar.gz: 38bde32ffee8b05b04bc8a1af261764f967b64f322352ef8d79729f1de485e13
 SHA512:
-  metadata.gz: 635ac9cfa1426f77ec59647e7282887fcfc81ec2db8217a545f791383bc1e3538f8f2e5bcb55c1aedee194b27287063a0ee330ffafe0068a7c219f2350a421b9
-  data.tar.gz: f72cf3ef8ac71296984002d798b895740fc15ec91e582503fde012d8b58986956e36bd41bfae5453abb374da27a20f92bbcf96fbfe2abdddf3fe8f2569be3f48
+  metadata.gz: 2352fa358c91e6dbec9a22c9abac34fb27b45e662c1402e88cfe94864b7bfa4966628f246a6f6f5d6c6af323e1320a3fe03c74df644f86ec6d14e4bde7c81962
+  data.tar.gz: ad812a3ce4c8d4d0a7d24d9031815a26ae2c32bfca6d0721430f3c31f01d8c5910f4af091fb7d088e4860d65d887ba0a27531bdd0d8aefc50b589a944ef29290

data/lib/database_consistency/checkers/association_checkers/foreign_key_checker.rb

@@ -14,15 +14,6 @@ module DatabaseConsistency
           @foreign_table = foreign_table
           @foreign_key = foreign_key
         end
-
-        def attributes
-          super.merge(
-            primary_table: primary_table,
-            primary_key: primary_key,
-            foreign_table: foreign_table,
-            foreign_key: foreign_key
-          )
-        end
       end
 
       private

data/lib/database_consistency/checkers/association_checkers/foreign_key_type_checker.rb

@@ -4,27 +4,22 @@ module DatabaseConsistency
   module Checkers
     # This class checks if association's foreign key type covers associated model's primary key (same or bigger)
     class ForeignKeyTypeChecker < AssociationChecker
-      class Report < DatabaseConsistency::Report # :nodoc:
-        attr_reader :pk_name, :pk_type, :fk_name, :fk_type
-
-        def initialize(fk_name: nil, fk_type: nil, pk_name: nil, pk_type: nil, **args)
-          super(**args)
-          @fk_name = fk_name
-          @fk_type = fk_type
-          @pk_name = pk_name
-          @pk_type = pk_type
+      ALLOWED_TYPES =
+
+        class Report < DatabaseConsistency::Report # :nodoc:
+          attr_reader :pk_name, :pk_type, :fk_name, :fk_type, :table_to_change, :type_to_set
+
+          def initialize(fk_name: nil, fk_type: nil, pk_name: nil, pk_type: nil, table_to_change: nil, type_to_set: nil, **args) # rubocop:disable Metrics/ParameterLists, Layout/LineLength
+            super(**args)
+            @table_to_change = table_to_change
+            @type_to_set = type_to_set
+            @fk_name = fk_name
+            @fk_type = fk_type
+            @pk_name = pk_name
+            @pk_type = pk_type
+          end
         end
 
-        def attributes
-          super.merge(
-            fk_name: fk_name,
-            fk_type: fk_type,
-            pk_name: pk_name,
-            pk_type: pk_type
-          )
-        end
-      end
-
       private
 
       # We skip check when:
@@ -46,9 +41,11 @@ module DatabaseConsistency
       # | ------------- | ------ |
       # | covers        | ok     |
       # | doesn't cover | fail   |
-      def check # rubocop:disable Metrics/MethodLength
+      def check # rubocop:disable Metrics/MethodLength,  Metrics/AbcSize
         if converted_type(associated_column).cover?(converted_type(primary_column))
           report_template(:ok)
+        elsif !(converted_type(associated_column).numeric? && converted_type(primary_column).numeric?)
+          report_template(:ok)
         else
           report_template(:fail, error_slug: :inconsistent_types)
         end
@@ -61,11 +58,13 @@ module DatabaseConsistency
         )
       end
 
-      def report_template(status, error_slug: nil)
+      def report_template(status, error_slug: nil) # rubocop:disable Metrics/MethodLength
         Report.new(
           status: status,
           error_slug: error_slug,
           error_message: nil,
+          table_to_change: table_to_change,
+          type_to_set: converted_type(primary_column).convert,
           fk_type: converted_type(associated_column).type,
           fk_name: associated_key,
           pk_type: converted_type(primary_column).type,
@@ -74,6 +73,14 @@ module DatabaseConsistency
         )
       end
 
+      def table_to_change
+        @table_to_change ||= if belongs_to_association?
+                               association.active_record.table_name
+                             else
+                               association.klass.table_name
+                             end
+      end
+
       # @return [String]
       def primary_key
         @primary_key ||= if belongs_to_association?

data/lib/database_consistency/checkers/association_checkers/missing_index_checker.rb

@@ -4,6 +4,16 @@ module DatabaseConsistency
   module Checkers
     # This class checks if association's foreign key has index in the database
     class MissingIndexChecker < AssociationChecker
+      class Report < DatabaseConsistency::Report # :nodoc:
+        attr_reader :table_name, :columns
+
+        def initialize(table_name:, columns:, **args)
+          super(**args)
+          @table_name = table_name
+          @columns = columns
+        end
+      end
+
       private
 
       # We skip check when:
@@ -48,6 +58,17 @@ module DatabaseConsistency
         end
       end
 
+      def report_template(status, error_slug: nil)
+        Report.new(
+          status: status,
+          error_slug: error_slug,
+          error_message: nil,
+          table_name: association.klass.table_name,
+          columns: association_keys,
+          **report_attributes
+        )
+      end
+
       def unique_has_one_association?
         association.scope.nil? && association.macro == :has_one && !association.options[:as].present?
       end

data/lib/database_consistency/checkers/column_checkers/null_constraint_checker.rb

@@ -11,10 +11,6 @@ module DatabaseConsistency
           super(**args)
           @association_name = association_name
         end
-
-        def attributes
-          super.merge(association_name: association_name)
-        end
       end
 
       private

data/lib/database_consistency/checkers/column_checkers/primary_key_type_checker.rb

@@ -4,9 +4,24 @@ module DatabaseConsistency
   module Checkers
     # This class checks missing presence validator
     class PrimaryKeyTypeChecker < ColumnChecker
+      class Report < DatabaseConsistency::Report # :nodoc:
+        attr_reader :fk_name, :table_to_change, :type_to_set
+
+        def initialize(fk_name: nil, table_to_change: nil, type_to_set: nil, **args)
+          super(**args)
+          @table_to_change = table_to_change
+          @type_to_set = type_to_set
+          @fk_name = fk_name
+        end
+      end
+
       private
 
       VALID_TYPES = %w[bigserial bigint uuid].freeze
+      VALID_TYPES_MAP = {
+        'serial' => 'bigserial',
+        'integer' => 'bigint'
+      }.freeze
       SQLITE_ADAPTER_NAME = 'SQLite'
 
       # We skip check when:
@@ -21,14 +36,26 @@ module DatabaseConsistency
       # | --------------------- | ------ |
       # | yes                   | ok     |
       # | no                    | fail   |
-      def check
+      def check # rubocop:disable Metrics/MethodLength
         if valid?
           report_template(:ok)
         else
-          report_template(:fail, error_slug: :small_primary_key)
+          Report.new(
+            status: :fail,
+            error_slug: :small_primary_key,
+            error_message: nil,
+            table_to_change: model.table_name,
+            fk_name: column.name,
+            type_to_set: type_to_set,
+            **report_attributes
+          )
         end
       end
 
+      def type_to_set
+        VALID_TYPES_MAP[column.sql_type.to_s] || 'bigserial'
+      end
+
       # @return [Boolean]
       def valid?
         VALID_TYPES.any? do |type|

data/lib/database_consistency/checkers/index_checkers/redundant_index_checker.rb

@@ -12,10 +12,6 @@ module DatabaseConsistency
           @covered_index_name = covered_index_name
           @index_name = index_name
         end
-
-        def attributes
-          super.merge(covered_index_name: covered_index_name, index_name: index_name)
-        end
       end
 
       private

data/lib/database_consistency/checkers/index_checkers/redundant_unique_index_checker.rb

@@ -5,15 +5,12 @@ module DatabaseConsistency
     # This class checks redundant database indexes
     class RedundantUniqueIndexChecker < IndexChecker
       class Report < DatabaseConsistency::Report # :nodoc:
-        attr_reader :index_name
+        attr_reader :index_name, :covered_index_name
 
-        def initialize(index_name:, **args)
+        def initialize(covered_index_name:, index_name:, **args)
           super(**args)
           @index_name = index_name
-        end
-
-        def attributes
-          super.merge(index_name: index_name)
+          @covered_index_name = covered_index_name
         end
       end
 
@@ -31,13 +28,14 @@ module DatabaseConsistency
       # | provided   | ok     |
       # | redundant  | fail   |
       #
-      def check
+      def check # rubocop:disable Metrics/MethodLength
         if covered_by_index
           Report.new(
             status: :fail,
             error_slug: :redundant_unique_index,
             error_message: nil,
-            index_name: covered_by_index.name,
+            index_name: index.name,
+            covered_index_name: covered_by_index.name,
             **report_attributes
           )
         else

data/lib/database_consistency/checkers/validator_checkers/missing_unique_index_checker.rb

@@ -4,6 +4,16 @@ module DatabaseConsistency
   module Checkers
     # This class checks if uniqueness validator has unique index in the database
     class MissingUniqueIndexChecker < ValidatorChecker
+      class Report < DatabaseConsistency::Report # :nodoc:
+        attr_reader :table_name, :columns
+
+        def initialize(table_name:, columns:, **args)
+          super(**args)
+          @table_name = table_name
+          @columns = columns
+        end
+      end
+
       def column_or_attribute_name
         @column_or_attribute_name ||= Helper.uniqueness_validator_columns(attribute, validator, model).join('+')
       end
@@ -21,11 +31,18 @@ module DatabaseConsistency
       # | ------------ | ------ |
       # | persisted    | ok     |
       # | missing      | fail   |
-      def check
+      def check # rubocop:disable Metrics/MethodLength
         if unique_index
           report_template(:ok)
         else
-          report_template(:fail, error_slug: :missing_unique_index)
+          Report.new(
+            status: :fail,
+            error_slug: :missing_unique_index,
+            error_message: nil,
+            table_name: model.table_name,
+            columns: sorted_uniqueness_validator_columns,
+            **report_attributes
+          )
         end
       end
 

data/lib/database_consistency/checkers/validators_fraction_checkers/column_presence_checker.rb

@@ -14,10 +14,6 @@ module DatabaseConsistency
           @table_name = table_name
           @column_name = column_name
         end
-
-        def attributes
-          super.merge(table_name: table_name, column_name: column_name)
-        end
       end
 
       private

data/lib/database_consistency/databases/types/base.rb

@@ -7,6 +7,8 @@ module DatabaseConsistency
       class Base
         attr_reader :type
 
+        NUMERIC_TYPES = %w[bigserial serial bigint integer smallint].freeze
+
         COVERED_TYPES = {
           'bigint' => %w[integer bigint],
           'integer' => %w[integer smallint]
@@ -22,6 +24,10 @@ module DatabaseConsistency
           type
         end
 
+        def numeric?
+          NUMERIC_TYPES.include?(convert)
+        end
+
         # @param [DatabaseConsistency::Databases::Types::Base]
         #
         # @return [Boolean]

data/lib/database_consistency/report.rb

@@ -12,12 +12,5 @@ module DatabaseConsistency
       @error_slug = error_slug
       @error_message = error_message
     end
-
-    def attributes
-      {
-        error_slug: error_slug,
-        error_message: error_message
-      }
-    end
   end
 end

data/lib/database_consistency/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DatabaseConsistency
-  VERSION = '1.3.3'
+  VERSION = '1.3.5'
 end

data/lib/database_consistency/writers/autofix/association_missing_index.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Autofix
+      class AssociationMissingIndex < MigrationBase # :nodoc:
+        def attributes
+          {
+            table_name: report.table_name,
+            columns: columns,
+            index_name: index_name
+          }
+        end
+
+        private
+
+        def migration_name
+          "add_#{report.table_name}_#{columns_key}_index"
+        end
+
+        def template_path
+          File.join(__dir__, 'templates', 'association_missing_index.tt')
+        end
+
+        def columns
+          "%w[#{report.columns.join(' ')}]"
+        end
+
+        def columns_key
+          report.columns.join('_').gsub('(', '_').gsub(')', '_')
+        end
+
+        def index_name
+          "index_#{report.table_name}_#{columns_key}".first(63)
+        end
+      end
+    end
+  end
+end

data/lib/database_consistency/writers/autofix/has_one_missing_unique_index.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Autofix
+      class HasOneMissingUniqueIndex < AssociationMissingIndex # :nodoc:
+        def attributes
+          super.merge(unique: true)
+        end
+
+        private
+
+        def template_path
+          File.join(__dir__, 'templates', 'has_one_missing_unique_index.tt')
+        end
+      end
+    end
+  end
+end

data/lib/database_consistency/writers/autofix/inconsistent_types.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Autofix
+      class InconsistentTypes < MigrationBase # :nodoc:
+        def attributes
+          {
+            table_to_change: report.table_to_change,
+            type_to_set: report.type_to_set,
+            fk_name: report.fk_name
+          }
+        end
+
+        private
+
+        def migration_name
+          "change_#{report.table_to_change}_#{report.fk_name}_to_#{report.type_to_set}"
+        end
+
+        def template_path
+          File.join(__dir__, 'templates', 'inconsistent_types.tt')
+        end
+      end
+    end
+  end
+end

data/lib/database_consistency/writers/autofix/migration_base.rb

@@ -10,10 +10,14 @@ module DatabaseConsistency
           File.write(migration_path(migration_name), migration)
         end
 
+        def attributes
+          {}
+        end
+
         private
 
         def migration
-          File.read(template_path) % report.attributes.merge(migration_configuration(migration_name))
+          File.read(template_path) % attributes.merge(migration_configuration(migration_name))
         end
       end
     end

data/lib/database_consistency/writers/autofix/missing_foreign_key.rb

@@ -4,6 +4,15 @@ module DatabaseConsistency
   module Writers
     module Autofix
       class MissingForeignKey < MigrationBase # :nodoc:
+        def attributes
+          {
+            foreign_table: report.foreign_table,
+            foreign_key: report.foreign_key,
+            primary_table: report.primary_table,
+            primary_key: report.primary_key
+          }
+        end
+
         private
 
         def migration_name

data/lib/database_consistency/writers/autofix/null_constraint_missing.rb

@@ -4,6 +4,13 @@ module DatabaseConsistency
   module Writers
     module Autofix
       class NullConstraintMissing < MigrationBase # :nodoc:
+        def attributes
+          {
+            table_name: report.table_name,
+            column_name: report.column_name
+          }
+        end
+
         private
 
         def migration_name

data/lib/database_consistency/writers/autofix/redundant_index.rb

@@ -4,6 +4,12 @@ module DatabaseConsistency
   module Writers
     module Autofix
       class RedundantIndex < MigrationBase # :nodoc:
+        def attributes
+          {
+            index_name: report.index_name
+          }
+        end
+
         private
 
         def migration_name

data/lib/database_consistency/writers/autofix/templates/association_missing_index.tt

@@ -0,0 +1,5 @@
+class %<migration_name>s < ActiveRecord::Migration[%<migration_version>s]
+  def change
+    add_index :%<table_name>s, %<columns>s, name: :%<index_name>s
+  end
+end

data/lib/database_consistency/writers/autofix/templates/has_one_missing_unique_index.tt

@@ -0,0 +1,5 @@
+class %<migration_name>s < ActiveRecord::Migration[%<migration_version>s]
+  def change
+    add_index :%<table_name>s, %<columns>s, name: :%<index_name>s, unique: true
+  end
+end

data/lib/database_consistency/writers/autofix/templates/inconsistent_types.tt

@@ -0,0 +1,5 @@
+class %<migration_name>s < ActiveRecord::Migration[%<migration_version>s]
+  def change
+    change_column :%<table_to_change>s, :%<fk_name>s, :%<type_to_set>s
+  end
+end

data/lib/database_consistency/writers/autofix/templates/null_constraint_missing.tt

@@ -1,5 +1,5 @@
 class %<migration_name>s < ActiveRecord::Migration[%<migration_version>s]
   def change
-    change_column_null(:%<table_name>s, :%<column_name>s, false)
+    change_column_null :%<table_name>s, :%<column_name>s, false
   end
 end

data/lib/database_consistency/writers/autofix_writer.rb

@@ -6,35 +6,43 @@ module DatabaseConsistency
     # The simplest formatter
     class AutofixWriter < BaseWriter
       SLUG_TO_GENERATOR = {
+        association_missing_index: Autofix::AssociationMissingIndex,
+        association_missing_null_constraint: Autofix::NullConstraintMissing,
+        has_one_missing_unique_index: Autofix::HasOneMissingUniqueIndex,
+        inconsistent_types: Autofix::InconsistentTypes,
         missing_foreign_key: Autofix::MissingForeignKey,
+        missing_unique_index: Autofix::HasOneMissingUniqueIndex,
         null_constraint_missing: Autofix::NullConstraintMissing,
-        association_missing_null_constraint: Autofix::NullConstraintMissing,
-        redundant_index: Autofix::RedundantIndex
+        redundant_index: Autofix::RedundantIndex,
+        redundant_unique_index: Autofix::RedundantIndex,
+        small_primary_key: Autofix::InconsistentTypes
       }.freeze
 
       def write
-        reports.each do |report|
-          next unless fix?(report)
-
-          fix(report)
-        end
+        unique_generators.each(&:fix!)
       end
 
       private
 
-      def reports
-        results.then(&Helpers::Pipes.method(:unique))
+      def unique_generators
+        results
+          .select(&method(:fix?))
+          .map(&method(:generator))
+          .compact
+          .uniq(&method(:unique_key))
       end
 
       def fix?(report)
         report.status == :fail
       end
 
-      def fix(report)
+      def generator(report)
         klass = SLUG_TO_GENERATOR[report.error_slug]
-        return unless klass
+        klass&.new(report)
+      end
 
-        klass.new(report).fix!
+      def unique_key(report)
+        [report.class, report.attributes]
       end
     end
   end

data/lib/database_consistency/writers/simple/base.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class Base # :nodoc:
+        COLORS = {
+          blue: "\e[34m",
+          yellow: "\e[33m",
+          green: "\e[32m",
+          red: "\e[31m"
+        }.freeze
+
+        COLOR_BY_STATUS = {
+          ok: :green,
+          warning: :yellow,
+          fail: :red
+        }.freeze
+
+        def self.with(text)
+          Class.new(self) do
+            define_method :template do
+              text
+            end
+          end
+        end
+
+        attr_reader :report, :config
+
+        def initialize(report, config:)
+          @report = report
+          @config = config
+        end
+
+        def msg
+          "#{report.checker_name} #{status_text} #{key_text} #{message_text}"
+        end
+
+        private
+
+        def message_text
+          template % attributes
+        end
+
+        def attributes
+          {}
+        end
+
+        def key_text
+          "#{colorize(report.table_or_model_name, :blue)} #{colorize(report.column_or_attribute_name, :yellow)}"
+        end
+
+        def colorize(text, color)
+          return text unless config.colored? && color
+
+          "#{COLORS[color]}#{text}\e[0m"
+        end
+
+        def status_text
+          color = COLOR_BY_STATUS[report.status]
+
+          colorize(report.status, color)
+        end
+      end
+    end
+  end
+end

data/lib/database_consistency/writers/simple/error_message.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class ErrorMessage < Base # :nodoc:
+        private
+
+        def template
+          report.error_message || ''
+        end
+      end
+    end
+  end
+end

data/lib/database_consistency/writers/simple/inconsistent_types.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class InconsistentTypes < Base # :nodoc:
+        private
+
+        def template
+          "foreign key %<fk_name>s with type %<fk_type>s doesn't cover primary key %<pk_name>s with type %<pk_type>s"
+        end
+
+        def attributes
+          {
+            fk_name: report.fk_name,
+            fk_type: report.fk_type,
+            pk_name: report.pk_name,
+            pk_type: report.pk_type
+          }
+        end
+      end
+    end
+  end
+end

data/lib/database_consistency/writers/simple/null_constraint_association_misses_validator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class NullConstraintAssociationMissesValidator < Base # :nodoc:
+        private
+
+        def template
+          'column is required in the database but do not have presence validator for association %<association_name>s'
+        end
+
+        def attributes
+          {
+            association_name: report.association_name
+          }
+        end
+      end
+    end
+  end
+end

data/lib/database_consistency/writers/simple/redundant_index.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class RedundantIndex < Base # :nodoc:
+        private
+
+        def template
+          'index is redundant as %<covered_index_name>s covers it'
+        end
+
+        def attributes
+          {
+            covered_index_name: report.covered_index_name
+          }
+        end
+      end
+    end
+  end
+end

data/lib/database_consistency/writers/simple/redundant_unique_index.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class RedundantUniqueIndex < Base # :nodoc:
+        private
+
+        def template
+          'index uniqueness is redundant as %<covered_index_name>s covers it'
+        end
+
+        def attributes
+          {
+            covered_index_name: report.covered_index_name
+          }
+        end
+      end
+    end
+  end
+end

data/lib/database_consistency/writers/simple_writer.rb

@@ -5,75 +5,45 @@ module DatabaseConsistency
   module Writers
     # The simplest formatter
     class SimpleWriter < BaseWriter
-      COLORS = {
-        blue: "\e[34m",
-        yellow: "\e[33m",
-        green: "\e[32m",
-        red: "\e[31m"
-      }.freeze
-
-      COLOR_BY_STATUS = {
-        ok: :green,
-        warning: :yellow,
-        fail: :red
-      }.freeze
-
-      SLUG_TO_MESSAGE = {
-        missing_foreign_key: 'should have foreign key in the database',
-        inconsistent_types: "foreign key %<fk_name>s with type %<fk_type>s doesn't cover primary key %<pk_name>s with type %<pk_type>s", # rubocop:disable Layout/LineLength
-        has_one_missing_unique_index: 'associated model should have proper unique index in the database',
-        association_missing_index: 'associated model should have proper index in the database',
-        length_validator_missing: 'column has limit in the database but do not have length validator',
-        length_validator_greater_limit: 'column has greater limit in the database than in length validator',
-        length_validator_lower_limit: 'column has lower limit in the database than in length validator',
-        null_constraint_association_misses_validator: 'column is required in the database but do not have presence validator for association %<association_name>s', # rubocop:disable Layout/LineLength
-        null_constraint_misses_validator: 'column is required in the database but do not have presence validator',
-        small_primary_key: 'column has int/serial type but recommended to have bigint/bigserial/uuid',
-        redundant_index: 'index is redundant as %<covered_index_name>s covers it',
-        redundant_unique_index: 'index uniqueness is redundant as %<index_name>s covers it',
-        missing_uniqueness_validation: 'index is unique in the database but do not have uniqueness validator',
-        missing_unique_index: 'model should have proper unique index in the database',
-        possible_null: 'column is required but there is possible null value insert',
-        null_constraint_missing: 'column should be required in the database',
-        association_missing_null_constraint: 'association foreign key column should be required in the database'
+      SLUG_TO_WRITER = {
+        association_missing_index: Simple::Base.with('associated model should have proper index in the database'),
+        association_missing_null_constraint: Simple::Base.with('association foreign key column should be required in the database'), # rubocop:disable Layout/LineLength
+        has_one_missing_unique_index: Simple::Base.with('associated model should have proper unique index in the database'), # rubocop:disable Layout/LineLength
+        inconsistent_types: Simple::InconsistentTypes,
+        length_validator_greater_limit: Simple::Base.with('column has greater limit in the database than in length validator'), # rubocop:disable Layout/LineLength
+        length_validator_lower_limit: Simple::Base.with('column has lower limit in the database than in length validator'), # rubocop:disable Layout/LineLength
+        length_validator_missing: Simple::Base.with('column has limit in the database but do not have length validator'), # rubocop:disable Layout/LineLength
+        missing_foreign_key: Simple::Base.with('should have foreign key in the database'),
+        missing_unique_index: Simple::Base.with('model should have proper unique index in the database'),
+        missing_uniqueness_validation: Simple::Base.with('index is unique in the database but do not have uniqueness validator'), # rubocop:disable Layout/LineLength
+        null_constraint_association_misses_validator: Simple::NullConstraintAssociationMissesValidator,
+        null_constraint_misses_validator: Simple::Base.with('column is required in the database but do not have presence validator'), # rubocop:disable Layout/LineLength
+        null_constraint_missing: Simple::Base.with('column should be required in the database'),
+        possible_null: Simple::Base.with('column is required but there is possible null value insert'),
+        redundant_index: Simple::RedundantIndex,
+        redundant_unique_index: Simple::RedundantUniqueIndex,
+        small_primary_key: Simple::Base.with('column has int/serial type but recommended to have bigint/bigserial/uuid')
       }.freeze
 
       def write
         results.each do |result|
           next unless write?(result.status)
 
-          puts msg(result)
+          writer = writer(result)
+
+          puts writer.msg
         end
       end
 
       private
 
-      def msg(result)
-        "#{result.checker_name} #{status_text(result)} #{key_text(result)} #{message_text(result)}"
-      end
-
       def write?(status)
         status == :fail || config.debug?
       end
 
-      def message_text(result)
-        (SLUG_TO_MESSAGE[result.error_slug] || result.error_message || '') % result.attributes
-      end
-
-      def key_text(result)
-        "#{colorize(result.table_or_model_name, :blue)} #{colorize(result.column_or_attribute_name, :yellow)}"
-      end
-
-      def status_text(result)
-        color = COLOR_BY_STATUS[result.status]
-
-        colorize(result.status, color)
-      end
-
-      def colorize(text, color)
-        return text unless config.colored? && color
-
-        "#{COLORS[color]}#{text}\e[0m"
+      def writer(report)
+        klass = SLUG_TO_WRITER[report.error_slug] || Simple::ErrorMessage
+        klass.new(report, config: config)
       end
     end
   end

data/lib/database_consistency.rb

@@ -9,16 +9,24 @@ require 'database_consistency/rescue_error'
 require 'database_consistency/errors'
 require 'database_consistency/report'
 
-require 'database_consistency/writers/helpers/pipes'
-
 require 'database_consistency/writers/base_writer'
-require 'database_consistency/writers/simple_writer'
 require 'database_consistency/writers/todo_writer'
 
+require 'database_consistency/writers/simple/base'
+require 'database_consistency/writers/simple/error_message'
+require 'database_consistency/writers/simple/inconsistent_types'
+require 'database_consistency/writers/simple/null_constraint_association_misses_validator'
+require 'database_consistency/writers/simple/redundant_index'
+require 'database_consistency/writers/simple/redundant_unique_index'
+require 'database_consistency/writers/simple_writer'
+
 require 'database_consistency/writers/autofix/helpers/migration'
 require 'database_consistency/writers/autofix/base'
 require 'database_consistency/writers/autofix/migration_base'
 require 'database_consistency/writers/autofix/missing_foreign_key'
+require 'database_consistency/writers/autofix/inconsistent_types'
+require 'database_consistency/writers/autofix/association_missing_index'
+require 'database_consistency/writers/autofix/has_one_missing_unique_index'
 require 'database_consistency/writers/autofix/redundant_index'
 require 'database_consistency/writers/autofix/null_constraint_missing'
 require 'database_consistency/writers/autofix_writer'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: database_consistency
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 1.3.5
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-11-12 00:00:00.000000000 Z
+date: 2022-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -179,18 +179,29 @@ files:
 - lib/database_consistency/rescue_error.rb
 - lib/database_consistency/templates/rails_defaults.yml
 - lib/database_consistency/version.rb
+- lib/database_consistency/writers/autofix/association_missing_index.rb
 - lib/database_consistency/writers/autofix/base.rb
+- lib/database_consistency/writers/autofix/has_one_missing_unique_index.rb
 - lib/database_consistency/writers/autofix/helpers/migration.rb
+- lib/database_consistency/writers/autofix/inconsistent_types.rb
 - lib/database_consistency/writers/autofix/migration_base.rb
 - lib/database_consistency/writers/autofix/missing_foreign_key.rb
 - lib/database_consistency/writers/autofix/null_constraint_missing.rb
 - lib/database_consistency/writers/autofix/redundant_index.rb
+- lib/database_consistency/writers/autofix/templates/association_missing_index.tt
+- lib/database_consistency/writers/autofix/templates/has_one_missing_unique_index.tt
+- lib/database_consistency/writers/autofix/templates/inconsistent_types.tt
 - lib/database_consistency/writers/autofix/templates/missing_foreign_key.tt
 - lib/database_consistency/writers/autofix/templates/null_constraint_missing.tt
 - lib/database_consistency/writers/autofix/templates/redundant_index.tt
 - lib/database_consistency/writers/autofix_writer.rb
 - lib/database_consistency/writers/base_writer.rb
-- lib/database_consistency/writers/helpers/pipes.rb
+- lib/database_consistency/writers/simple/base.rb
+- lib/database_consistency/writers/simple/error_message.rb
+- lib/database_consistency/writers/simple/inconsistent_types.rb
+- lib/database_consistency/writers/simple/null_constraint_association_misses_validator.rb
+- lib/database_consistency/writers/simple/redundant_index.rb
+- lib/database_consistency/writers/simple/redundant_unique_index.rb
 - lib/database_consistency/writers/simple_writer.rb
 - lib/database_consistency/writers/todo_writer.rb
 homepage: https://github.com/djezzzl/database_consistency

data/lib/database_consistency/writers/helpers/pipes.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module DatabaseConsistency
-  module Writers
-    module Helpers
-      module Pipes # :nodoc:
-        module_function
-
-        def unique(reports)
-          reports.uniq(&:attributes)
-        end
-      end
-    end
-  end
-end