database_consistency 1.3.5 → 1.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f935ca51faca06dad689d217e897a035253f4ce9884f1826befdf1bcbbee3b5
-  data.tar.gz: 38bde32ffee8b05b04bc8a1af261764f967b64f322352ef8d79729f1de485e13
+  metadata.gz: 3977b5e14b960051dad79361a32e435e511707612a269512fd42dcbac389216f
+  data.tar.gz: 95aba2661c7724aca4cee0e386b8f5e12e59f62b6444f35c66ebcabba2a6f9be
 SHA512:
-  metadata.gz: 2352fa358c91e6dbec9a22c9abac34fb27b45e662c1402e88cfe94864b7bfa4966628f246a6f6f5d6c6af323e1320a3fe03c74df644f86ec6d14e4bde7c81962
-  data.tar.gz: ad812a3ce4c8d4d0a7d24d9031815a26ae2c32bfca6d0721430f3c31f01d8c5910f4af091fb7d088e4860d65d887ba0a27531bdd0d8aefc50b589a944ef29290
+  metadata.gz: d71ae7f118719222bfcdb11329d8f0be6ca5c62d8f54ca145cd08f26d982e7e7b0a1b848397b19aa4e4a4c35e88602be24fd384896ed58cf6221f83e7d87280c
+  data.tar.gz: 0b1efa4b1c268d3959eae583bd4b2e3dc6da2585ac64a6ebf4b4a83ad73710f1a0c704ff1fdee4e13c01b5170c41bf593f31bd77a7f6bea9b6d417fe892208d6

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

@@ -4,17 +4,13 @@ module DatabaseConsistency
   module Checkers
     # This class checks if non polymorphic +belongs_to+ association has foreign key constraint
     class ForeignKeyChecker < AssociationChecker
-      class Report < DatabaseConsistency::Report # :nodoc:
-        attr_reader :primary_table, :primary_key, :foreign_table, :foreign_key
-
-        def initialize(primary_table:, foreign_table:, primary_key:, foreign_key:, **args)
-          super(**args)
-          @primary_table = primary_table
-          @primary_key = primary_key
-          @foreign_table = foreign_table
-          @foreign_key = foreign_key
-        end
-      end
+      Report = ReportBuilder.define(
+        DatabaseConsistency::Report,
+        :primary_table,
+        :primary_key,
+        :foreign_table,
+        :foreign_key
+      )
 
       private
 
@@ -43,22 +39,26 @@ module DatabaseConsistency
       # | ----------- | ------ |
       # | persisted   | ok     |
       # | missing     | fail   |
-      def check # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def check
         if model.connection.foreign_keys(model.table_name).find { |fk| fk.column == association.foreign_key.to_s }
           report_template(:ok)
         else
-          Report.new(
-            status: :fail,
-            error_message: nil,
-            error_slug: :missing_foreign_key,
-            primary_table: association.table_name.to_s,
-            primary_key: association.association_primary_key.to_s,
-            foreign_table: association.active_record.table_name.to_s,
-            foreign_key: association.foreign_key.to_s,
-            **report_attributes
-          )
+          report_template(:fail, error_slug: :missing_foreign_key)
         end
       end
+
+      def report_template(status, error_slug: nil)
+        Report.new(
+          status: status,
+          error_message: nil,
+          error_slug: error_slug,
+          primary_table: association.table_name.to_s,
+          primary_key: association.association_primary_key.to_s,
+          foreign_table: association.active_record.table_name.to_s,
+          foreign_key: association.foreign_key.to_s,
+          **report_attributes
+        )
+      end
     end
   end
 end

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

@@ -4,21 +4,15 @@ 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
-      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
+      Report = ReportBuilder.define(
+        DatabaseConsistency::Report,
+        :pk_name,
+        :pk_type,
+        :fk_name,
+        :fk_type,
+        :table_to_change,
+        :type_to_set
+      )
 
       private
 
@@ -50,7 +44,7 @@ module DatabaseConsistency
           report_template(:fail, error_slug: :inconsistent_types)
         end
       rescue Errors::MissingField => e
-        Report.new(
+        DatabaseConsistency::Report.new(
           status: :fail,
           error_slug: nil,
           error_message: e.message,

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

@@ -4,15 +4,11 @@ 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
+      Report = ReportBuilder.define(
+        DatabaseConsistency::Report,
+        :table_name,
+        :columns
+      )
 
       private
 

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

@@ -4,14 +4,10 @@ module DatabaseConsistency
   module Checkers
     # This class checks missing presence validator
     class NullConstraintChecker < ColumnChecker
-      class Report < DatabaseConsistency::Report # :nodoc:
-        attr_reader :association_name
-
-        def initialize(association_name:, **args)
-          super(**args)
-          @association_name = association_name
-        end
-      end
+      Report = ReportBuilder.define(
+        DatabaseConsistency::Report,
+        :association_name
+      )
 
       private
 
@@ -33,22 +29,26 @@ module DatabaseConsistency
       #
       # We consider PresenceValidation, InclusionValidation, ExclusionValidation, NumericalityValidator with nil,
       # or required BelongsTo association using this column
-      def check # rubocop:disable Metrics/MethodLength
+      def check
         if valid?
           report_template(:ok)
         elsif belongs_to_association
-          Report.new(
-            status: :fail,
-            error_slug: :null_constraint_association_misses_validator,
-            error_message: nil,
-            association_name: belongs_to_association.name.to_s,
-            **report_attributes
-          )
+          report_template(:fail, error_slug: :null_constraint_association_misses_validator)
         else
           report_template(:fail, error_slug: :null_constraint_misses_validator)
         end
       end
 
+      def report_template(status, error_slug: nil)
+        Report.new(
+          status: status,
+          error_slug: error_slug,
+          error_message: nil,
+          association_name: belongs_to_association&.name&.to_s,
+          **report_attributes
+        )
+      end
+
       def valid?
         validator?(:presence, column.name) ||
           validator?(:inclusion, column.name) ||

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

@@ -4,16 +4,12 @@ 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
+      Report = ReportBuilder.define(
+        DatabaseConsistency::Report,
+        :fk_name,
+        :table_to_change,
+        :type_to_set
+      )
 
       private
 
@@ -36,22 +32,26 @@ module DatabaseConsistency
       # | --------------------- | ------ |
       # | yes                   | ok     |
       # | no                    | fail   |
-      def check # rubocop:disable Metrics/MethodLength
+      def check
         if valid?
           report_template(:ok)
         else
-          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
-          )
+          report_template(:fail, error_slug: :small_primary_key)
         end
       end
 
+      def report_template(status, error_slug: nil)
+        Report.new(
+          status: status,
+          error_slug: error_slug,
+          error_message: nil,
+          table_to_change: model.table_name,
+          fk_name: column.name,
+          type_to_set: type_to_set,
+          **report_attributes
+        )
+      end
+
       def type_to_set
         VALID_TYPES_MAP[column.sql_type.to_s] || 'bigserial'
       end

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

@@ -4,15 +4,11 @@ module DatabaseConsistency
   module Checkers
     # This class checks redundant database indexes
     class RedundantIndexChecker < IndexChecker
-      class Report < DatabaseConsistency::Report # :nodoc:
-        attr_reader :covered_index_name, :index_name
-
-        def initialize(covered_index_name:, index_name:, **args)
-          super(**args)
-          @covered_index_name = covered_index_name
-          @index_name = index_name
-        end
-      end
+      Report = ReportBuilder.define(
+        DatabaseConsistency::Report,
+        :covered_index_name,
+        :index_name
+      )
 
       private
 
@@ -28,21 +24,25 @@ module DatabaseConsistency
       # | provided   | ok     |
       # | redundant  | fail   |
       #
-      def check # rubocop:disable Metrics/MethodLength
+      def check
         if covered_by_index
-          Report.new(
-            status: :fail,
-            error_slug: :redundant_index,
-            error_message: nil,
-            covered_index_name: covered_by_index.name,
-            index_name: index.name,
-            **report_attributes
-          )
+          report_template(:fail, error_slug: :redundant_index)
         else
           report_template(:ok)
         end
       end
 
+      def report_template(status, error_slug: nil)
+        Report.new(
+          status: status,
+          error_slug: error_slug,
+          error_message: nil,
+          covered_index_name: covered_by_index&.name,
+          index_name: index.name,
+          **report_attributes
+        )
+      end
+
       def covered_by_index
         @covered_by_index ||=
           model.connection.indexes(model.table_name).find do |another_index|

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

@@ -4,15 +4,11 @@ module DatabaseConsistency
   module Checkers
     # This class checks redundant database indexes
     class RedundantUniqueIndexChecker < IndexChecker
-      class Report < DatabaseConsistency::Report # :nodoc:
-        attr_reader :index_name, :covered_index_name
-
-        def initialize(covered_index_name:, index_name:, **args)
-          super(**args)
-          @index_name = index_name
-          @covered_index_name = covered_index_name
-        end
-      end
+      Report = ReportBuilder.define(
+        DatabaseConsistency::Report,
+        :index_name,
+        :covered_index_name
+      )
 
       private
 
@@ -28,21 +24,25 @@ module DatabaseConsistency
       # | provided   | ok     |
       # | redundant  | fail   |
       #
-      def check # rubocop:disable Metrics/MethodLength
+      def check
         if covered_by_index
-          Report.new(
-            status: :fail,
-            error_slug: :redundant_unique_index,
-            error_message: nil,
-            index_name: index.name,
-            covered_index_name: covered_by_index.name,
-            **report_attributes
-          )
+          report_template(:fail, error_slug: :redundant_unique_index)
         else
           report_template(:ok)
         end
       end
 
+      def report_template(status, error_slug: nil)
+        Report.new(
+          status: status,
+          error_slug: error_slug,
+          error_message: nil,
+          index_name: index.name,
+          covered_index_name: covered_by_index&.name,
+          **report_attributes
+        )
+      end
+
       def covered_by_index
         @covered_by_index ||=
           model.connection.indexes(model.table_name).find do |another_index|

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

@@ -4,15 +4,11 @@ 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
+      Report = ReportBuilder.define(
+        DatabaseConsistency::Report,
+        :table_name,
+        :columns
+      )
 
       def column_or_attribute_name
         @column_or_attribute_name ||= Helper.uniqueness_validator_columns(attribute, validator, model).join('+')
@@ -31,21 +27,25 @@ module DatabaseConsistency
       # | ------------ | ------ |
       # | persisted    | ok     |
       # | missing      | fail   |
-      def check # rubocop:disable Metrics/MethodLength
+      def check
         if unique_index
           report_template(:ok)
         else
-          Report.new(
-            status: :fail,
-            error_slug: :missing_unique_index,
-            error_message: nil,
-            table_name: model.table_name,
-            columns: sorted_uniqueness_validator_columns,
-            **report_attributes
-          )
+          report_template(:fail, error_slug: :missing_unique_index)
         end
       end
 
+      def report_template(status, error_slug: nil)
+        Report.new(
+          status: status,
+          error_slug: error_slug,
+          error_message: nil,
+          table_name: model.table_name,
+          columns: sorted_uniqueness_validator_columns,
+          **report_attributes
+        )
+      end
+
       def unique_index
         @unique_index ||= model.connection.indexes(model.table_name).find do |index|
           index.unique && Helper.extract_index_columns(index.columns).sort == sorted_uniqueness_validator_columns

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

@@ -6,15 +6,11 @@ module DatabaseConsistency
     class ColumnPresenceChecker < ValidatorsFractionChecker
       WEAK_OPTIONS = %i[allow_nil allow_blank if unless on].freeze
 
-      class Report < DatabaseConsistency::Report # :nodoc:
-        attr_reader :table_name, :column_name
-
-        def initialize(table_name:, column_name:, **args)
-          super(**args)
-          @table_name = table_name
-          @column_name = column_name
-        end
-      end
+      Report = ReportBuilder.define(
+        DatabaseConsistency::Report,
+        :table_name,
+        :column_name
+      )
 
       private
 
@@ -44,6 +40,17 @@ module DatabaseConsistency
         report_template(:fail, error_message: e.message)
       end
 
+      def report_template(status, error_message: nil, error_slug: nil)
+        Report.new(
+          status: status,
+          error_slug: error_slug,
+          error_message: error_message,
+          table_name: model.table_name.to_s,
+          column_name: attribute.to_s,
+          **report_attributes
+        )
+      end
+
       def weak_option?
         validators.all? { |validator| validator.options.slice(*WEAK_OPTIONS).any? }
       end

data/lib/database_consistency/report.rb

@@ -1,16 +1,13 @@
 # frozen_string_literal: true
 
 module DatabaseConsistency
-  class Report # :nodoc:
-    attr_reader :checker_name, :table_or_model_name, :column_or_attribute_name, :status, :error_slug, :error_message
-
-    def initialize(checker_name:, table_or_model_name:, column_or_attribute_name:, status:, error_slug:, error_message:) # rubocop:disable Metrics/ParameterLists
-      @checker_name = checker_name
-      @table_or_model_name = table_or_model_name
-      @column_or_attribute_name = column_or_attribute_name
-      @status = status
-      @error_slug = error_slug
-      @error_message = error_message
-    end
-  end
+  Report = ReportBuilder.define(
+    Class.new,
+    :checker_name,
+    :table_or_model_name,
+    :column_or_attribute_name,
+    :status,
+    :error_slug,
+    :error_message
+  )
 end

data/lib/database_consistency/report_builder.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  class ReportBuilder # :nodoc:
+    def self.define(klass, *attrs) # rubocop:disable Metrics/MethodLength
+      Class.new(klass) do
+        attr_reader(*attrs)
+
+        class_eval(<<~DEF, __FILE__, __LINE__ + 1)
+          def initialize(#{attrs.map { |attr| "#{attr}:" }.join(', ')}, **opts)
+            super(**opts) if opts.any?
+            #{attrs.map { |attr| "@#{attr} = #{attr}" }.join("\n")}
+          end
+
+          def to_h
+            h = defined?(super) ? super : {}
+            #{attrs.map { |attr| "h[#{attr}] = #{attr}" }.join("\n")}
+            h
+          end
+        DEF
+      end
+    end
+  end
+end

data/lib/database_consistency/version.rb

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

data/lib/database_consistency/writers/autofix_writer.rb

@@ -41,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

@@ -33,11 +33,19 @@ module DatabaseConsistency
         end
 
         def msg
-          "#{report.checker_name} #{status_text} #{key_text} #{message_text}"
+          "#{report.checker_name} #{status_text} #{key_text} #{message_text}".strip
+        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 → default_message.rb}

@@ -3,12 +3,16 @@
 module DatabaseConsistency
   module Writers
     module Simple
-      class ErrorMessage < Base # :nodoc:
+      class DefaultMessage < Base # :nodoc:
         private
 
         def template
           report.error_message || ''
         end
+
+        def unique_attributes
+          report.to_h
+        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

@@ -7,7 +7,8 @@ module DatabaseConsistency
         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"
+          "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
@@ -18,6 +19,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,43 +6,49 @@ module DatabaseConsistency
     # The simplest formatter
     class SimpleWriter < BaseWriter
       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
+        association_missing_index: Simple::AssociationMissingIndex,
+        association_missing_null_constraint: Simple::AssociationMissingNullConstraint,
+        has_one_missing_unique_index: Simple::HasOneMissingUniqueIndex,
         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
+        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::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'),
+        null_constraint_misses_validator: Simple::NullConstraintMissesValidator,
+        null_constraint_missing: Simple::NullConstraintMissing,
+        possible_null: Simple::PossibleNull,
         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')
+        small_primary_key: Simple::SmallPrimaryKey
       }.freeze
 
       def write
-        results.each do |result|
-          next unless write?(result.status)
-
-          writer = writer(result)
-
-          puts writer.msg
+        results.select(&method(:write?))
+               .map(&method(:writer))
+               .group_by(&:unique_key)
+               .each_value do |writers|
+          puts message(writers)
         end
       end
 
       private
 
-      def write?(status)
-        status == :fail || config.debug?
+      def message(writers)
+        msg = writers.first.msg
+        return msg if writers.size == 1
+
+        "#{msg}. Total grouped offenses: #{writers.size}"
+      end
+
+      def write?(report)
+        report.status == :fail || config.debug?
       end
 
       def writer(report)
-        klass = SLUG_TO_WRITER[report.error_slug] || Simple::ErrorMessage
+        klass = SLUG_TO_WRITER[report.error_slug] || Simple::DefaultMessage
         klass.new(report, config: config)
       end
     end

data/lib/database_consistency.rb

@@ -7,17 +7,31 @@ require 'database_consistency/helper'
 require 'database_consistency/configuration'
 require 'database_consistency/rescue_error'
 require 'database_consistency/errors'
+require 'database_consistency/report_builder'
 require 'database_consistency/report'
 
 require 'database_consistency/writers/base_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/default_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/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'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: database_consistency
 version: !ruby/object:Gem::Version
-  version: 1.3.5
+  version: 1.3.7
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-11-13 00:00:00.000000000 Z
+date: 2022-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -176,6 +176,7 @@ files:
 - lib/database_consistency/processors/validators_fractions_processor.rb
 - lib/database_consistency/processors/validators_processor.rb
 - lib/database_consistency/report.rb
+- lib/database_consistency/report_builder.rb
 - lib/database_consistency/rescue_error.rb
 - lib/database_consistency/templates/rails_defaults.yml
 - lib/database_consistency/version.rb
@@ -196,12 +197,25 @@ files:
 - 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/default_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