active_record_doctor 1.9.0 → 1.11.0

data/lib/active_record_doctor/detectors/extraneous_indexes.rb

@@ -33,82 +33,64 @@ module ActiveRecordDoctor
       end
 
       def subindexes_of_multi_column_indexes
-        tables(except: config(:ignore_tables)).each do |table|
-          indexes = indexes(table)
-          maximal_indexes = indexes.select { |index| maximal?(indexes, index) }
-
-          indexes.each do |index|
-            next if maximal_indexes.include?(index)
-
-            replacement_indexes = maximal_indexes.select do |maximum_index|
-              cover?(maximum_index, index)
-            end.map(&:name).sort
-
-            next if config(:ignore_indexes).include?(index.name)
-
-            problem!(extraneous_index: index.name, replacement_indexes: replacement_indexes)
+        log(__method__) do
+          each_table(except: config(:ignore_tables)) do |table|
+            each_index(table, except: config(:ignore_indexes), multicolumn_only: true) do |index, indexes|
+              replacement_indexes = indexes.select do |other_index|
+                index != other_index && replaceable_with?(index, other_index)
+              end
+
+              if replacement_indexes.empty?
+                log("Found no replacement indexes; skipping")
+                next
+              end
+
+              problem!(
+                extraneous_index: index.name,
+                replacement_indexes: replacement_indexes.map(&:name).sort
+              )
+            end
           end
         end
       end
 
       def indexed_primary_keys
-        tables(except: config(:ignore_tables)).each do |table|
-          indexes(table).each do |index|
-            next if config(:ignore_indexes).include?(index.name)
-            next if index.columns != ["id"]
-
-            problem!(extraneous_index: index.name, replacement_indexes: nil)
+        log(__method__) do
+          each_table(except: config(:ignore_tables)) do |table|
+            each_index(table, except: config(:ignore_indexes), multicolumn_only: true) do |index|
+              primary_key = connection.primary_key(table)
+              if index.columns == [primary_key] && index.where.nil?
+                problem!(extraneous_index: index.name, replacement_indexes: nil)
+              end
+            end
           end
         end
       end
 
-      def maximal?(indexes, index)
-        indexes.all? do |another_index|
-          index == another_index || !cover?(another_index, index)
-        end
-      end
-
-      # Does lhs cover rhs?
-      def cover?(lhs, rhs)
-        return false unless compatible_options?(lhs, rhs)
+      def replaceable_with?(index1, index2)
+        return false if index1.type != index2.type
+        return false if index1.using != index2.using
+        return false if index1.where != index2.where
+        return false if opclasses(index1) != opclasses(index2)
 
-        case [lhs.unique, rhs.unique]
+        case [index1.unique, index2.unique]
         when [true, true]
-          lhs.columns == rhs.columns
-        when [false, true]
+          (index2.columns - index1.columns).empty?
+        when [true, false]
           false
         else
-          prefix?(rhs, lhs)
+          prefix?(index1, index2)
         end
       end
 
+      def opclasses(index)
+        index.respond_to?(:opclasses) ? index.opclasses : nil
+      end
+
       def prefix?(lhs, rhs)
         lhs.columns.count <= rhs.columns.count &&
           rhs.columns[0...lhs.columns.count] == lhs.columns
       end
-
-      def indexes(table_name)
-        super.select { |index| index.columns.is_a?(Array) }
-      end
-
-      def compatible_options?(lhs, rhs)
-        lhs.type == rhs.type &&
-          lhs.using == rhs.using &&
-          lhs.where == rhs.where &&
-          same_opclasses?(lhs, rhs)
-      end
-
-      def same_opclasses?(lhs, rhs)
-        if ActiveRecord::VERSION::STRING >= "5.2"
-          rhs.columns.all? do |column|
-            lhs_opclass = lhs.opclasses.is_a?(Hash) ? lhs.opclasses[column] : lhs.opclasses
-            rhs_opclass = rhs.opclasses.is_a?(Hash) ? rhs.opclasses[column] : rhs.opclasses
-            lhs_opclass == rhs_opclass
-          end
-        else
-          true
-        end
-      end
     end
   end
 end

data/lib/active_record_doctor/detectors/incorrect_boolean_presence_validation.rb

@@ -25,12 +25,8 @@ module ActiveRecordDoctor
       end
 
       def detect
-        models(except: config(:ignore_models)).each do |model|
-          next if model.table_name.nil?
-          next unless table_exists?(model.table_name)
-
-          connection.columns(model.table_name).each do |column|
-            next if config(:ignore_attributes).include?("#{model.name}.#{column.name}")
+        each_model(except: config(:ignore_models), existing_tables_only: true) do |model|
+          each_attribute(model, except: config(:ignore_attributes)) do |column|
             next unless column.type == :boolean
             next unless has_presence_validator?(model, column)
 

data/lib/active_record_doctor/detectors/incorrect_dependent_option.rb

@@ -18,31 +18,77 @@ module ActiveRecordDoctor
 
       private
 
-      def message(model:, association:, problem:)
+      def message(model:, association:, problem:, associated_models:, associated_models_type:)
+        associated_models.sort!
+
+        models_part =
+          if associated_models.length == 1
+            "model #{associated_models[0]} has"
+          else
+            "models #{associated_models.join(', ')} have"
+          end
+
+        if associated_models_type
+          models_part = "#{associated_models_type} #{models_part}"
+        end
+
         # rubocop:disable Layout/LineLength
         case problem
+        when :invalid_through
+          "ensure #{model}.#{association} is configured correctly - #{associated_models[0]}.#{association} may be undefined"
         when :suggest_destroy
-          "use `dependent: :destroy` or similar on #{model}.#{association} - the associated model has callbacks that are currently skipped"
+          "use `dependent: :destroy` or similar on #{model}.#{association} - associated #{models_part} callbacks that are currently skipped"
         when :suggest_delete
-          "use `dependent: :delete` or similar on #{model}.#{association} - the associated model has no callbacks and can be deleted without loading"
+          "use `dependent: :delete` or similar on #{model}.#{association} - 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 have no validations and can be deleted in bulk"
+          "use `dependent: :delete_all` or similar on #{model}.#{association} - associated #{models_part} no callbacks and can be deleted in bulk"
         end
         # rubocop:enable Layout/LineLength
       end
 
       def detect
-        models(except: config(:ignore_models)).each do |model|
-          next if model.table_name.nil?
+        each_model(except: config(:ignore_models), existing_tables_only: true) do |model|
+          each_association(model, except: config(:ignore_associations)) do |association|
+            # A properly configured :through association will have a non-nil
+            # source_reflection. If it's nil then it indicates the :through
+            # model lacks the next leg in the :through relationship. For
+            # instance, if user has many comments through posts then a nil
+            # source_reflection means that Post doesn't define +has_many :comments+.
+            if through?(association) && association.source_reflection.nil?
+              log("through association with nil source_reflection")
 
-          associations = model.reflect_on_all_associations(:has_many) +
-                         model.reflect_on_all_associations(:has_one) +
-                         model.reflect_on_all_associations(:belongs_to)
+              through_association = model.reflect_on_association(association.options.fetch(:through))
+              association_on_join_model = through_association.klass.reflect_on_association(association.name)
 
-          associations.each do |association|
-            next if config(:ignore_associations).include?("#{model.name}.#{association.name}")
+              # We report a problem only if the +has_many+ association mentioned
+              # above is actually missing. We let the detector continue in other
+              # cases, risking an exception, as the absence of source_reflection
+              # must be caused by something else in those cases. Each further
+              # exception will be handled on a case-by-case basis.
+              if association_on_join_model.nil?
+                problem!(
+                  model: model.name,
+                  association: association.name,
+                  problem: :invalid_through,
+                  associated_models: [through_association.klass.name],
+                  associated_models_type: "join"
+                )
+                next
+              end
+            end
+
+            associated_models, associated_models_type =
+              if association.polymorphic?
+                [models_having_association_with_options(as: association.name), nil]
+              elsif through?(association)
+                [[association.source_reflection.active_record], "join"]
+              else
+                [[association.klass], nil]
+              end
 
-            if callback_action(association) == :invoke && deletable?(association.klass)
+            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
@@ -50,14 +96,37 @@ module ActiveRecordDoctor
                 else raise("unsupported association type #{association.macro}")
                 end
 
-              problem!(model: model.name, association: association.name, problem: suggestion)
-            elsif callback_action(association) == :skip && !deletable?(association.klass)
-              problem!(model: model.name, association: association.name, problem: :suggest_destroy)
+              problem!(
+                model: model.name,
+                association: association.name,
+                problem: suggestion,
+                associated_models: deletable_models.map(&:name),
+                associated_models_type: associated_models_type
+              )
+            elsif callback_action(association) == :skip && destroyable_models.present?
+              problem!(
+                model: model.name,
+                association: association.name,
+                problem: :suggest_destroy,
+                associated_models: destroyable_models.map(&:name),
+                associated_models_type: associated_models_type
+              )
             end
           end
         end
       end
 
+      def models_having_association_with_options(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, :delete_all then :skip
@@ -77,6 +146,10 @@ module ActiveRecordDoctor
           end
       end
 
+      def through?(reflection)
+        reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+      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

data/lib/active_record_doctor/detectors/incorrect_length_validation.rb

@@ -0,0 +1,60 @@
+# 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
+        each_model(except: config(:ignore_models), existing_tables_only: true) do |model|
+          each_attribute(model, except: config(:ignore_attributes), type: [:string, :text]) do |column|
+            model_maximum = maximum_allowed_by_validations(model, column.name.to_sym)
+            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, column)
+        length_validator = model.validators.find do |validator|
+          validator.kind == :length &&
+            validator.options.include?(:maximum) &&
+            validator.attributes.include?(column)
+        end
+        length_validator ? length_validator.options[:maximum] : nil
+      end
+    end
+  end
+end

data/lib/active_record_doctor/detectors/mismatched_foreign_key_type.rb

@@ -18,25 +18,32 @@ module ActiveRecordDoctor
 
       private
 
-      def message(table:, column:)
+      def message(from_table:, from_column:, from_type:, to_table:, to_column:, to_type:)
         # rubocop:disable Layout/LineLength
-        "#{table}.#{column} references a column of different type - foreign keys should be of the same type as the referenced column"
+        "#{from_table}.#{from_column} is a foreign key of type #{from_type} and references #{to_table}.#{to_column} of type #{to_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|
+        each_table(except: config(:ignore_tables)) do |table|
+          each_foreign_key(table) 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)
+            to_column = column(to_table, foreign_key.primary_key)
+
+            next if from_column.sql_type == to_column.sql_type
+
+            problem!(
+              from_table: table,
+              from_column: from_column.name,
+              from_type: from_column.sql_type,
+              to_table: to_table,
+              to_column: to_column.name,
+              to_type: to_column.sql_type
+            )
           end
         end
       end

data/lib/active_record_doctor/detectors/missing_foreign_keys.rb

@@ -23,10 +23,8 @@ module ActiveRecordDoctor
       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}")
-
+        each_table(except: config(:ignore_tables)) do |table|
+          each_column(table, except: config(:ignore_columns)) 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.

data/lib/active_record_doctor/detectors/missing_non_null_constraint.rb

@@ -23,8 +23,7 @@ module ActiveRecordDoctor
       end
 
       def detect
-        table_models = models.group_by(&:table_name)
-        table_models.delete_if { |table| table.nil? || !table_exists?(table) }
+        table_models = models.select(&:table_exists?).group_by(&:table_name)
 
         table_models.each do |table, models|
           next if config(:ignore_tables).include?(table)
@@ -37,6 +36,7 @@ module ActiveRecordDoctor
             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
@@ -49,19 +49,22 @@ module ActiveRecordDoctor
       end
 
       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
-        # in one go.
-        attribute_name_forms = [column.name.to_sym]
         belongs_to = model.reflect_on_all_associations(:belongs_to).find do |reflection|
-          reflection.foreign_key == column.name
+          reflection.foreign_key == column.name ||
+            (reflection.polymorphic? && reflection.foreign_type == column.name)
         end
-        attribute_name_forms << belongs_to.name.to_sym if belongs_to
 
-        model.validators.any? do |validator|
+        required_presence_validators(model).any? do |validator|
+          attributes = validator.attributes
+
+          attributes.include?(column.name.to_sym) ||
+            (belongs_to && attributes.include?(belongs_to.name.to_sym))
+        end
+      end
+
+      def required_presence_validators(model)
+        model.validators.select do |validator|
           validator.is_a?(ActiveRecord::Validations::PresenceValidator) &&
-            (validator.attributes & attribute_name_forms).present? &&
             !validator.options[:allow_nil] &&
             !validator.options[:if] &&
             !validator.options[:unless]

data/lib/active_record_doctor/detectors/missing_presence_validation.rb

@@ -23,14 +23,10 @@ module ActiveRecordDoctor
       end
 
       def detect
-        models(except: config(:ignore_models)).each do |model|
-          next if model.table_name.nil?
-          next unless table_exists?(model.table_name)
-
-          connection.columns(model.table_name).each do |column|
+        each_model(except: config(:ignore_models), existing_tables_only: true) do |model|
+          each_attribute(model, except: config(:ignore_attributes)) 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
@@ -38,8 +34,8 @@ module ActiveRecordDoctor
       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)
@@ -53,17 +49,23 @@ module ActiveRecordDoctor
 
       def inclusion_validator_present?(model, column)
         model.validators.any? do |validator|
+          validator_items = inclusion_validator_items(validator)
+          return true if validator_items.is_a?(Proc)
+
           validator.is_a?(ActiveModel::Validations::InclusionValidator) &&
             validator.attributes.include?(column.name.to_sym) &&
-            !validator.options.fetch(:in, []).include?(nil)
+            !validator_items.include?(nil)
         end
       end
 
       def exclusion_validator_present?(model, column)
         model.validators.any? do |validator|
+          validator_items = inclusion_validator_items(validator)
+          return true if validator_items.is_a?(Proc)
+
           validator.is_a?(ActiveModel::Validations::ExclusionValidator) &&
             validator.attributes.include?(column.name.to_sym) &&
-            validator.options.fetch(:in, []).include?(nil)
+            validator_items.include?(nil)
         end
       end
 
@@ -80,6 +82,10 @@ module ActiveRecordDoctor
             (validator.attributes & allowed_attributes).present?
         end
       end
+
+      def inclusion_validator_items(validator)
+        validator.options[:in] || validator.options[:within] || []
+      end
     end
   end
 end

data/lib/active_record_doctor/detectors/missing_unique_indexes.rb

@@ -18,31 +18,54 @@ module ActiveRecordDoctor
 
       private
 
-      def message(table:, columns:)
-        # rubocop:disable Layout/LineLength
-        "add a unique index on #{table}(#{columns.join(', ')}) - validating uniqueness in the model without an index can lead to duplicates"
-        # rubocop:enable Layout/LineLength
+      # 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
-        ignore_columns = config(:ignore_columns).map do |column|
-          column.gsub(" ", "")
-        end
-
-        models(except: config(:ignore_models)).each do |model|
-          next if model.table_name.nil?
+        validations_without_indexes
+        has_ones_without_indexes
+      end
 
+      def validations_without_indexes
+        each_model(except: config(:ignore_models), existing_tables_only: true) do |model|
           model.validators.each do |validator|
             scope = Array(validator.options.fetch(:scope, []))
 
             next unless validator.is_a?(ActiveRecord::Validations::UniquenessValidator)
             next unless supported_validator?(validator)
-            next if unique_index?(model.table_name, validator.attributes, scope)
 
-            columns = (scope + validator.attributes).map(&:to_s)
-            next if ignore_columns.include?("#{model.name}(#{columns.join(',')})")
+            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
+        end
+      end
+
+      def has_ones_without_indexes # rubocop:disable Naming/PredicateName
+        each_model do |model|
+          each_association(model, type: :has_one, has_scope: false, through: false) do |has_one|
+            next if config(:ignore_models).include?(has_one.klass.name)
 
-            problem!(table: model.table_name, columns: columns)
+            foreign_key = has_one.foreign_key
+            next if ignore_columns.include?(foreign_key.to_s)
+
+            table_name = has_one.klass.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
@@ -59,11 +82,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

@@ -20,10 +20,10 @@ module ActiveRecordDoctor
       end
 
       def detect
-        tables(except: config(:ignore_tables)).each do |table|
+        each_table(except: config(:ignore_tables)) do |table|
           column = primary_key(table)
           next if column.nil?
-          next if bigint?(column)
+          next if bigint?(column) || uuid?(column)
 
           problem!(table: table, column: column.name)
         end
@@ -36,6 +36,10 @@ module ActiveRecordDoctor
           /\Abigint\b/.match?(column.sql_type)
         end
       end
+
+      def uuid?(column)
+        column.sql_type == "uuid"
+      end
     end
   end
 end

data/lib/active_record_doctor/detectors/undefined_table_references.rb

@@ -20,10 +20,8 @@ module ActiveRecordDoctor
       end
 
       def detect
-        models(except: config(:ignore_models)).each do |model|
-          next if model.table_name.nil?
-          next if tables.include?(model.table_name)
-          next if tables_and_views.include?(model.table_name)
+        each_model(except: config(:ignore_models), abstract: false) do |model|
+          next if connection.data_source_exists?(model.table_name)
 
           problem!(model: model.name, table: model.table_name)
         end