database_consistency 1.3.4 → 1.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f1aad5cf1e4812b31d9bc7df0402f64dd32bb7ebdb9ab4ec7bf41bb195622dc
-  data.tar.gz: 1fc95e58bd89e9faf0004d7faf5cc2635d5432785d2e1a57d9965e413abf4c41
+  metadata.gz: ad00c3759184fa0098812d4cb79169f109205bff2861c37965d56c42c4da568f
+  data.tar.gz: 579087c2a52d57bac85af5fc7f9e86fa31b6c78bbaab1583128e319f9156dafb
 SHA512:
-  metadata.gz: 6d5d98750608c54e20a5f6990b54c37df89717d7009d46b099b62695b90c2a29ab44f35dab299c1e3e0f83ff4d77f5709e6a42aa7130190fcbb1807b5a6628b9
-  data.tar.gz: ff7a4d0fa92518ed33393c8e1614852ef9ec168ee5a4ac857a653881a268511ad877b982633553e7341ce8a740dbf7ae402002e991210784614e397dbe07ed36
+  metadata.gz: 206324a83d7f850bde79bb8a4399362ba7ff4f94cf848139d55781cf7e6f54d8b03d5e4641928193689c0c818c803badbcbb4f72685031f72dab26eea1f4a80a
+  data.tar.gz: 2cbaed407b168b1100de5cb6962d2fedac6ce2e8f955a5ed4811ef9d80227a2f3f396de98c9ed0a9de8c5ca751c092f389b482852663a510860cbaad85866643

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

@@ -4,17 +4,21 @@ 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
-      end
 
       private
 
@@ -37,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
@@ -52,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,
@@ -65,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/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/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/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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DatabaseConsistency
-  VERSION = '1.3.4'
+  VERSION = '1.3.6'
 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/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,11 +6,16 @@ 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_unique_index: Autofix::RedundantIndex
+        redundant_unique_index: Autofix::RedundantIndex,
+        small_primary_key: Autofix::InconsistentTypes
       }.freeze
 
       def write
@@ -36,8 +41,8 @@ module DatabaseConsistency
         klass&.new(report)
       end
 
-      def unique_key(report)
-        [report.class, report.attributes]
+      def unique_key(generator)
+        [generator.class, generator.attributes]
       end
     end
   end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class AssociationMissingIndex < Base # :nodoc:
+        private
+
+        def template
+          'associated model should have proper index in the database'
+        end
+
+        def unique_attributes
+          {
+            table_name: report.table_name,
+            columns: report.columns
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class AssociationMissingNullConstraint < Base # :nodoc:
+        private
+
+        def template
+          'association foreign key column should be required in the database'
+        end
+
+        def unique_attributes
+          {
+            table_name: report.table_name,
+            column_name: report.column_name
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -36,8 +36,16 @@ module DatabaseConsistency
           "#{report.checker_name} #{status_text} #{key_text} #{message_text}"
         end
 
+        def unique_key
+          { class: self.class }.merge(unique_attributes)
+        end
+
         private
 
+        def unique_attributes
+          raise StandardError, 'Missing the implementation'
+        end
+
         def message_text
           template % attributes
         end

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

@@ -9,6 +9,13 @@ module DatabaseConsistency
         def template
           report.error_message || ''
         end
+
+        def unique_attributes
+          {
+            template: template,
+            checker_name: report.checker_name
+          }
+        end
       end
     end
   end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class HasOneMissingUniqueIndex < Base # :nodoc:
+        private
+
+        def template
+          'associated model should have proper unique index in the database'
+        end
+
+        def unique_attributes
+          {
+            table_name: report.table_name,
+            columns: report.columns,
+            unique: true
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -18,6 +18,14 @@ module DatabaseConsistency
             pk_type: report.pk_type
           }
         end
+
+        def unique_attributes
+          {
+            table_to_change: report.table_to_change,
+            type_to_set: report.type_to_set,
+            fk_name: report.fk_name
+          }
+        end
       end
     end
   end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class LengthValidatorGreaterLimit < Base # :nodoc:
+        private
+
+        def template
+          'column has greater limit in the database than in length validator'
+        end
+
+        def unique_attributes
+          {
+            table_or_model_name: report.table_or_model_name,
+            column_or_attribute_name: report.column_or_attribute_name
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class LengthValidatorLowerLimit < Base # :nodoc:
+        private
+
+        def template
+          'column has lower limit in the database than in length validator'
+        end
+
+        def unique_attributes
+          {
+            table_or_model_name: report.table_or_model_name,
+            column_or_attribute_name: report.column_or_attribute_name
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class LengthValidatorMissing < Base # :nodoc:
+        private
+
+        def template
+          'column has limit in the database but do not have length validator'
+        end
+
+        def unique_attributes
+          {
+            table_or_model_name: report.table_or_model_name,
+            column_or_attribute_name: report.column_or_attribute_name
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class MissingForeignKey < Base # :nodoc:
+        private
+
+        def template
+          'should have foreign key in the database'
+        end
+
+        def unique_attributes
+          {
+            foreign_table: report.foreign_table,
+            foreign_key: report.foreign_key,
+            primary_table: report.primary_table,
+            primary_key: report.primary_key
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class MissingUniqueIndex < Base # :nodoc:
+        private
+
+        def template
+          'model should have proper unique index in the database'
+        end
+
+        def unique_attributes
+          {
+            table_name: report.table_name,
+            columns: report.columns,
+            unique: true
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class MissingUniquenessValidation < Base # :nodoc:
+        private
+
+        def template
+          'index is unique in the database but do not have uniqueness validator'
+        end
+
+        def unique_attributes
+          {
+            table_or_model_name: report.table_or_model_name,
+            column_or_attribute_name: report.column_or_attribute_name
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -15,6 +15,13 @@ module DatabaseConsistency
             association_name: report.association_name
           }
         end
+
+        def unique_attributes
+          {
+            table_or_model_name: report.table_or_model_name,
+            column_or_attribute_name: report.column_or_attribute_name
+          }
+        end
       end
     end
   end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class NullConstraintMissesValidator < Base # :nodoc:
+        private
+
+        def template
+          'column is required in the database but do not have presence validator'
+        end
+
+        def unique_attributes
+          {
+            table_or_model_name: report.table_or_model_name,
+            column_or_attribute_name: report.column_or_attribute_name
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class NullConstraintMissing < Base # :nodoc:
+        private
+
+        def template
+          'column should be required in the database'
+        end
+
+        def unique_attributes
+          {
+            table_name: report.table_name,
+            column_name: report.column_name
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class PossibleNull < Base # :nodoc:
+        private
+
+        def template
+          'column is required but there is possible null value insert'
+        end
+
+        def unique_attributes
+          {
+            table_or_model_name: report.table_or_model_name,
+            column_or_attribute_name: report.column_or_attribute_name
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -15,6 +15,12 @@ module DatabaseConsistency
             covered_index_name: report.covered_index_name
           }
         end
+
+        def unique_attributes
+          {
+            index_name: report.index_name
+          }
+        end
       end
     end
   end

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

@@ -15,6 +15,12 @@ module DatabaseConsistency
             covered_index_name: report.covered_index_name
           }
         end
+
+        def unique_attributes
+          {
+            index_name: report.index_name
+          }
+        end
       end
     end
   end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Simple
+      class SmallPrimaryKey < Base # :nodoc:
+        private
+
+        def template
+          'column has int/serial type but recommended to have bigint/bigserial/uuid'
+        end
+
+        def unique_attributes
+          {
+            table_or_model_name: report.table_or_model_name,
+            column_or_attribute_name: report.column_or_attribute_name
+          }
+        end
+      end
+    end
+  end
+end

data/lib/database_consistency/writers/simple_writer.rb

@@ -6,39 +6,38 @@ module DatabaseConsistency
     # The simplest formatter
     class SimpleWriter < BaseWriter
       SLUG_TO_WRITER = {
-        missing_foreign_key: Simple::Base.with('should have foreign key in the database'),
+        association_missing_index: Simple::AssociationMissingIndex,
+        association_missing_null_constraint: Simple::AssociationMissingNullConstraint,
+        has_one_missing_unique_index: Simple::HasOneMissingUniqueIndex,
         inconsistent_types: Simple::InconsistentTypes,
-        has_one_missing_unique_index: Simple::Base.with('associated model should have proper unique index in the database'), # rubocop:disable Layout/LineLength
-        association_missing_index: Simple::Base.with('associated model should have proper index in the database'),
-        length_validator_missing: Simple::Base.with('column has limit in the database but do not have length validator'), # rubocop:disable Layout/LineLength
-        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
-        null_constraint_misses_validator: Simple::Base.with('column is required in the database but do not have presence validator'), # rubocop:disable Layout/LineLength
-        small_primary_key: Simple::Base.with('column has int/serial type but recommended to have bigint/bigserial/uuid'), # rubocop:disable Layout/LineLength
-        missing_uniqueness_validation: Simple::Base.with('index is unique in the database but do not have uniqueness validator'), # rubocop:disable Layout/LineLength
-        missing_unique_index: Simple::Base.with('model should have proper unique index in the database'),
-        possible_null: Simple::Base.with('column is required but there is possible null value insert'),
-        null_constraint_missing: Simple::Base.with('column should be required in the database'),
-        association_missing_null_constraint: Simple::Base.with('association foreign key column should be required in the database'), # rubocop:disable Layout/LineLength
+        length_validator_greater_limit: Simple::LengthValidatorGreaterLimit,
+        length_validator_lower_limit: Simple::LengthValidatorLowerLimit,
+        length_validator_missing: Simple::LengthValidatorMissing,
+        missing_foreign_key: Simple::MissingForeignKey,
+        missing_unique_index: Simple::MissingUniqueIndex,
+        missing_uniqueness_validation: Simple::MissingUniquenessValidation,
         null_constraint_association_misses_validator: Simple::NullConstraintAssociationMissesValidator,
+        null_constraint_misses_validator: Simple::NullConstraintMissesValidator,
+        null_constraint_missing: Simple::NullConstraintMissing,
+        possible_null: Simple::PossibleNull,
         redundant_index: Simple::RedundantIndex,
-        redundant_unique_index: Simple::RedundantUniqueIndex
+        redundant_unique_index: Simple::RedundantUniqueIndex,
+        small_primary_key: Simple::SmallPrimaryKey
       }.freeze
 
       def write
-        results.each do |result|
-          next unless write?(result.status)
-
-          writer = writer(result)
-
+        results.select(&method(:write?))
+               .map(&method(:writer))
+               .uniq(&:unique_key)
+               .each do |writer|
           puts writer.msg
         end
       end
 
       private
 
-      def write?(status)
-        status == :fail || config.debug?
+      def write?(report)
+        report.status == :fail || config.debug?
       end
 
       def writer(report)

data/lib/database_consistency.rb

@@ -18,12 +18,28 @@ 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/association_missing_index'
+require 'database_consistency/writers/simple/association_missing_null_constraint'
+require 'database_consistency/writers/simple/has_one_missing_unique_index'
+require 'database_consistency/writers/simple/length_validator_lower_limit'
+require 'database_consistency/writers/simple/length_validator_greater_limit'
+require 'database_consistency/writers/simple/length_validator_missing'
+require 'database_consistency/writers/simple/missing_foreign_key'
+require 'database_consistency/writers/simple/missing_unique_index'
+require 'database_consistency/writers/simple/missing_uniqueness_validation'
+require 'database_consistency/writers/simple/null_constraint_misses_validator'
+require 'database_consistency/writers/simple/null_constraint_missing'
+require 'database_consistency/writers/simple/possible_null'
+require 'database_consistency/writers/simple/small_primary_key'
 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.4
+  version: 1.3.6
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-11-12 00:00:00.000000000 Z
+date: 2022-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -179,23 +179,42 @@ 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/simple/association_missing_index.rb
+- lib/database_consistency/writers/simple/association_missing_null_constraint.rb
 - lib/database_consistency/writers/simple/base.rb
 - lib/database_consistency/writers/simple/error_message.rb
+- lib/database_consistency/writers/simple/has_one_missing_unique_index.rb
 - lib/database_consistency/writers/simple/inconsistent_types.rb
+- lib/database_consistency/writers/simple/length_validator_greater_limit.rb
+- lib/database_consistency/writers/simple/length_validator_lower_limit.rb
+- lib/database_consistency/writers/simple/length_validator_missing.rb
+- lib/database_consistency/writers/simple/missing_foreign_key.rb
+- lib/database_consistency/writers/simple/missing_unique_index.rb
+- lib/database_consistency/writers/simple/missing_uniqueness_validation.rb
 - lib/database_consistency/writers/simple/null_constraint_association_misses_validator.rb
+- lib/database_consistency/writers/simple/null_constraint_misses_validator.rb
+- lib/database_consistency/writers/simple/null_constraint_missing.rb
+- lib/database_consistency/writers/simple/possible_null.rb
 - lib/database_consistency/writers/simple/redundant_index.rb
 - lib/database_consistency/writers/simple/redundant_unique_index.rb
+- lib/database_consistency/writers/simple/small_primary_key.rb
 - lib/database_consistency/writers/simple_writer.rb
 - lib/database_consistency/writers/todo_writer.rb
 homepage: https://github.com/djezzzl/database_consistency