active_record_doctor 1.8.0 → 1.10.0

data/lib/active_record_doctor/detectors/incorrect_dependent_option.rb

@@ -4,55 +4,110 @@ require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
   module Detectors
-    # Find has_many/has_one associations with dependent options not taking the
-    # related model's callbacks into account.
-    class IncorrectDependentOption < Base
-      # rubocop:disable Layout/LineLength
-      @description = "Detect associations that should use a different dependent option based on callbacks on the related model"
-      # rubocop:enable Layout/LineLength
-
-      def run
-        eager_load!
-
-        problems(hash_from_pairs(models.reject do |model|
-          model.table_name.nil?
-        end.map do |model|
-          [
-            model.name,
-            associations_with_incorrect_dependent_options(model)
-          ]
-        end.reject do |_model_name, associations|
-          associations.empty?
-        end))
-      end
+    class IncorrectDependentOption < Base # :nodoc:
+      @description = "detect associations with incorrect dependent options"
+      @config = {
+        ignore_models: {
+          description: "models whose associations should not be checked",
+          global: true
+        },
+        ignore_associations: {
+          description: "associations, written as Model.association, that should not be checked"
+        }
+      }
 
       private
 
-      def associations_with_incorrect_dependent_options(model)
-        reflections = model.reflect_on_all_associations(:has_many) + model.reflect_on_all_associations(:has_one)
-        reflections.map do |reflection|
-          if callback_action(reflection) == :invoke && !defines_destroy_callbacks?(reflection.klass)
-            suggestion =
-              case reflection.macro
-              when :has_many then :suggest_delete_all
-              when :has_one then :suggest_delete
-              else raise("unsupported association type #{reflection.macro}")
+      def message(model:, association:, problem:, associated_models:)
+        associated_models.sort!
+
+        models_part =
+          if associated_models.length == 1
+            "model #{associated_models[0]} has"
+          else
+            "models #{associated_models.join(', ')} have"
+          end
+
+        # rubocop:disable Layout/LineLength
+        case problem
+        when :suggest_destroy
+          "use `dependent: :destroy` or similar on #{model}.#{association} - the associated #{models_part} callbacks that are currently skipped"
+        when :suggest_delete
+          "use `dependent: :delete` or similar on #{model}.#{association} - the associated #{models_part} no callbacks and can be deleted without loading"
+        when :suggest_delete_all
+          "use `dependent: :delete_all` or similar on #{model}.#{association} - associated #{models_part} no validations and can be deleted in bulk"
+        end
+        # rubocop:enable Layout/LineLength
+      end
+
+      def detect
+        models(except: config(:ignore_models)).each do |model|
+          next unless model.table_exists?
+
+          associations = model.reflect_on_all_associations(:has_many) +
+                         model.reflect_on_all_associations(:has_one) +
+                         model.reflect_on_all_associations(:belongs_to)
+
+          associations.each do |association|
+            next if config(:ignore_associations).include?("#{model.name}.#{association.name}")
+
+            associated_models =
+              if association.polymorphic?
+                models_having(as: association.name)
+              else
+                [association.klass]
               end
 
-            [reflection.name, suggestion]
-          elsif callback_action(reflection) == :skip && defines_destroy_callbacks?(reflection.klass)
-            [reflection.name, :suggest_destroy]
+            deletable_models, destroyable_models = associated_models.partition { |klass| deletable?(klass) }
+
+            if callback_action(association) == :invoke && destroyable_models.empty? && deletable_models.present?
+              suggestion =
+                case association.macro
+                when :has_many then :suggest_delete_all
+                when :has_one, :belongs_to then :suggest_delete
+                else raise("unsupported association type #{association.macro}")
+                end
+
+              problem!(model: model.name, association: association.name, problem: suggestion,
+                       associated_models: deletable_models.map(&:name))
+            elsif callback_action(association) == :skip && destroyable_models.present?
+              problem!(model: model.name, association: association.name, problem: :suggest_destroy,
+                       associated_models: destroyable_models.map(&:name))
+            end
           end
-        end.compact
+        end
+      end
+
+      def models_having(as:)
+        models.select do |model|
+          associations = model.reflect_on_all_associations(:has_one) +
+                         model.reflect_on_all_associations(:has_many)
+
+          associations.any? do |association|
+            association.options[:as] == as
+          end
+        end
       end
 
       def callback_action(reflection)
         case reflection.options[:dependent]
-        when :delete_all then :skip
+        when :delete, :delete_all then :skip
         when :destroy then :invoke
         end
       end
 
+      def deletable?(model)
+        !defines_destroy_callbacks?(model) &&
+          dependent_models(model).all? do |dependent_model|
+            foreign_key = foreign_key(dependent_model.table_name, model.table_name)
+
+            foreign_key.nil? ||
+              foreign_key.on_delete == :nullify || (
+                foreign_key.on_delete == :cascade && deletable?(dependent_model)
+              )
+          end
+      end
+
       def defines_destroy_callbacks?(model)
         # Destroying an associated model involves loading it first hence
         # initialize and find are present. If they are defined on the model
@@ -66,6 +121,18 @@ module ActiveRecordDoctor
           model._commit_callbacks.present? ||
           model._rollback_callbacks.present?
       end
+
+      def dependent_models(model)
+        reflections = model.reflect_on_all_associations(:has_many) +
+                      model.reflect_on_all_associations(:has_one)
+        reflections.map(&:klass)
+      end
+
+      def foreign_key(from_table, to_table)
+        connection.foreign_keys(from_table).find do |foreign_key|
+          foreign_key.to_table == to_table
+        end
+      end
     end
   end
 end

data/lib/active_record_doctor/detectors/incorrect_length_validation.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    class IncorrectLengthValidation < Base # :nodoc:
+      @description = "detect mismatches between database length limits and model length validations"
+      @config = {
+        ignore_models: {
+          description: "models whose validators should not be checked",
+          global: true
+        },
+        ignore_attributes: {
+          description: "attributes, written as Model.attribute, whose validators should not be checked"
+        }
+      }
+
+      private
+
+      def message(model:, attribute:, table:, database_maximum:, model_maximum:)
+        # rubocop:disable Layout/LineLength
+        if database_maximum && model_maximum
+          "the schema limits #{table}.#{attribute} to #{database_maximum} characters but the length validator on #{model}.#{attribute} enforces a maximum of #{model_maximum} characters - set both limits to the same value or remove both"
+        elsif database_maximum && model_maximum.nil?
+          "the schema limits #{table}.#{attribute} to #{database_maximum} characters but there's no length validator on #{model}.#{attribute} - remove the database limit or add the validator"
+        elsif database_maximum.nil? && model_maximum
+          "the length validator on #{model}.#{attribute} enforces a maximum of #{model_maximum} characters but there's no schema limit on #{table}.#{attribute} - remove the validator or the schema length limit"
+        end
+        # rubocop:enable Layout/LineLength
+      end
+
+      def detect
+        models(except: config(:ignore_models)).each do |model|
+          next unless model.table_exists?
+
+          connection.columns(model.table_name).each do |column|
+            next if config(:ignore_attributes).include?("#{model.name}.#{column.name}")
+            next if ![:string, :text].include?(column.type)
+
+            model_maximum = maximum_allowed_by_validations(model)
+            next if model_maximum == column.limit
+
+            problem!(
+              model: model.name,
+              attribute: column.name,
+              table: model.table_name,
+              database_maximum: column.limit,
+              model_maximum: model_maximum
+            )
+          end
+        end
+      end
+
+      def maximum_allowed_by_validations(model)
+        length_validator = model.validators.find do |validator|
+          validator.kind == :length && validator.options.include?(:maximum)
+        end
+        length_validator ? length_validator.options[:maximum] : nil
+      end
+    end
+  end
+end

data/lib/active_record_doctor/detectors/mismatched_foreign_key_type.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    class MismatchedForeignKeyType < Base # :nodoc:
+      @description = "detect foreign key type mismatches"
+      @config = {
+        ignore_tables: {
+          description: "tables whose foreign keys should not be checked",
+          global: true
+        },
+        ignore_columns: {
+          description: "foreign keys, written as table.column, that should not be checked"
+        }
+      }
+
+      private
+
+      def message(table:, column:)
+        # rubocop:disable Layout/LineLength
+        "#{table}.#{column} references a column of different type - foreign keys should be of the same type as the referenced column"
+        # rubocop:enable Layout/LineLength
+      end
+
+      def detect
+        tables(except: config(:ignore_tables)).each do |table|
+          connection.foreign_keys(table).each do |foreign_key|
+            from_column = column(table, foreign_key.column)
+
+            next if config(:ignore_columns).include?("#{table}.#{from_column.name}")
+
+            to_table = foreign_key.to_table
+            primary_key = primary_key(to_table)
+
+            next if from_column.sql_type == primary_key.sql_type
+
+            problem!(table: table, column: from_column.name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/detectors/missing_foreign_keys.rb

@@ -4,32 +4,41 @@ require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
   module Detectors
-    # Find foreign-key like columns lacking an actual foreign key constraint.
-    class MissingForeignKeys < Base
-      @description = "Detect association columns without a foreign key constraint"
-
-      def run
-        problems(hash_from_pairs(tables.reject do |table|
-          table == "schema_migrations"
-        end.map do |table|
-          [
-            table,
-            connection.columns(table).select do |column|
-              # We need to skip polymorphic associations as they can reference
-              # multiple tables but a foreign key constraint can reference
-              # a single predefined table.
-              named_like_foreign_key?(column) &&
-                !foreign_key?(table, column) &&
-                !polymorphic_foreign_key?(table, column)
-            end.map(&:name)
-          ]
-        end.reject do |_table, columns|
-          columns.empty?
-        end))
-      end
+    class MissingForeignKeys < Base # :nodoc:
+      @description = "detect foreign-key-like columns lacking an actual foreign key constraint"
+      @config = {
+        ignore_tables: {
+          description: "tables whose columns should not be checked",
+          global: true
+        },
+        ignore_columns: {
+          description: "columns, written as table.column, that should not be checked"
+        }
+      }
 
       private
 
+      def message(table:, column:)
+        "create a foreign key on #{table}.#{column} - looks like an association without a foreign key constraint"
+      end
+
+      def detect
+        tables(except: config(:ignore_tables)).each do |table|
+          connection.columns(table).each do |column|
+            next if config(:ignore_columns).include?("#{table}.#{column.name}")
+
+            # We need to skip polymorphic associations as they can reference
+            # multiple tables but a foreign key constraint can reference
+            # a single predefined table.
+            next unless named_like_foreign_key?(column)
+            next if foreign_key?(table, column)
+            next if polymorphic_foreign_key?(table, column)
+
+            problem!(table: table, column: column.name)
+          end
+        end
+      end
+
       def named_like_foreign_key?(column)
         column.name.end_with?("_id")
       end

data/lib/active_record_doctor/detectors/missing_non_null_constraint.rb

@@ -4,39 +4,52 @@ require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
   module Detectors
-    # Detect model-level presence validators on columns that lack a non-NULL constraint thus allowing potentially
-    # invalid insertions.
-    class MissingNonNullConstraint < Base
-      @description = "Detect presence validators not backed by a non-NULL constraint"
-
-      def run
-        eager_load!
-
-        problems(hash_from_pairs(models.reject do |model|
-          model.table_name.nil? ||
-          model.table_name == "schema_migrations" ||
-          !table_exists?(model.table_name)
-        end.map do |model|
-          [
-            model.table_name,
-            connection.columns(model.table_name).select do |column|
-              validator_needed?(model, column) &&
-                has_mandatory_presence_validator?(model, column) &&
-                column.null
-            end.map(&:name)
-          ]
-        end.reject do |_model_name, columns|
-          columns.empty?
-        end))
-      end
+    class MissingNonNullConstraint < Base # :nodoc:
+      @description = "detect columns whose presence is always validated but isn't enforced via a non-NULL constraint"
+      @config = {
+        ignore_tables: {
+          description: "tables whose columns should not be checked",
+          global: true
+        },
+        ignore_columns: {
+          description: "columns, written as table.column, that should not be checked"
+        }
+      }
 
       private
 
-      def validator_needed?(model, column)
-        ![model.primary_key, "created_at", "updated_at"].include?(column.name)
+      def message(column:, table:)
+        "add `NOT NULL` to #{table}.#{column} - models validates its presence but it's not non-NULL in the database"
+      end
+
+      def detect
+        table_models = models.group_by(&:table_name)
+        table_models.delete_if { |_table, models| !models.first.table_exists? }
+
+        table_models.each do |table, models|
+          next if config(:ignore_tables).include?(table)
+
+          concrete_models = models.reject do |model|
+            model.abstract_class? || sti_base_model?(model)
+          end
+
+          connection.columns(table).each do |column|
+            next if config(:ignore_columns).include?("#{table}.#{column.name}")
+            next if !column.null
+            next if !concrete_models.all? { |model| non_null_needed?(model, column) }
+            next if not_null_check_constraint_exists?(table, column)
+
+            problem!(column: column.name, table: table)
+          end
+        end
+      end
+
+      def sti_base_model?(model)
+        model.base_class == model &&
+          model.columns_hash.include?(model.inheritance_column.to_s)
       end
 
-      def has_mandatory_presence_validator?(model, column)
+      def non_null_needed?(model, column)
         # A foreign key can be validates via the column name (e.g. company_id)
         # or the association name (e.g. company). We collect the allowed names
         # in an array to check for their presence in the validator definition

data/lib/active_record_doctor/detectors/missing_presence_validation.rb

@@ -4,35 +4,41 @@ require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
   module Detectors
-    # Detect models with non-NULL columns that lack the corresponding model-level validator.
-    class MissingPresenceValidation < Base
-      @description = "Detect non-NULL columns without a presence validator"
+    class MissingPresenceValidation < Base # :nodoc:
+      @description = "detect non-NULL columns without a corresponding presence validator"
+      @config = {
+        ignore_models: {
+          description: "models whose underlying tables' columns should not be checked",
+          global: true
+        },
+        ignore_attributes: {
+          description: "specific attributes, written as Model.attribute, that should not be checked"
+        }
+      }
 
-      def run
-        eager_load!
+      private
 
-        problems(hash_from_pairs(models.reject do |model|
-          model.table_name.nil? ||
-          model.table_name == "schema_migrations" ||
-          !table_exists?(model.table_name)
-        end.map do |model|
-          [
-            model.name,
-            connection.columns(model.table_name).select do |column|
-              validator_needed?(model, column) &&
-                !validator_present?(model, column)
-            end.map(&:name)
-          ]
-        end.reject do |_model_name, columns|
-          columns.empty?
-        end))
+      def message(column:, model:)
+        "add a `presence` validator to #{model}.#{column} - it's NOT NULL but lacks a validator"
       end
 
-      private
+      def detect
+        models(except: config(:ignore_models)).each do |model|
+          next unless model.table_exists?
+
+          connection.columns(model.table_name).each do |column|
+            next unless validator_needed?(model, column)
+            next if validator_present?(model, column)
+            next if config(:ignore_attributes).include?("#{model}.#{column.name}")
+
+            problem!(column: column.name, model: model.name)
+          end
+        end
+      end
 
       def validator_needed?(model, column)
-        ![model.primary_key, "created_at", "updated_at"].include?(column.name) &&
-          !column.null
+        ![model.primary_key, "created_at", "updated_at", "created_on", "updated_on"].include?(column.name) &&
+          (!column.null || not_null_check_constraint_exists?(model.table_name, column))
       end
 
       def validator_present?(model, column)

data/lib/active_record_doctor/detectors/missing_unique_indexes.rb

@@ -4,38 +4,77 @@ require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
   module Detectors
-    # Detect columns covered by a uniqueness validation that lack the corresponding unique index thus risking duplicate
-    # inserts.
-    class MissingUniqueIndexes < Base
-      @description = "Detect columns covered by a uniqueness validator without a unique index"
-
-      def run
-        eager_load!
-
-        problems(hash_from_pairs(models.reject do |model|
-          model.table_name.nil?
-        end.map do |model|
-          [
-            model.table_name,
-            model.validators.select do |validator|
-              table_name = model.table_name
-              scope = validator.options.fetch(:scope, [])
-
-              validator.is_a?(ActiveRecord::Validations::UniquenessValidator) &&
-                supported_validator?(validator) &&
-                !unique_index?(table_name, validator.attributes, scope)
-            end.map do |validator|
-              scope = Array(validator.options.fetch(:scope, []))
-              attributes = validator.attributes
-              (scope + attributes).map(&:to_s)
+    class MissingUniqueIndexes < Base # :nodoc:
+      @description = "detect uniqueness validators not backed by a database constraint"
+      @config = {
+        ignore_models: {
+          description: "models whose uniqueness validators should not be checked",
+          global: true
+        },
+        ignore_columns: {
+          description: "specific validators, written as Model(column1, column2, ...), that should not be checked"
+        }
+      }
+
+      private
+
+      # rubocop:disable Layout/LineLength
+      def message(model:, table:, columns:, problem:)
+        case problem
+        when :validations
+          "add a unique index on #{table}(#{columns.join(', ')}) - validating uniqueness in the model without an index can lead to duplicates"
+        when :has_ones
+          "add a unique index on #{table}(#{columns.first}) - using `has_one` in the #{model.name} model without an index can lead to duplicates"
+        end
+      end
+      # rubocop:enable Layout/LineLength
+
+      def detect
+        validations_without_indexes
+        has_ones_without_indexes
+      end
+
+      def validations_without_indexes
+        models(except: config(:ignore_models)).each do |model|
+          next unless model.table_exists?
+
+          model.validators.each do |validator|
+            scope = Array(validator.options.fetch(:scope, []))
+
+            next unless validator.is_a?(ActiveRecord::Validations::UniquenessValidator)
+            next unless supported_validator?(validator)
+
+            validator.attributes.each do |attribute|
+              columns = resolve_attributes(model, scope + [attribute])
+
+              next if unique_index?(model.table_name, columns)
+              next if ignore_columns.include?("#{model.name}(#{columns.join(',')})")
+
+              problem!(model: model, table: model.table_name, columns: columns, problem: :validations)
             end
-          ]
-        end.reject do |_table_name, indexes|
-          indexes.empty?
-        end))
+          end
+        end
       end
 
-      private
+      def has_ones_without_indexes # rubocop:disable Naming/PredicateName
+        models.each do |model|
+          has_ones = model.reflect_on_all_associations(:has_one)
+          has_ones.each do |has_one|
+            next if has_one.is_a?(ActiveRecord::Reflection::ThroughReflection) || has_one.scope
+
+            association_model = has_one.klass
+            next if config(:ignore_models).include?(association_model.name)
+
+            foreign_key = has_one.foreign_key
+            next if ignore_columns.include?(foreign_key.to_s)
+
+            table_name = association_model.table_name
+            next if unique_index?(table_name, [foreign_key])
+
+            problem!(model: model, table: table_name, columns: [foreign_key], problem: :has_ones)
+          end
+        end
+      end
 
       def supported_validator?(validator)
         validator.options[:if].nil? &&
@@ -49,11 +88,32 @@ module ActiveRecordDoctor
           validator.options.fetch(:case_sensitive, true)
       end
 
-      def unique_index?(table_name, columns, scope)
-        columns = (Array(scope) + columns).map(&:to_s)
+      def resolve_attributes(model, attributes)
+        attributes.flat_map do |attribute|
+          reflection = model.reflect_on_association(attribute)
+
+          if reflection.nil?
+            attribute
+          elsif reflection.polymorphic?
+            [reflection.foreign_type, reflection.foreign_key]
+          else
+            reflection.foreign_key
+          end
+        end.map(&:to_s)
+      end
 
+      def unique_index?(table_name, columns, scope = nil)
+        columns = (Array(scope) + columns).map(&:to_s)
         indexes(table_name).any? do |index|
-          index.columns.to_set == columns.to_set && index.unique
+          index.unique &&
+            index.where.nil? &&
+            (Array(index.columns) - columns).empty?
+        end
+      end
+
+      def ignore_columns
+        @ignore_columns ||= config(:ignore_columns).map do |column|
+          column.gsub(" ", "")
         end
       end
     end

data/lib/active_record_doctor/detectors/short_primary_key_type.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    class ShortPrimaryKeyType < Base # :nodoc:
+      @description = "detect primary keys with short integer types"
+      @config = {
+        ignore_tables: {
+          description: "tables whose primary keys should not be checked",
+          global: true
+        }
+      }
+
+      private
+
+      def message(table:, column:)
+        "change the type of #{table}.#{column} to bigint"
+      end
+
+      def detect
+        tables(except: config(:ignore_tables)).each do |table|
+          column = primary_key(table)
+          next if column.nil?
+          next if bigint?(column) || uuid?(column)
+
+          problem!(table: table, column: column.name)
+        end
+      end
+
+      def bigint?(column)
+        if column.respond_to?(:bigint?)
+          column.bigint?
+        else
+          /\Abigint\b/.match?(column.sql_type)
+        end
+      end
+
+      def uuid?(column)
+        column.sql_type == "uuid"
+      end
+    end
+  end
+end