active_record_doctor 1.5.0 → 1.8.0

data/lib/active_record_doctor/detectors/incorrect_dependent_option.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+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
+
+      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}")
+              end
+
+            [reflection.name, suggestion]
+          elsif callback_action(reflection) == :skip && defines_destroy_callbacks?(reflection.klass)
+            [reflection.name, :suggest_destroy]
+          end
+        end.compact
+      end
+
+      def callback_action(reflection)
+        case reflection.options[:dependent]
+        when :delete_all then :skip
+        when :destroy then :invoke
+        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
+        # being deleted then theoretically we can't use :delete_all. It's a bit
+        # of an edge case as they usually are either absent or have no side
+        # effects but we're being pedantic -- they could be used for audit
+        # trial, for instance, and we don't want to skip that.
+        model._initialize_callbacks.present? ||
+          model._find_callbacks.present? ||
+          model._destroy_callbacks.present? ||
+          model._commit_callbacks.present? ||
+          model._rollback_callbacks.present?
+      end
+    end
+  end
+end

data/lib/active_record_doctor/{tasks → detectors}/missing_foreign_keys.rb

@@ -1,28 +1,16 @@
-require "active_record_doctor/compatibility"
-require "active_record_doctor/printers/io_printer"
+# frozen_string_literal: true
 
-module ActiveRecordDoctor
-  module Tasks
-    class MissingForeignKeys
-      include Compatibility
-
-      def self.run
-        new.run
-      end
+require "active_record_doctor/detectors/base"
 
-      def initialize(printer: ActiveRecordDoctor::Printers::IOPrinter.new)
-        @printer = printer
-      end
+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
-        @printer.print_missing_foreign_keys(missing_foreign_keys)
-      end
-
-      private
-
-      def missing_foreign_keys
-        hash_from_pairs(connection_tables.select do |table|
-          "schema_migrations" != table
+        problems(hash_from_pairs(tables.reject do |table|
+          table == "schema_migrations"
         end.map do |table|
           [
             table,
@@ -30,17 +18,19 @@ module ActiveRecordDoctor
               # We need to skip polymorphic associations as they can reference
               # multiple tables but a foreign key constraint can reference
               # a single predefined table.
-              id?(table, column) &&
+              named_like_foreign_key?(column) &&
                 !foreign_key?(table, column) &&
                 !polymorphic_foreign_key?(table, column)
             end.map(&:name)
           ]
-        end.select do |table, columns|
-          !columns.empty?
-        end)
+        end.reject do |_table, columns|
+          columns.empty?
+        end))
       end
 
-      def id?(table, column)
+      private
+
+      def named_like_foreign_key?(column)
         column.name.end_with?("_id")
       end
 
@@ -51,19 +41,11 @@ module ActiveRecordDoctor
       end
 
       def polymorphic_foreign_key?(table, column)
-        type_column_name = column.name.sub(/_id\Z/, '_type')
+        type_column_name = column.name.sub(/_id\Z/, "_type")
         connection.columns(table).any? do |another_column|
           another_column.name == type_column_name
         end
       end
-
-      def connection
-        @connection ||= ActiveRecord::Base.connection
-      end
-
-      def hash_from_pairs(pairs)
-        Hash[*pairs.flatten(1)]
-      end
     end
   end
 end

data/lib/active_record_doctor/detectors/missing_non_null_constraint.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+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
+
+      private
+
+      def validator_needed?(model, column)
+        ![model.primary_key, "created_at", "updated_at"].include?(column.name)
+      end
+
+      def has_mandatory_presence_validator?(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
+        end
+        attribute_name_forms << belongs_to.name.to_sym if belongs_to
+
+        model.validators.any? do |validator|
+          validator.is_a?(ActiveRecord::Validations::PresenceValidator) &&
+            (validator.attributes & attribute_name_forms).present? &&
+            !validator.options[:allow_nil] &&
+            !validator.options[:if] &&
+            !validator.options[:unless]
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/detectors/missing_presence_validation.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+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"
+
+      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.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))
+      end
+
+      private
+
+      def validator_needed?(model, column)
+        ![model.primary_key, "created_at", "updated_at"].include?(column.name) &&
+          !column.null
+      end
+
+      def validator_present?(model, column)
+        if column.type == :boolean
+          inclusion_validator_present?(model, column) ||
+            exclusion_validator_present?(model, column)
+        else
+          presence_validator_present?(model, column)
+        end
+      end
+
+      def inclusion_validator_present?(model, column)
+        model.validators.any? do |validator|
+          validator.is_a?(ActiveModel::Validations::InclusionValidator) &&
+            validator.attributes.include?(column.name.to_sym) &&
+            !validator.options.fetch(:in, []).include?(nil)
+        end
+      end
+
+      def exclusion_validator_present?(model, column)
+        model.validators.any? do |validator|
+          validator.is_a?(ActiveModel::Validations::ExclusionValidator) &&
+            validator.attributes.include?(column.name.to_sym) &&
+            validator.options.fetch(:in, []).include?(nil)
+        end
+      end
+
+      def presence_validator_present?(model, column)
+        allowed_attributes = [column.name.to_sym]
+
+        belongs_to = model.reflect_on_all_associations(:belongs_to).find do |reflection|
+          reflection.foreign_key == column.name
+        end
+        allowed_attributes << belongs_to.name.to_sym if belongs_to
+
+        model.validators.any? do |validator|
+          validator.is_a?(ActiveRecord::Validations::PresenceValidator) &&
+            (validator.attributes & allowed_attributes).present?
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/detectors/missing_unique_indexes.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+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)
+            end
+          ]
+        end.reject do |_table_name, indexes|
+          indexes.empty?
+        end))
+      end
+
+      private
+
+      def supported_validator?(validator)
+        validator.options[:if].nil? &&
+          validator.options[:unless].nil? &&
+          validator.options[:conditions].nil? &&
+
+          # In Rails 6, default option values are no longer explicitly set on
+          # options so if the key is absent we must fetch the default value
+          # ourselves. case_sensitive is the default in 4.2+ so it's safe to
+          # put true literally.
+          validator.options.fetch(:case_sensitive, true)
+      end
+
+      def unique_index?(table_name, columns, scope)
+        columns = (Array(scope) + columns).map(&:to_s)
+
+        indexes(table_name).any? do |index|
+          index.columns.to_set == columns.to_set && index.unique
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/detectors/undefined_table_references.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    # Find models referencing non-existent database tables or views.
+    class UndefinedTableReferences < Base
+      @description = "Detect models referencing undefined tables or views"
+
+      def run
+        eager_load!
+
+        # If we can't list views due to old Rails version or unsupported
+        # database then existing_views is nil. We inform the caller we haven't
+        # consulted views so that it can display an appropriate warning.
+        existing_views = views
+
+        offending_models = models.select do |model|
+          model.table_name.present? &&
+            !tables.include?(model.table_name) &&
+            (
+              existing_views.nil? ||
+                !existing_views.include?(model.table_name)
+            )
+        end.map do |model|
+          [model.name, model.table_name]
+        end
+
+        problems(offending_models, views_checked: !existing_views.nil?)
+      end
+    end
+  end
+end

data/lib/active_record_doctor/detectors/unindexed_deleted_at.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    # Find unindexed deleted_at columns.
+    class UnindexedDeletedAt < Base
+      PATTERN = [
+        "deleted_at",
+        "discarded_at"
+      ].join("|").freeze
+
+      @description = "Detect unindexed deleted_at columns"
+
+      def run
+        problems(connection.tables.select do |table|
+          connection.columns(table).any? { |column| column.name =~ /^#{PATTERN}$/ }
+        end.flat_map do |table|
+          connection.indexes(table).reject do |index|
+            index.where =~ /\b#{PATTERN}\s+IS\s+NULL\b/i
+          end.map do |index|
+            index.name
+          end
+        end)
+      end
+    end
+  end
+end

data/lib/active_record_doctor/detectors/unindexed_foreign_keys.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    # Find foreign keys that lack indexes (usually recommended for performance reasons).
+    class UnindexedForeignKeys < Base
+      @description = "Detect foreign keys without an index on them"
+
+      def run
+        problems(hash_from_pairs(tables.reject do |table|
+          table == "schema_migrations"
+        end.map do |table|
+          [
+            table,
+            connection.columns(table).select do |column|
+              foreign_key?(column) &&
+                !indexed?(table, column) &&
+                !indexed_as_polymorphic?(table, column)
+            end.map(&:name)
+          ]
+        end.reject do |_table, columns|
+          columns.empty?
+        end))
+      end
+
+      private
+
+      def foreign_key?(column)
+        column.name.end_with?("_id")
+      end
+
+      def indexed?(table, column)
+        connection.indexes(table).any? do |index|
+          index.columns.first == column.name
+        end
+      end
+
+      def indexed_as_polymorphic?(table, column)
+        type_column_name = column.name.sub(/_id\Z/, "_type")
+        connection.indexes(table).any? do |index|
+          index.columns == [type_column_name, column.name]
+        end
+      end
+    end
+  end
+end