database_consistency 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5774c6b4064a081e7a285013456b39fef68f39ec7dd536063c236d54abec3e84
-  data.tar.gz: 18ed6073af882e007ec6ea70a9a55fad8daa8fef755049a3070d9f68ce1377dd
+  metadata.gz: 977b169b47dd5335a327746945ddd512717db1305744f44884d81bb0c7e82645
+  data.tar.gz: 59eb6c6ddefd09e77ba3f51dfbc2d4474eb92f62ca7b92437a4d9d70778d0d85
 SHA512:
-  metadata.gz: 575b90af564642b397b5a93d2c5a94a3b3b2fb8f6de12e40225361ebb96128df61a8d3e19fb4982986985c6bd1ae110539cc93f00688bab3b44205f7aa5f3716
-  data.tar.gz: 051360a87facb2062451b17c59ff596156b0211dfbf73d6e3345c1b45d470f45177c280d6dd6fb59602faa719a959534252dc4f9615378724d2a321d39c64394
+  metadata.gz: 8b2b83f4ca288c7173f7abacc04c80f07b4d78c45f0fc949a801d1eb08b173c217ee524462eade7f443d9582243e593faa2730dd33e77e6d985f86c8ba86f6b4
+  data.tar.gz: e461a6da7caab598150602dac3f02075f4da00b9e68b481419e5717bb33fd3390d5e3f5b90c9ec315c2445af06812e435dafb3db81a7c2ced6cda4b957b035d0

data/bin/database_consistency

@@ -35,10 +35,14 @@ opt_parser = OptionParser.new do |opts|
     config << f
   end
 
-  opts.on('-g', '--generate-todo', 'Generate TODO file with every failing check disabled. You can pass existing configurations so the generated file will have only new failures.') do |f|
+  opts.on('-g', '--generate-todo', 'Generate TODO file with every failing check disabled. You can pass existing configurations so the generated file will have only new failures.') do
     options[:todo] = true
   end
 
+  opts.on('-fix', '--autofix', 'Automatically fixes issues by adjusting the code or generating missing migrations.') do
+    options[:autofix] = true
+  end
+
   opts.on('-h', '--help', 'Prints this help.') do
     puts opts
     exit

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

@@ -4,7 +4,26 @@ module DatabaseConsistency
   module Checkers
     # This class checks if non polymorphic +belongs_to+ association has foreign key constraint
     class ForeignKeyChecker < AssociationChecker
-      MISSING_FOREIGN_KEY = 'should have foreign key in the database'
+      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
+
+        def attributes
+          super.merge(
+            primary_table: primary_table,
+            primary_key: primary_key,
+            foreign_table: foreign_table,
+            foreign_key: foreign_key
+          )
+        end
+      end
 
       private
 
@@ -33,11 +52,20 @@ module DatabaseConsistency
       # | ----------- | ------ |
       # | persisted   | ok     |
       # | missing     | fail   |
-      def check
+      def check # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         if model.connection.foreign_keys(model.table_name).find { |fk| fk.column == association.foreign_key.to_s }
           report_template(:ok)
         else
-          report_template(:fail, MISSING_FOREIGN_KEY)
+          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
+          )
         end
       end
     end

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

@@ -4,7 +4,26 @@ 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
-      INCONSISTENT_TYPE = "foreign key (%a_f) with type (%a_t) doesn't cover primary key (%b_f) with type (%b_t)"
+      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
+        end
+
+        def attributes
+          super.merge(
+            fk_name: fk_name,
+            fk_type: fk_type,
+            pk_name: pk_name,
+            pk_type: pk_type
+          )
+        end
+      end
 
       private
 
@@ -27,23 +46,32 @@ module DatabaseConsistency
       # | ------------- | ------ |
       # | covers        | ok     |
       # | doesn't cover | fail   |
-      def check
+      def check # rubocop:disable Metrics/MethodLength
         if converted_type(associated_column).cover?(converted_type(primary_column))
           report_template(:ok)
         else
-          report_template(:fail, render_text)
+          report_template(:fail, error_slug: :inconsistent_types)
         end
       rescue Errors::MissingField => e
-        report_template(:fail, e.message)
+        Report.new(
+          status: :fail,
+          error_slug: nil,
+          error_message: e.message,
+          **report_attributes
+        )
       end
 
-      # @return [String]
-      def render_text
-        INCONSISTENT_TYPE
-          .gsub('%a_t', type(associated_column))
-          .gsub('%a_f', associated_key)
-          .gsub('%b_t', type(primary_column))
-          .gsub('%b_f', primary_key)
+      def report_template(status, error_slug: nil)
+        Report.new(
+          status: status,
+          error_slug: error_slug,
+          error_message: nil,
+          fk_type: converted_type(associated_column).type,
+          fk_name: associated_key,
+          pk_type: converted_type(primary_column).type,
+          pk_name: primary_key,
+          **report_attributes
+        )
       end
 
       # @return [String]

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

@@ -4,10 +4,6 @@ module DatabaseConsistency
   module Checkers
     # This class checks if association's foreign key has index in the database
     class MissingIndexChecker < AssociationChecker
-      # Message templates
-      MISSING_INDEX = 'associated model should have proper index in the database'
-      MISSING_UNIQUE_INDEX = 'associated model should have proper unique index in the database'
-
       private
 
       # We skip check when:
@@ -40,7 +36,7 @@ module DatabaseConsistency
         if unique_index
           report_template(:ok)
         else
-          report_template(:fail, MISSING_UNIQUE_INDEX)
+          report_template(:fail, error_slug: :has_one_missing_unique_index)
         end
       end
 
@@ -48,7 +44,7 @@ module DatabaseConsistency
         if index
           report_template(:ok)
         else
-          report_template(:fail, MISSING_INDEX)
+          report_template(:fail, error_slug: :association_missing_index)
         end
       end
 

data/lib/database_consistency/checkers/base_checker.rb

@@ -66,16 +66,23 @@ module DatabaseConsistency
         raise NotImplementedError
       end
 
-      # @return [OpenStruct]
-      def report_template(status, message = nil)
-        OpenStruct.new(
-          checker_name: checker_name,
-          table_or_model_name: table_or_model_name,
-          column_or_attribute_name: column_or_attribute_name,
+      # @return [DatabaseConsistency::Report]
+      def report_template(status, error_slug: nil, error_message: nil)
+        Report.new(
           status: status,
-          message: message
+          error_slug: error_slug,
+          error_message: error_message,
+          **report_attributes
         )
       end
+
+      def report_attributes
+        {
+          checker_name: checker_name,
+          table_or_model_name: table_or_model_name,
+          column_or_attribute_name: column_or_attribute_name
+        }
+      end
     end
   end
 end

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

@@ -4,11 +4,6 @@ module DatabaseConsistency
   module Checkers
     # This class checks missing presence validator
     class LengthConstraintChecker < ColumnChecker
-      # Message templates
-      VALIDATOR_MISSING = 'column has limit in the database but do not have length validator'
-      GREATER_LIMIT = 'column has greater limit in the database than in length validator'
-      LOWER_LIMIT = 'column has lower limit in the database than in length validator'
-
       VALIDATOR_CLASS =
         if defined?(ActiveRecord::Validations::LengthValidator)
           ActiveRecord::Validations::LengthValidator
@@ -38,14 +33,14 @@ module DatabaseConsistency
       # | small      | warning |
       # | missing    | fail    |
       def check
-        return report_template(:fail, VALIDATOR_MISSING) unless validator
+        return report_template(:fail, error_slug: :length_validator_missing) unless validator
 
         if valid?(:==)
           report_template(:ok)
         elsif valid?(:<)
-          report_template(:warning, GREATER_LIMIT)
+          report_template(:warning, error_slug: :length_validator_greater_limit)
         else
-          report_template(:fail, LOWER_LIMIT)
+          report_template(:fail, error_slug: :length_validator_lower_limit)
         end
       end
 

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

@@ -4,10 +4,18 @@ module DatabaseConsistency
   module Checkers
     # This class checks missing presence validator
     class NullConstraintChecker < ColumnChecker
-      # Message templates
-      VALIDATOR_MISSING = 'column is required in the database but do not have presence validator'
-      ASSOCIATION_VALIDATOR_MISSING = 'column is required in the database but do '\
-                                      'not have presence validator for association (%a_n)'
+      class Report < DatabaseConsistency::Report # :nodoc:
+        attr_reader :association_name
+
+        def initialize(association_name:, **args)
+          super(**args)
+          @association_name = association_name
+        end
+
+        def attributes
+          super.merge(association_name: association_name)
+        end
+      end
 
       private
 
@@ -29,13 +37,19 @@ module DatabaseConsistency
       #
       # We consider PresenceValidation, InclusionValidation, ExclusionValidation, NumericalityValidator with nil,
       # or required BelongsTo association using this column
-      def check
+      def check # rubocop:disable Metrics/MethodLength
         if valid?
           report_template(:ok)
         elsif belongs_to_association
-          report_template(:fail, ASSOCIATION_VALIDATOR_MISSING.gsub('%a_n', belongs_to_association.name.to_s))
+          Report.new(
+            status: :fail,
+            error_slug: :null_constraint_association_misses_validator,
+            error_message: nil,
+            association_name: belongs_to_association.name.to_s,
+            **report_attributes
+          )
         else
-          report_template(:fail, VALIDATOR_MISSING)
+          report_template(:fail, error_slug: :null_constraint_misses_validator)
         end
       end
 

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

@@ -4,9 +4,6 @@ module DatabaseConsistency
   module Checkers
     # This class checks missing presence validator
     class PrimaryKeyTypeChecker < ColumnChecker
-      # Message templates
-      VALIDATOR_MISSING = 'column has int/serial type but recommended to have bigint/bigserial/uuid'
-
       private
 
       VALID_TYPES = %w[bigserial bigint uuid].freeze
@@ -28,7 +25,7 @@ module DatabaseConsistency
         if valid?
           report_template(:ok)
         else
-          report_template(:fail, VALIDATOR_MISSING)
+          report_template(:fail, error_slug: :small_primary_key)
         end
       end
 

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

@@ -4,8 +4,18 @@ module DatabaseConsistency
   module Checkers
     # This class checks redundant database indexes
     class RedundantIndexChecker < IndexChecker
-      # Message templates
-      REDUNDANT_INDEX = 'index is redundant as (%index) covers it'
+      class Report < DatabaseConsistency::Report # :nodoc:
+        attr_reader :index_name
+
+        def initialize(index_name:, **args)
+          super(**args)
+          @index_name = index_name
+        end
+
+        def attributes
+          super.merge(index_name: index_name)
+        end
+      end
 
       private
 
@@ -23,16 +33,18 @@ module DatabaseConsistency
       #
       def check
         if covered_by_index
-          report_template(:fail, render_message)
+          Report.new(
+            status: :fail,
+            error_slug: :redundant_index,
+            error_message: nil,
+            index_name: covered_by_index.name,
+            **report_attributes
+          )
         else
           report_template(:ok)
         end
       end
 
-      def render_message
-        REDUNDANT_INDEX.sub('%index', covered_by_index.name)
-      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,8 +4,18 @@ module DatabaseConsistency
   module Checkers
     # This class checks redundant database indexes
     class RedundantUniqueIndexChecker < IndexChecker
-      # Message templates
-      REDUNDANT_UNIQUE_INDEX = 'index uniqueness is redundant as (%index) covers it'
+      class Report < DatabaseConsistency::Report # :nodoc:
+        attr_reader :index_name
+
+        def initialize(index_name:, **args)
+          super(**args)
+          @index_name = index_name
+        end
+
+        def attributes
+          super.merge(index_name: index_name)
+        end
+      end
 
       private
 
@@ -23,16 +33,18 @@ module DatabaseConsistency
       #
       def check
         if covered_by_index
-          report_template(:fail, render_message)
+          Report.new(
+            status: :fail,
+            error_slug: :redundant_unique_index,
+            error_message: nil,
+            index_name: covered_by_index.name,
+            **report_attributes
+          )
         else
           report_template(:ok)
         end
       end
 
-      def render_message
-        REDUNDANT_UNIQUE_INDEX.sub('%index', covered_by_index.name)
-      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/unique_index_checker.rb

@@ -4,9 +4,6 @@ module DatabaseConsistency
   module Checkers
     # This class checks missing uniqueness validator
     class UniqueIndexChecker < IndexChecker
-      # Message templates
-      VALIDATOR_MISSING = 'index is unique in the database but do not have uniqueness validator'
-
       private
 
       # We skip check when:
@@ -25,7 +22,7 @@ module DatabaseConsistency
         if valid?
           report_template(:ok)
         else
-          report_template(:fail, VALIDATOR_MISSING)
+          report_template(:fail, error_slug: :missing_uniqueness_validation)
         end
       end
 

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

@@ -4,8 +4,6 @@ module DatabaseConsistency
   module Checkers
     # This class checks if uniqueness validator has unique index in the database
     class MissingUniqueIndexChecker < ValidatorChecker
-      MISSING_INDEX = 'model should have proper unique index in the database'
-
       def column_or_attribute_name
         @column_or_attribute_name ||= Helper.uniqueness_validator_columns(attribute, validator, model).join('+')
       end
@@ -27,7 +25,7 @@ module DatabaseConsistency
         if unique_index
           report_template(:ok)
         else
-          report_template(:fail, MISSING_INDEX)
+          report_template(:fail, error_slug: :missing_unique_index)
         end
       end
 

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

@@ -5,10 +5,20 @@ module DatabaseConsistency
     # This class checks if presence validator has non-null constraint in the database
     class ColumnPresenceChecker < ValidatorsFractionChecker
       WEAK_OPTIONS = %i[allow_nil allow_blank if unless on].freeze
-      # Message templates
-      CONSTRAINT_MISSING = 'column should be required in the database'
-      ASSOCIATION_FOREIGN_KEY_CONSTRAINT_MISSING = 'association foreign key column should be required in the database'
-      POSSIBLE_NULL = 'column is required but there is possible null value insert'
+
+      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
+
+        def attributes
+          super.merge(table_name: table_name, column_name: column_name)
+        end
+      end
 
       private
 
@@ -35,24 +45,38 @@ module DatabaseConsistency
       def check
         report_message
       rescue Errors::MissingField => e
-        report_template(:fail, e.message)
+        report_template(:fail, error_message: e.message)
       end
 
       def weak_option?
         validators.all? { |validator| validator.options.slice(*WEAK_OPTIONS).any? }
       end
 
-      def report_message
+      def report_message # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         can_be_null = column.null
         has_weak_option = weak_option?
 
         return report_template(:ok) if can_be_null == has_weak_option
-        return report_template(:fail, POSSIBLE_NULL) unless can_be_null
+        return report_template(:fail, error_slug: :possible_null) unless can_be_null
 
         if regular_column
-          report_template(:fail, CONSTRAINT_MISSING)
+          Report.new(
+            status: :fail,
+            error_slug: :null_constraint_missing,
+            error_message: nil,
+            table_name: model.table_name.to_s,
+            column_name: attribute.to_s,
+            **report_attributes
+          )
         else
-          report_template(:fail, ASSOCIATION_FOREIGN_KEY_CONSTRAINT_MISSING)
+          Report.new(
+            status: :fail,
+            error_slug: :association_missing_null_constraint,
+            error_message: nil,
+            table_name: model.table_name.to_s,
+            column_name: association_reflection.foreign_key.to_s,
+            **report_attributes
+          )
         end
       end
 

data/lib/database_consistency/processors/base_processor.rb

@@ -25,8 +25,13 @@ module DatabaseConsistency
       end
 
       # @return [Array<Hash>]
-      def reports
+      def reports(catch_errors: true)
         @reports ||= check
+      rescue StandardError => e
+        raise e unless catch_errors
+
+        RescueError.call(e)
+        []
       end
 
       # @return [Array<Class>]

data/lib/database_consistency/processors/indexes_processor.rb

@@ -16,7 +16,7 @@ module DatabaseConsistency
         Helper.parent_models.flat_map do |model|
           next unless configuration.enabled?(model.name.to_s)
 
-          indexes = ActiveRecord::Base.connection.indexes(model.table_name)
+          indexes = model.connection.indexes(model.table_name)
 
           indexes.flat_map do |index|
             enabled_checkers.map do |checker_class|

data/lib/database_consistency/report.rb

@@ -0,0 +1,23 @@
+# 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
+
+    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.2.1'
+  VERSION = '1.3.0'
 end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Autofix
+      class Base # :nodoc:
+        attr_reader :report
+
+        def initialize(report)
+          @report = report
+        end
+      end
+    end
+  end
+end

data/lib/database_consistency/writers/autofix/helpers/migration.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Autofix
+      module Helpers
+        module Migration # :nodoc:
+          def migration_path(name)
+            migration_paths  = ActiveRecord::Migrator.migrations_paths
+            schema_migration = ActiveRecord::Base.connection.schema_migration
+
+            last = ActiveRecord::MigrationContext.new(migration_paths, schema_migration).migrations.last
+            version = ActiveRecord::Migration.next_migration_number(last&.version.to_i + 1)
+
+            "db/migrate/#{version}_#{name.underscore}.rb"
+          end
+
+          def migration_configuration(name)
+            {
+              migration_name: name.camelcase,
+              migration_version: ActiveRecord::Migration.current_version
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Autofix
+      class MigrationBase < Base # :nodoc:
+        include Helpers::Migration
+
+        def fix!
+          File.write(migration_path(migration_name), migration)
+        end
+
+        private
+
+        def migration
+          File.read(template_path) % report.attributes.merge(migration_configuration(migration_name))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Autofix
+      class MissingForeignKey < MigrationBase # :nodoc:
+        private
+
+        def migration_name
+          "add_#{report.primary_table}_#{report.foreign_table}_foreign_key"
+        end
+
+        def template_path
+          File.join(__dir__, 'templates', 'missing_foreign_key.tt')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  module Writers
+    module Autofix
+      class NullConstraintMissing < MigrationBase # :nodoc:
+        private
+
+        def migration_name
+          "change_#{report.table_name}_#{report.column_name}_null_constraint"
+        end
+
+        def template_path
+          File.join(__dir__, 'templates', 'null_constraint_missing.tt')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+class %<migration_name>s < ActiveRecord::Migration[%<migration_version>s]
+  def change
+    add_foreign_key :%<foreign_table>s, :%<primary_table>s, column: :%<foreign_key>s, primary_key: :%<primary_key>s
+  end
+end

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

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

data/lib/database_consistency/writers/autofix_writer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module DatabaseConsistency
+  # The module contains formatters
+  module Writers
+    # The simplest formatter
+    class AutofixWriter < BaseWriter
+      SLUG_TO_GENERATOR = {
+        missing_foreign_key: Autofix::MissingForeignKey,
+        null_constraint_missing: Autofix::NullConstraintMissing,
+        association_missing_null_constraint: Autofix::NullConstraintMissing
+      }.freeze
+
+      def write
+        reports.each do |report|
+          next unless fix?(report)
+
+          fix(report)
+        end
+      end
+
+      private
+
+      def reports
+        results.then(&Helpers::Pipes.method(:unique))
+      end
+
+      def fix?(report)
+        report.status == :fail
+      end
+
+      def fix(report)
+        klass = SLUG_TO_GENERATOR[report.error_slug]
+        return unless klass
+
+        klass.new(report).fix!
+      end
+    end
+  end
+end

data/lib/database_consistency/writers/base_writer.rb

@@ -11,10 +11,6 @@ module DatabaseConsistency
         @config = config
       end
 
-      def write?(status)
-        status == :fail || config.debug?
-      end
-
       def self.write(results, config: Configuration.new)
         new(results, config: config).write
       end

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

@@ -0,0 +1,15 @@
+# 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

data/lib/database_consistency/writers/simple_writer.rb

@@ -18,6 +18,26 @@ module DatabaseConsistency
         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 %<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'
+      }.freeze
+
       def write
         results.each do |result|
           next unless write?(result.status)
@@ -26,11 +46,19 @@ module DatabaseConsistency
         end
       end
 
+      private
+
       def msg(result)
-        "#{result.checker_name} #{status_text(result)} #{key_text(result)} #{result.message}"
+        "#{result.checker_name} #{status_text(result)} #{key_text(result)} #{message_text(result)}"
       end
 
-      private
+      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)}"

data/lib/database_consistency/writers/todo_writer.rb

@@ -6,32 +6,32 @@ module DatabaseConsistency
     # The writer that generates to-do file
     class TodoWriter < BaseWriter
       def write
-        hash = results.each_with_object({}) do |result, hash|
+        h = results.each_with_object({}) do |result, hash|
           next unless write?(result.status)
 
           assign_result(hash, result)
         end
 
-        File.write(file_name, hash.to_yaml)
+        File.write(file_name, h.to_yaml)
       end
 
+      private
+
       def write?(status)
         status == :fail
       end
 
-      private
-
       def assign_result(hash, result)
         hash[result.table_or_model_name] ||= {}
         hash[result.table_or_model_name][result.column_or_attribute_name] ||= {}
-        hash[result.table_or_model_name][result.column_or_attribute_name][result.checker_name] = {'enabled' => false}
+        hash[result.table_or_model_name][result.column_or_attribute_name][result.checker_name] = { 'enabled' => false }
       end
 
       def file_name
         [nil, *(1..100)].each do |number|
           name = generate_file_name(number)
 
-          return name unless File.exists?(name)
+          return name unless File.exist?(name)
         end
       end
 

data/lib/database_consistency.rb

@@ -7,11 +7,21 @@ require 'database_consistency/helper'
 require 'database_consistency/configuration'
 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/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/null_constraint_missing'
+require 'database_consistency/writers/autofix_writer'
+
 require 'database_consistency/databases/factory'
 require 'database_consistency/databases/types/base'
 require 'database_consistency/databases/types/sqlite'
@@ -49,11 +59,15 @@ require 'database_consistency/processors/indexes_processor'
 # The root module
 module DatabaseConsistency
   class << self
-    def run(*args, **opts)
+    def run(*args, **opts) # rubocop:disable Metrics/MethodLength
       configuration = Configuration.new(*args)
       reports = Processors.reports(configuration)
 
-      if opts[:todo]
+      if opts[:autofix]
+        Writers::AutofixWriter.write(reports, config: configuration)
+
+        0
+      elsif opts[:todo]
         Writers::TodoWriter.write(reports, config: configuration)
 
         0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: database_consistency
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-09-08 00:00:00.000000000 Z
+date: 2022-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -175,17 +175,30 @@ files:
 - lib/database_consistency/processors/indexes_processor.rb
 - lib/database_consistency/processors/validators_fractions_processor.rb
 - lib/database_consistency/processors/validators_processor.rb
+- lib/database_consistency/report.rb
 - lib/database_consistency/rescue_error.rb
 - lib/database_consistency/templates/rails_defaults.yml
 - lib/database_consistency/version.rb
+- lib/database_consistency/writers/autofix/base.rb
+- lib/database_consistency/writers/autofix/helpers/migration.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/templates/missing_foreign_key.tt
+- lib/database_consistency/writers/autofix/templates/null_constraint_missing.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_writer.rb
 - lib/database_consistency/writers/todo_writer.rb
 homepage: https://github.com/djezzzl/database_consistency
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message: "Thank you for using the gem!\n\nIf the project helps you or
+  your organization, I would be very grateful if you contribute or donate.  \nYour
+  support is an incredible motivation and the biggest reward for my hard work.\n\nhttps://github.com/djezzzl/database_consistency#contributing\nhttps://opencollective.com/database_consistency#support\n\nThank
+  you for your attention,\nEvgeniy Demin\n"
 rdoc_options: []
 require_paths:
 - lib
@@ -200,7 +213,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.21
+rubygems_version: 3.2.33
 signing_key: 
 specification_version: 4
 summary: Provide an easy way to check the consistency of the database constraints