active_record_doctor 1.7.2 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 649707d9a4a22831b3733778ad05614cc71f8edb704a68e9b18bd784a350daf9
-  data.tar.gz: 6e0fc8fe22ba882549152203c3a92f3eeebd3effb3f4eead6245001849b9e5de
+  metadata.gz: 296a8bbb4a326fd78afb08638435754646e22a4416dc18b02dc66f54198a9130
+  data.tar.gz: 5548b71ee3bb95344e34896a7c972cf39ce33f8a4bd1b03a1a2bf02b4081a1dd
 SHA512:
-  metadata.gz: 437df56684da87b78b3336337cabe138f5375c54673a5d02da29b06fa9d238e1c9fa34a4cf9973b7bf944a0ef8ebbed5ec9dd9d9d12612f87e16597292ff22aa
-  data.tar.gz: 3ee83bab9d6dc5c88c4c47d33d69d30ecf373bb6ab4798accfc681066fd0a1a4580295f29a869c69a9ff582c925f7c2cb328b345429a92623942995a0416e1d6
+  metadata.gz: 48c447ca18f35ee44db354414980f54d0ee9416ecc81b6b3fef9401afbaeb44b2951f0fabe43c89027d8783430bdbb6b055ca1000779e37d3729a171649ce795
+  data.tar.gz: 89ab1d3e4cca4df9c94022e0f11217b41239a3b5f2b3c579d8e466a4fe337909ab48f0b05d28eb5a67fc93afa4afe88a47c7c0ebbd3dc7d45c6d0259db22de40

data/README.md

@@ -12,6 +12,7 @@ can:
 * detect missing non-`NULL` constraints - [`active_record_doctor:missing_non_null_constraint`](#detecting-missing-non-null-constraints)
 * detect missing presence validations - [`active_record_doctor:missing_presence_validation`](#detecting-missing-presence-validations)
 * detect incorrect presence validations on boolean columns - [`active_record_doctor:incorrect_boolean_presence_validation`](#detecting-incorrect-presence-validations-on-boolean-columns)
+* detect incorrect values of `dependent` on associations - [`active_record_doctor:incorrect_dependent_option`](#detecting-incorrect-dependent-option-on-associations)
 
 More features coming soon!
 
@@ -284,6 +285,34 @@ This means `active` is validated with `presence: true` instead of
 
 This validator skips models whose corresponding database tables don't exist.
 
+### Detecting Incorrect `dependent` Option on Associations
+
+Cascading model deletions can be sped up with `dependent: :delete_all` (to
+delete all dependent models with one SQL query) but only if the deleted models
+have no callbacks as they're skipped.
+
+This can lead to two types of errors:
+
+- Using `delete_all` when dependent models define callbacks - they will NOT be
+  invoked.
+- Using `destroy` when dependent models define no callbacks - dependent models
+  will be loaded one-by-one with no reason
+
+In order to detect associations affected by the two aforementioned problems run
+the following command:
+
+```
+bundle exec rake active_record_doctor:incorrect_dependent_option
+```
+
+The output of the command looks like this:
+
+```
+The following associations might be using invalid dependent settings:
+  Company: users loads models one-by-one to invoke callbacks even though the related model defines none - consider using `dependent: :delete_all`
+  Post: comments skips callbacks that are defined on the associated model - consider changing to `dependent: :destroy` or similar
+```
+
 ## Ruby and Rails Compatibility Policy
 
 The goal of the policy is to ensure proper functioning in reasonable

data/lib/active_record_doctor.rb

@@ -1,18 +1,22 @@
+# frozen_string_literal: true
+
 require "active_record_doctor/printers"
 require "active_record_doctor/printers/io_printer"
 require "active_record_doctor/railtie" if defined?(Rails) && defined?(Rails::Railtie)
-require "active_record_doctor/tasks"
-require "active_record_doctor/tasks/base"
-require "active_record_doctor/tasks/missing_presence_validation"
-require "active_record_doctor/tasks/missing_foreign_keys"
-require "active_record_doctor/tasks/missing_unique_indexes"
-require "active_record_doctor/tasks/incorrect_boolean_presence_validation"
-require "active_record_doctor/tasks/extraneous_indexes"
-require "active_record_doctor/tasks/unindexed_deleted_at"
-require "active_record_doctor/tasks/undefined_table_references"
-require "active_record_doctor/tasks/missing_non_null_constraint"
-require "active_record_doctor/tasks/unindexed_foreign_keys"
+require "active_record_doctor/detectors"
+require "active_record_doctor/detectors/base"
+require "active_record_doctor/detectors/missing_presence_validation"
+require "active_record_doctor/detectors/missing_foreign_keys"
+require "active_record_doctor/detectors/missing_unique_indexes"
+require "active_record_doctor/detectors/incorrect_boolean_presence_validation"
+require "active_record_doctor/detectors/extraneous_indexes"
+require "active_record_doctor/detectors/unindexed_deleted_at"
+require "active_record_doctor/detectors/undefined_table_references"
+require "active_record_doctor/detectors/missing_non_null_constraint"
+require "active_record_doctor/detectors/unindexed_foreign_keys"
+require "active_record_doctor/detectors/incorrect_dependent_option"
+require "active_record_doctor/task"
 require "active_record_doctor/version"
 
-module ActiveRecordDoctor
+module ActiveRecordDoctor # :nodoc:
 end

data/lib/active_record_doctor/detectors.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext/class/subclasses"
+
+module ActiveRecordDoctor
+  # Container module for all detectors, implemented as separate classes.
+  module Detectors
+    def self.all
+      ActiveRecordDoctor::Detectors::Base.subclasses
+    end
+  end
+end

data/lib/active_record_doctor/detectors/base.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ActiveRecordDoctor
+  module Detectors
+    # Base class for all active_record_doctor detectors.
+    class Base
+      class << self
+        attr_reader :description
+
+        def run
+          new.run
+        end
+      end
+
+      private
+
+      def problems(problems, options = {})
+        [problems, options]
+      end
+
+      def connection
+        @connection ||= ActiveRecord::Base.connection
+      end
+
+      def indexes(table_name)
+        connection.indexes(table_name)
+      end
+
+      def tables
+        connection.tables
+      end
+
+      def table_exists?(table_name)
+        connection.table_exists?(table_name)
+      end
+
+      def views
+        @views ||=
+          if connection.respond_to?(:views)
+            connection.views
+          elsif connection.adapter_name == "PostgreSQL"
+            ActiveRecord::Base.connection.execute(<<-SQL).map { |tuple| tuple.fetch("relname") }
+              SELECT c.relname FROM pg_class c WHERE c.relkind IN ('m', 'v')
+            SQL
+          else # rubocop:disable Style/EmptyElse
+            # We don't support this Rails/database combination yet.
+            nil
+          end
+      end
+
+      def hash_from_pairs(pairs)
+        Hash[*pairs.flatten(1)]
+      end
+
+      def eager_load!
+        Rails.application.eager_load!
+      end
+
+      def models
+        ActiveRecord::Base.descendants
+      end
+    end
+  end
+end

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

@@ -1,19 +1,23 @@
-require "active_record_doctor/tasks/base"
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
-  module Tasks
+  module Detectors
+    # Detect indexes whose function can be overtaken by other indexes. For example, an index on columns A, B, and C
+    # can also serve as an index on A and A, B.
     class ExtraneousIndexes < Base
-      @description = 'Detect extraneous indexes'
+      @description = "Detect extraneous indexes"
 
       def run
-        success(subindexes_of_multi_column_indexes + indexed_primary_keys)
+        problems(subindexes_of_multi_column_indexes + indexed_primary_keys)
       end
 
       private
 
       def subindexes_of_multi_column_indexes
         tables.reject do |table|
-          "schema_migrations" == table
+          table == "schema_migrations"
         end.flat_map do |table|
           indexes = indexes(table)
           maximum_indexes = indexes.select do |index|
@@ -38,7 +42,7 @@ module ActiveRecordDoctor
 
       def indexed_primary_keys
         @indexed_primary_keys ||= tables.reject do |table|
-          "schema_migrations" == table
+          table == "schema_migrations"
         end.map do |table|
           [
             table,
@@ -77,7 +81,7 @@ module ActiveRecordDoctor
       end
 
       def indexes(table_name)
-        super.select { |index| index.columns.kind_of?(Array) }
+        super.select { |index| index.columns.is_a?(Array) }
       end
     end
   end

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

@@ -1,16 +1,19 @@
-require "active_record_doctor/tasks/base"
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
-  module Tasks
+  module Detectors
+    # Find instances of boolean column presence validations that use presence/absence instead of includes/excludes.
     class IncorrectBooleanPresenceValidation < Base
-      @description = 'Detect boolean columns with presence/absence instead of includes/excludes validators'
+      @description = "Detect boolean columns with presence/absence instead of includes/excludes validators"
 
       def run
         eager_load!
 
-        success(hash_from_pairs(models.reject do |model|
+        problems(hash_from_pairs(models.reject do |model|
           model.table_name.nil? ||
-            model.table_name == 'schema_migrations' ||
+            model.table_name == "schema_migrations" ||
             !table_exists?(model.table_name)
         end.map do |model|
           [
@@ -20,7 +23,7 @@ module ActiveRecordDoctor
                 has_presence_validator?(model, column)
             end.map(&:name)
           ]
-        end.reject do |model_name, columns|
+        end.reject do |_model_name, columns|
           columns.empty?
         end))
       end

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,13 +1,16 @@
-require "active_record_doctor/tasks/base"
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
-  module Tasks
+  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'
+      @description = "Detect association columns without a foreign key constraint"
 
       def run
-        success(hash_from_pairs(tables.select do |table|
-          "schema_migrations" != table
+        problems(hash_from_pairs(tables.reject do |table|
+          table == "schema_migrations"
         end.map do |table|
           [
             table,
@@ -15,19 +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.reject do |_table, columns|
+          columns.empty?
         end))
       end
 
       private
 
-      def id?(table, column)
+      def named_like_foreign_key?(column)
         column.name.end_with?("_id")
       end
 
@@ -38,7 +41,7 @@ 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

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

@@ -1,16 +1,20 @@
-require "active_record_doctor/tasks/base"
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
-  module Tasks
+  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'
+      @description = "Detect presence validators not backed by a non-NULL constraint"
 
       def run
         eager_load!
 
-        success(hash_from_pairs(models.reject do |model|
+        problems(hash_from_pairs(models.reject do |model|
           model.table_name.nil? ||
-          model.table_name == 'schema_migrations' ||
+          model.table_name == "schema_migrations" ||
           !table_exists?(model.table_name)
         end.map do |model|
           [
@@ -21,7 +25,7 @@ module ActiveRecordDoctor
                 column.null
             end.map(&:name)
           ]
-        end.reject do |model_name, columns|
+        end.reject do |_model_name, columns|
           columns.empty?
         end))
       end
@@ -29,7 +33,7 @@ module ActiveRecordDoctor
       private
 
       def validator_needed?(model, column)
-        ![model.primary_key, 'created_at', 'updated_at'].include?(column.name)
+        ![model.primary_key, "created_at", "updated_at"].include?(column.name)
       end
 
       def has_mandatory_presence_validator?(model, column)

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

@@ -1,16 +1,19 @@
-require "active_record_doctor/tasks/base"
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
-  module Tasks
+  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'
+      @description = "Detect non-NULL columns without a presence validator"
 
       def run
         eager_load!
 
-        success(hash_from_pairs(models.reject do |model|
+        problems(hash_from_pairs(models.reject do |model|
           model.table_name.nil? ||
-          model.table_name == 'schema_migrations' ||
+          model.table_name == "schema_migrations" ||
           !table_exists?(model.table_name)
         end.map do |model|
           [
@@ -20,7 +23,7 @@ module ActiveRecordDoctor
                 !validator_present?(model, column)
             end.map(&:name)
           ]
-        end.reject do |model_name, columns|
+        end.reject do |_model_name, columns|
           columns.empty?
         end))
       end
@@ -28,7 +31,7 @@ module ActiveRecordDoctor
       private
 
       def validator_needed?(model, column)
-        ![model.primary_key, 'created_at', 'updated_at'].include?(column.name) &&
+        ![model.primary_key, "created_at", "updated_at"].include?(column.name) &&
           !column.null
       end
 
@@ -53,7 +56,7 @@ module ActiveRecordDoctor
         model.validators.any? do |validator|
           validator.is_a?(ActiveModel::Validations::ExclusionValidator) &&
             validator.attributes.include?(column.name.to_sym) &&
-              validator.options.fetch(:in, []).include?(nil)
+            validator.options.fetch(:in, []).include?(nil)
         end
       end