active_record_doctor 1.14.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89e283c2844a768587302646735a080d8db2b3514775083cc6bc74a25e7aff18
-  data.tar.gz: 975a75da213c565dba3ee7918ffe64d5b75d812059b8080d6a5134a2fb27028f
+  metadata.gz: 8bae986a04fe63835ce7e190f32471cc06a370972161c487cac195ef33f73269
+  data.tar.gz: c5a2f92f0b31ec1faedfd65fc5abe9ef656f75b9fa933719e57f180b4fb0f28d
 SHA512:
-  metadata.gz: ca4a89d161ef3a57ee325ea6551417b9e542967d2f932f383eca6e7394ba99f02cf08ac9cd699e98f1f59018669405220fe1175f80d31f60576fc606d2d3f5f6
-  data.tar.gz: 70644778b22b9fe2892d12704cdfb3d81337702e8770ca94f8410694e3a8b12ad931bc511bc5188f77726849fca7c87c1ce8fec059d647ea4225adf6ab1363ef
+  metadata.gz: 7759e1effdfcea2382966f8973c2c132bda909b847a14914fb7a46b795a7d0407f9605efa39dfece9d889ee65b35f334f78e6664928fbbe03e349f792845ae7f
+  data.tar.gz: c563de0bbf91966325eddd2bafedb3dadcc07ca39e7c27a529fdb544113eadba4f2373e9d618a074205a8716687f7684f232a212711fcf5d50fc1484999b1074

data/README.md

@@ -15,12 +15,16 @@ can detect:
 * incorrect values of `dependent` on associations - [`active_record_doctor:incorrect_dependent_option`](#detecting-incorrect-dependent-option-on-associations)
 * primary keys having short integer types - [`active_record_doctor:short_primary_key_type`](#detecting-primary-keys-having-short-integer-types)
 * mismatched foreign key types - [`active_record_doctor:mismatched_foreign_key_type`](#detecting-mismatched-foreign-key-types)
+* tables without primary keys - [`active_record_doctor:table_without_primary_key`](#detecting-tables-without-primary-keys)
+* tables without timestamps - [`active_record_doctor:table_without_timestamps`](#detecting-tables-without-timestamps)
 
 It can also:
 
 * index unindexed foreign keys - [`active_record_doctor:unindexed_foreign_keys`](#indexing-unindexed-foreign-keys)
 
-[![Build Status](https://github.com/gregnavis/active_record_doctor/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/gregnavis/active_record_doctor/actions/workflows/test.yml)
+[![Build Status](https://github.com/gregnavis/active_record_doctor/actions/workflows/lint.yml/badge.svg?branch=master)](https://github.com/gregnavis/active_record_doctor/actions/workflows/lint.yml)
+[![Build Status](https://github.com/gregnavis/active_record_doctor/actions/workflows/mysql.yml/badge.svg?branch=master)](https://github.com/gregnavis/active_record_doctor/actions/workflows/mysql.yml)
+[![Build Status](https://github.com/gregnavis/active_record_doctor/actions/workflows/postgresql.yml/badge.svg?branch=master)](https://github.com/gregnavis/active_record_doctor/actions/workflows/postgresql.yml)
 
 ## Installation
 
@@ -28,14 +32,14 @@ In order to use the latest production release, please add the following to
 your `Gemfile`:
 
 ```ruby
-gem 'active_record_doctor', group: :development
+gem 'active_record_doctor', group: [:development, :test]
 ```
 
 and run `bundle install`. If you'd like to use the most recent development
 version then use this instead:
 
 ```ruby
-gem 'active_record_doctor', github: 'gregnavis/active_record_doctor'
+gem 'active_record_doctor', github: 'gregnavis/active_record_doctor', group: [:development, :test]
 ```
 
 That's it when it comes to Rails projects. If your project doesn't use Rails
@@ -101,6 +105,17 @@ bundle exec rake active_record_doctor:extraneous_indexes:help
 This will show the detector help text in the terminal, along with supported
 configuration options, their meaning, and whether they're global or local.
 
+### Debug Logging
+
+It may be that `active_record_doctor` fails with an exception and it is hard to tell
+what went wrong. For easier debugging, use `ACTIVE_RECORD_DOCTOR_DEBUG` environment variable.
+If `active_record_doctor` fails for some reason for your application, feel free
+to open an issue or a PR with the fix.
+
+```
+ACTIVE_RECORD_DOCTOR_DEBUG=1 bundle exec rake active_record_doctor
+```
+
 ### Configuration
 
 `active_record_doctor` can be configured to better suit your project's needs.
@@ -146,28 +161,26 @@ obtained via the help mechanism described in the previous section.
 
 ### Regexp-Based Ignores
 
-Settings like `ignore_tables`, `ignore_indexes`, and so on accept list of
-identifiers to ignore. These can be either:
+Settings like `ignore_tables`, `ignore_indexes`, `ignore_models` and so on
+accept list of identifiers to ignore. These can be either:
 
 1. Strings - in which case an exact match is needed.
 2. Regexps - which are matched against object names, and matching ones are
    excluded from output.
 
-For example, to ignore all tables starting with `legacy_` you can write:
+For example, to ignore all tables starting with `legacy_` and all models under
+the `Legacy::` namespace you can write:
 
 ```ruby
 ActiveRecordDoctor.configure do
   global :ignore_tables, [
-    # Ignore internal Rails-related tables.
-    "ar_internal_metadata",
-    "schema_migrations",
-    "active_storage_blobs",
-    "active_storage_attachments",
-    "action_text_rich_texts",
-
     # Ignore all legacy tables.
     /^legacy_/
   ]
+  global :ignore_models, [
+    # Ignore all legacy models.
+    /^Legacy::/
+  ]
 end
 ```
 
@@ -256,7 +269,7 @@ Supported configuration options:
 
 - `enabled` - set to `false` to disable the detector altogether
 - `ignore_tables` - tables whose indexes should never be reported as extraneous.
-- `ignore_columns` - indexes that should never be reported as extraneous.
+- `ignore_indexes` - indexes that should never be reported as extraneous.
 
 ### Detecting Unindexed `deleted_at` Columns
 
@@ -358,9 +371,9 @@ Supported configuration options:
 
 ### Detecting Uniqueness Validations not Backed by an Index
 
-Model-level uniqueness validations and `has_one` associations should be backed
-by a database index in order to be robust. Otherwise you risk inserting
-duplicate values under a heavy load.
+Model-level uniqueness validations, `has_one` and `has_and_belongs_to_many`
+associations should be backed by a database index in order to be robust.
+Otherwise you risk inserting duplicate values under a heavy load.
 
 In order to detect such validations run:
 
@@ -382,12 +395,15 @@ Supported configuration options:
 - `ignore_models` - models whose uniqueness validators should not be checked.
 - `ignore_columns` - specific validators, written as Model(column1, ...), that
   should not be checked.
+- `ignore_join_tables` - join tables that should not be checked for existence
+  of unique indexes.
 
 ### Detecting Missing Non-`NULL` Constraints
 
 If there's an unconditional presence validation on a column then it should be
 marked as non-`NULL`-able at the database level or should have a `IS NOT NULL`
-constraint.
+constraint. Timestamp columns are also expected to be made `NOT NULL` as they're
+managed automatically by Active Record.
 
 In order to detect columns whose presence is required but that are marked
 `null: true` in the database run the following command:
@@ -417,7 +433,8 @@ Supported configuration options:
 ### Detecting Missing Presence Validations
 
 If a column is marked as `null: false` then it's likely it should have the
-corresponding presence validator.
+corresponding presence validator or an appropriately configured inclusion or
+exclusion validation.
 
 In order to detect models lacking these validations run:
 
@@ -442,6 +459,7 @@ Supported configuration options:
 - `ignore_models` - models whose underlying tables' columns should not be checked.
 - `ignore_attributes` - specific attributes, written as Model.attribute, that
   should not be checked.
+- `ignore_columns_with_default` - set to `true` to ignore columns with default values.
 
 ### Detecting Incorrect Presence Validations on Boolean Columns
 
@@ -602,6 +620,52 @@ Supported configuration options:
 - `ignore_columns` - foreign keys, written as table.column, that should not be
   checked.
 
+### Detecting Tables Without Primary Keys
+
+Tables should have primary keys. Otherwise, it becomes problematic to easily find a specific record,
+logical replication in PostgreSQL will be troublesome, because all the rows need to be unique
+in the table then etc.
+
+Running the command below will list all tables without primary keys:
+
+```
+bundle exec rake active_record_doctor:table_without_primary_key
+```
+
+The output of the command looks like this:
+
+```
+add a primary key to companies
+```
+
+Supported configuration options:
+
+- `enabled` - set to `false` to disable the detector altogether
+- `ignore_tables` - tables whose primary key existence should not be checked
+
+### Detecting Tables Without Timestamps
+
+Tables should have timestamp columns (`created_at`/`updated_at`). Otherwise, it becomes problematic
+to easily find when the record was created/updated, if the table is active or can be removed,
+automatic Rails cache expiration after record updates is not possible.
+
+Running the command below will list all tables without default timestamp columns:
+
+```
+bundle exec rake active_record_doctor:table_without_timestamps
+```
+
+The output of the command looks like this:
+
+```
+add a created_at column to companies
+```
+
+Supported configuration options:
+
+- `enabled` - set to `false` to disable the detector altogether
+- `ignore_tables` - tables whose timestamp columns existence should not be checked
+
 ## Ruby and Rails Compatibility Policy
 
 The goal of the policy is to ensure proper functioning in reasonable

data/lib/active_record_doctor/adapters/database.rb

@@ -0,0 +1,17 @@
+module ActiveRecordDoctor
+  module Adapters
+    class Database
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def tables
+        connection.tables
+      end
+
+      private
+
+      attr_reader :connection
+    end
+  end
+end

data/lib/active_record_doctor/adapters/table.rb

@@ -0,0 +1,18 @@
+module ActiveRecordDoctor
+  module Adapters
+    class Table
+      def initialize(connection, table_name)
+        @connection = connection
+        @table_name = table_name
+      end
+
+      def columns
+        connection.columns(table_name)
+      end
+
+      private
+
+      attr_reader :connection, :table_name
+    end
+  end
+end

data/lib/active_record_doctor/adapters/validators.rb

@@ -0,0 +1,16 @@
+module ActiveRecordDoctor
+  module Adapters
+    class Validators
+      def initialize(model_class, kind: :any)
+        @model_class = model_class
+      end
+
+      def each
+      end
+
+      private
+
+      attr_reader :model_class
+    end
+  end
+end

data/lib/active_record_doctor/config/default.rb

@@ -47,17 +47,27 @@ ActiveRecordDoctor.configure do
   detector :missing_presence_validation,
     enabled: true,
     ignore_models: [],
-    ignore_attributes: []
+    ignore_attributes: [],
+    ignore_columns_with_default: false
 
   detector :missing_unique_indexes,
     enabled: true,
     ignore_models: [],
-    ignore_columns: []
+    ignore_columns: [],
+    ignore_join_tables: []
 
   detector :short_primary_key_type,
     enabled: true,
     ignore_tables: []
 
+  detector :table_without_primary_key,
+    enabled: true,
+    ignore_tables: []
+
+  detector :table_without_timestamps,
+    enabled: true,
+    ignore_tables: []
+
   detector :undefined_table_references,
     enabled: true,
     ignore_models: []

data/lib/active_record_doctor/detectors/base.rb

@@ -136,8 +136,7 @@ module ActiveRecordDoctor
       end
 
       def check_constraints(table_name)
-        # ActiveRecord 6.1+
-        if connection.respond_to?(:supports_check_constraints?) && connection.supports_check_constraints?
+        if connection.supports_check_constraints?
           connection.check_constraints(table_name).select(&:validated?).map(&:expression)
         elsif Utils.postgresql?(connection)
           definitions =
@@ -157,7 +156,7 @@ module ActiveRecordDoctor
       end
 
       def models
-        ActiveRecord::Base.descendants
+        ActiveRecord::Base.descendants.sort_by(&:name)
       end
 
       def underscored_name
@@ -245,6 +244,13 @@ module ActiveRecordDoctor
         end
       end
 
+      def looks_like_foreign_key?(column)
+        type = column.type.to_s
+
+        column.name.end_with?("_id") &&
+          (type == "integer" || type.include?("uuid"))
+      end
+
       def each_foreign_key(table_name)
         log("Iterating over foreign keys on #{table_name}") do
           connection.foreign_keys(table_name).each do |foreign_key|
@@ -256,15 +262,8 @@ module ActiveRecordDoctor
       end
 
       def each_table(except: [])
-        tables =
-          if ActiveRecord::VERSION::STRING >= "5.1"
-            connection.tables
-          else
-            connection.data_sources
-          end
-
         log("Iterating over tables") do
-          tables.each do |table|
+          connection.tables.each do |table|
             case
             when ignored?(table, except)
               log("#{table} - ignored via the configuration; skipping")
@@ -323,7 +322,7 @@ module ActiveRecordDoctor
       end
 
       def ignored?(name, patterns)
-        patterns.any? { |pattern| pattern === name } # rubocop:disable Style/CaseEquality
+        patterns.any? { |pattern| pattern === name || name == pattern.to_s } # rubocop:disable Style/CaseEquality
       end
     end
   end

data/lib/active_record_doctor/detectors/extraneous_indexes.rb

@@ -81,11 +81,12 @@ module ActiveRecordDoctor
 
         case [index1.unique, index2.unique]
         when [true, true]
-          (index2_columns - index1_columns).empty?
+          contains_all?(index1_columns, index2_columns)
         when [true, false]
           false
         else
-          prefix?(index1_columns, index2_columns)
+          prefix?(index1_columns, index2_columns) &&
+            contains_all?(index2_columns + includes(index2), includes(index1))
         end
       end
 
@@ -96,6 +97,14 @@ module ActiveRecordDoctor
       def prefix?(lhs, rhs)
         lhs.count <= rhs.count && rhs[0...lhs.count] == lhs
       end
+
+      def contains_all?(array1, array2)
+        (array2 - array1).empty?
+      end
+
+      def includes(index)
+        index.respond_to?(:include) ? Array(index.include) : []
+      end
     end
   end
 end

data/lib/active_record_doctor/detectors/incorrect_dependent_option.rb

@@ -58,7 +58,7 @@ module ActiveRecordDoctor
             # 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?
+            if association.through_reflection? && association.source_reflection.nil?
               log("through association with nil source_reflection")
 
               through_association = model.reflect_on_association(association.options.fetch(:through))
@@ -77,14 +77,14 @@ module ActiveRecordDoctor
                   associated_models: [through_association.klass.name],
                   associated_models_type: "join"
                 )
-                next
               end
+              next
             end
 
             associated_models, associated_models_type =
               if association.polymorphic?
                 [models_having_association_with_options(as: association.name), nil]
-              elsif through?(association)
+              elsif association.through_reflection?
                 [[association.source_reflection.active_record], "join"]
               else
                 [[association.klass], nil]
@@ -159,10 +159,6 @@ 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

@@ -33,21 +33,23 @@ module ActiveRecordDoctor
       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
+            model_maximum = maximum_allowed_by_length_validation(model, column.name.to_sym)
+            database_maximum = column.limit
+            next if model_maximum == database_maximum
+            next if database_maximum && covered_by_inclusion_validation?(model, column.name.to_sym, database_maximum)
 
             problem!(
               model: model.name,
               attribute: column.name,
               table: model.table_name,
-              database_maximum: column.limit,
+              database_maximum: database_maximum,
               model_maximum: model_maximum
             )
           end
         end
       end
 
-      def maximum_allowed_by_validations(model, column)
+      def maximum_allowed_by_length_validation(model, column)
         length_validator = model.validators.find do |validator|
           validator.kind == :length &&
             validator.options.include?(:maximum) &&
@@ -55,6 +57,20 @@ module ActiveRecordDoctor
         end
         length_validator ? length_validator.options[:maximum] : nil
       end
+
+      def covered_by_inclusion_validation?(model, column, limit)
+        inclusion_validator = model.validators.find do |validator|
+          validator.kind == :inclusion &&
+            validator.attributes.include?(column) &&
+            [:if, :unless].none? { |option| validator.options.key?(option) } &&
+            [:allow_nil, :allow_blank].none? { |option| validator.options[option] == true }
+        end
+
+        return false if !inclusion_validator
+
+        values = inclusion_validator.options[:in] || inclusion_validator.options[:within]
+        values.is_a?(Array) && values.all? { |value| value.is_a?(String) && value.size <= limit }
+      end
     end
   end
 end

data/lib/active_record_doctor/detectors/missing_foreign_keys.rb

@@ -28,19 +28,16 @@ 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.
-            next unless named_like_foreign_key?(column)
+            next unless looks_like_foreign_key?(column)
             next if foreign_key?(table, column)
             next if polymorphic_foreign_key?(table, column)
+            next if model_destroyed_async?(table, column)
 
             problem!(table: table, column: column.name)
           end
         end
       end
 
-      def named_like_foreign_key?(column)
-        column.name.end_with?("_id")
-      end
-
       def foreign_key?(table, column)
         connection.foreign_keys(table).any? do |foreign_key|
           foreign_key.options[:column] == column.name
@@ -53,6 +50,18 @@ module ActiveRecordDoctor
           another_column.name == type_column_name
         end
       end
+
+      def model_destroyed_async?(table, column)
+        # Check if there are any models having `has_many ..., dependent: :destroy_async`
+        # referencing the specified table.
+        models.any? do |model|
+          model.reflect_on_all_associations(:has_many).any? do |reflection|
+            reflection.options[:dependent] == :destroy_async &&
+              reflection.foreign_key == column.name &&
+              reflection.klass.table_name == table
+          end
+        end
+      end
     end
   end
 end

data/lib/active_record_doctor/detectors/missing_non_null_constraint.rb

@@ -18,15 +18,27 @@ module ActiveRecordDoctor
 
       private
 
+      TIMESTAMPS = ["created_at", "created_on", "updated_at", "updated_on"].freeze
+
       def message(column:, table:)
-        "add `NOT NULL` to #{table}.#{column} - models validates its presence but it's not non-NULL in the database"
+        if TIMESTAMPS.include?(column)
+          <<~WARN.squish
+            add `NOT NULL` to #{table}.#{column} - timestamp columns are set
+            automatically by Active Record and allowing NULL may lead to
+            inconsistencies introduced by bulk operations
+          WARN
+        else
+          "add `NOT NULL` to #{table}.#{column} - models validates its presence but it's not non-NULL in the database"
+        end
       end
 
       def detect
         table_models = models.select(&:table_exists?).group_by(&:table_name)
+        views = connection.views
 
         table_models.each do |table, models|
           next if ignored?(table, config(:ignore_tables))
+          next if views.include?(table)
 
           concrete_models = models.reject do |model|
             model.abstract_class? || sti_base_model?(model)
@@ -36,6 +48,7 @@ module ActiveRecordDoctor
             next if ignored?("#{table}.#{column.name}", config(:ignore_columns))
             next if !column.null
             next if !concrete_models.all? { |model| non_null_needed?(model, column) }
+            next if sti_column?(models, column.name)
             next if not_null_check_constraint_exists?(table, column)
 
             problem!(column: column.name, table: table)
@@ -49,6 +62,8 @@ module ActiveRecordDoctor
       end
 
       def non_null_needed?(model, column)
+        return true if TIMESTAMPS.include?(column.name)
+
         belongs_to = model.reflect_on_all_associations(:belongs_to).find do |reflection|
           reflection.foreign_key == column.name ||
             (reflection.polymorphic? && reflection.foreign_type == column.name)
@@ -66,10 +81,29 @@ module ActiveRecordDoctor
         model.validators.select do |validator|
           validator.is_a?(ActiveRecord::Validations::PresenceValidator) &&
             !validator.options[:allow_nil] &&
-            !validator.options[:if] &&
-            !validator.options[:unless]
+            validator.options[:on].blank? &&
+            (rails_belongs_to_presence_validator?(validator) || !conditional_validator?(validator))
         end
       end
+
+      def sti_column?(models, column_name)
+        models.any? { |model| model.inheritance_column == column_name }
+      end
+
+      def rails_belongs_to_presence_validator?(validator)
+        ActiveRecord.version >= Gem::Version.new("7.1") &&
+          !ActiveRecord.belongs_to_required_validates_foreign_key &&
+          validator.options[:message] == :required &&
+          proc_from_activerecord?(validator.options[:if])
+      end
+
+      def conditional_validator?(validator)
+        validator.options[:if] || validator.options[:unless]
+      end
+
+      def proc_from_activerecord?(object)
+        object.is_a?(Proc) && object.binding.receiver.name.start_with?("ActiveRecord::")
+      end
     end
   end
 end

data/lib/active_record_doctor/detectors/missing_presence_validation.rb

@@ -13,79 +13,170 @@ module ActiveRecordDoctor
         },
         ignore_attributes: {
           description: "specific attributes, written as Model.attribute, that should not be checked"
+        },
+        ignore_columns_with_default: {
+          description: "ignore columns with default values, should be provided as boolean"
         }
       }
 
       private
 
-      def message(column:, model:)
-        "add a `presence` validator to #{model}.#{column} - it's NOT NULL but lacks a validator"
+      def message(type:, column_or_association:, model:)
+        case type
+        when :missing_validator
+          "add a `presence` validator to #{model}.#{column_or_association} - it's NOT NULL but lacks a validator"
+        when :optional_association
+          "add `optional: false` to #{model}.#{column_or_association} - the foreign key #{column_or_association}_id is NOT NULL" # rubocop:disable Layout/LineLength
+        when :optional_polymorphic_association
+          "add `optional: false` to #{model}.#{column_or_association} - the foreign key #{column_or_association}_id or type #{column_or_association}_type are NOT NULL" # rubocop:disable Layout/LineLength
+        end
       end
 
       def detect
         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)
+          # List all columns and then remove those that don't need or don't have
+          # a missing validator.
+          problematic_columns = connection.columns(model.table_name)
+          problematic_columns.reject! do |column|
+            # The primary key, timestamps, and counter caches are special
+            # columns that are automatically managed by Rails and don't need
+            # an explicit presence validator.
+            column.name == model.primary_key ||
+              ["created_at", "updated_at", "created_on", "updated_on"].include?(column.name) ||
+              counter_cache_column?(model, column) ||
+
+              # NULL-able columns don't need a presence validator as they can be
+              # set to NULL after all. A check constraint (column IS NOT NULL)
+              # is an alternative approach and the absence of such constraint is
+              # tested below.
+              (column.null && !not_null_check_constraint_exists?(model.table_name, column)) ||
+
+              # If requested, columns with a default value don't need presence
+              # validation as they'd have the default value substituted automatically.
+              (config(:ignore_columns_with_default) && (column.default || column.default_function)) ||
+
+              # Explicitly ignored columns should be skipped.
+              config(:ignore_attributes).include?("#{model.name}.#{column.name}")
+          end
 
-            problem!(column: column.name, model: model.name)
+          # At this point the only columns that are left are those that DO
+          # need presence validation in the model. Let's iterate over all
+          # validators to see which columns are actually validated, but before
+          # we do that let's define a map for quickly translating foreign key
+          # names to belongs_to association names.
+          column_name_to_association_name = {}
+          model.reflect_on_all_associations(:belongs_to).each do |reflection|
+            column_name_to_association_name[reflection.foreign_key] = reflection.name
+            if reflection.polymorphic?
+              column_name_to_association_name[reflection.foreign_type] = reflection.name
+            end
           end
-        end
-      end
 
-      def validator_needed?(model, column)
-        ![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
+          # We're now ready to iterate over the validators and remove columns
+          # that are validated directly or via an association name.
+          model.validators.each do |validator|
+            problematic_columns.reject! do |column|
+              # Translate a foreign key or type to the association name.
+              attribute = column_name_to_association_name[column.name] || column.name.to_sym
+
+              case validator
+
+              # A regular presence validator is enough if the column name is
+              # listed among the attributes it's validating.
+              when ActiveRecord::Validations::PresenceValidator
+                validator.attributes.include?(attribute)
+
+              # An inclusion validator ensures the column is not nil if it covers
+              # the column and nil is NOT one of the values it allows.
+              when ActiveModel::Validations::InclusionValidator
+                validator_items = inclusion_or_exclusion_validator_items(validator)
+                validator.attributes.include?(attribute) &&
+                  (validator_items.is_a?(Proc) || validator_items.exclude?(nil))
+
+              # An exclusion validator ensures the column is not nil if it covers
+              # the column and excludes nil as an allowed value explicitly.
+              when ActiveModel::Validations::ExclusionValidator
+                validator_items = inclusion_or_exclusion_validator_items(validator)
+                validator.attributes.include?(attribute) &&
+                  (validator_items.is_a?(Proc) || validator_items.include?(nil))
+
+              end
+            end
+          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
+          # Associations need to be checked whether they're marked optional
+          # while the underlying foreign key or type columns are marked NOT NULL.
+          problematic_associations = []
+          problematic_polymorphic_associations = []
+
+          model.reflect_on_all_associations.each do |reflection|
+            foreign_key_column = problematic_columns.find { |column| column.name == reflection.foreign_key }
+            if reflection.polymorphic?
+              # If the foreign key and type are not one of the columns that lack
+              # a validator then it means the association added a validator and
+              # is configured correctly.
+              foreign_type_column = problematic_columns.find { |column| column.name == reflection.foreign_type }
+              next if foreign_key_column.nil? && foreign_type_column.nil?
+
+              # Otherwise, don't report errors about missing validators on the
+              # foreign key or type, but instead ...
+              problematic_columns.delete(foreign_key_column)
+              problematic_columns.delete(foreign_type_column)
+
+              # ... report an error about an incorrectly configured polymorphic
+              # association.
+              problematic_polymorphic_associations << reflection.name
+            else
+              # If the foreign key is not one of the columns that lack a
+              # validator then it means the association added a validator and is
+              # configured correctly.
+              next if foreign_key_column.nil?
+
+              # Otherwise, don't report an error about a missing validator on
+              # the foreign key, but instead ...
+              problematic_columns.delete(foreign_key_column)
+
+              # ... report an error about an incorrectly configured association.
+              problematic_associations << reflection.name
+            end
+          end
 
-      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)
+          # Finally, regular and polymorphic associations that are explicitly
+          # ignored should be removed from the output. It's NOT enough to skip
+          # processing them in the loop above because their underlying foreign
+          # key and type columns must be removed from output, too.
+          problematic_associations.reject! do |name|
+            config(:ignore_attributes).include?("#{model.name}.#{name}")
+          end
+          problematic_polymorphic_associations.reject! do |name|
+            config(:ignore_attributes).include?("#{model.name}.#{name}")
+          end
 
-          validator.is_a?(ActiveModel::Validations::InclusionValidator) &&
-            validator.attributes.include?(column.name.to_sym) &&
-            !validator_items.include?(nil)
+          # Job is done and all accumulated errors can be reported.
+          problematic_polymorphic_associations.each do |name|
+            problem!(type: :optional_polymorphic_association, column_or_association: name, model: model.name)
+          end
+          problematic_associations.each do |name|
+            problem!(type: :optional_association, column_or_association: name, model: model.name)
+          end
+          problematic_columns.each do |column|
+            problem!(type: :missing_validator, column_or_association: column.name, model: model.name)
+          end
         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_items.include?(nil)
-        end
+      # Normalizes the list of values passed to an inclusion or exclusion validator.
+      def inclusion_or_exclusion_validator_items(validator)
+        validator.options[:in] || validator.options[:within] || []
       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?
+      # Determines whether the given column is used as a counter cache column by
+      # a has_many association on the model.
+      def counter_cache_column?(model, column)
+        model.reflect_on_all_associations(:has_many).any? do |reflection|
+          reflection.has_cached_counter? && reflection.counter_cache_column == column.name
         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

@@ -13,9 +13,17 @@ module ActiveRecordDoctor
         },
         ignore_columns: {
           description: "specific validators, written as Model(column1, column2, ...), that should not be checked"
+        },
+        ignore_join_tables: {
+          description: "join tables that should not be checked for existence of unique indexes"
         }
       }
 
+      def initialize(**)
+        super
+        @reported_join_tables = []
+      end
+
       private
 
       # rubocop:disable Layout/LineLength
@@ -28,6 +36,8 @@ module ActiveRecordDoctor
           "without an expression index can lead to duplicates (a regular unique index is not enough)"
         when :has_ones
           "add a unique index on #{table}(#{columns.join(', ')}) - using `has_one` in #{model.name} without an index can lead to duplicates"
+        when :has_and_belongs_to_many
+          "add a unique index on #{table}(#{columns.join(', ')}) - using `has_and_belongs_to_many` in #{model.name} without an index can lead to duplicates"
         end
       end
       # rubocop:enable Layout/LineLength
@@ -35,6 +45,7 @@ module ActiveRecordDoctor
       def detect
         validations_without_indexes
         has_ones_without_indexes
+        has_and_belongs_to_many_without_indexes
       end
 
       def validations_without_indexes
@@ -54,17 +65,19 @@ module ActiveRecordDoctor
             # put true literally.
             case_sensitive = validator.options.fetch(:case_sensitive, true)
 
-            # ActiveRecord < 5.0 does not support expression indexes,
-            # so this will always be a false positive.
-            next if !case_sensitive && Utils.expression_indexes_unsupported?
+            # Avoid a false positive if expression indexes are unsupported.
+            next if !case_sensitive && !connection.supports_expression_index?
 
             validator.attributes.each do |attribute|
               columns = resolve_attributes(model, scope + [attribute])
 
               next if ignore_columns.include?("#{model.name}(#{columns.join(',')})")
 
-              columns[-1] = "lower(#{columns[-1]})" unless case_sensitive
-
+              # citext is case-insensitive by default, so it doesn't have to be
+              # lowered.
+              if !case_sensitive && model.columns_hash[columns[-1]].type != :citext
+                columns[-1] = "lower(#{columns[-1]})"
+              end
               next if unique_index?(model.table_name, columns)
 
               if case_sensitive
@@ -108,6 +121,21 @@ module ActiveRecordDoctor
         (validator.options.keys & [:if, :unless, :conditions]).present?
       end
 
+      def has_and_belongs_to_many_without_indexes # rubocop:disable Naming/PredicateName
+        each_model do |model|
+          each_association(model, type: :has_and_belongs_to_many, has_scope: false) do |association|
+            join_table = association.join_table
+            next if @reported_join_tables.include?(join_table) || config(:ignore_join_tables).include?(join_table)
+
+            columns = [association.foreign_key, association.association_foreign_key]
+            next if unique_index?(join_table, columns)
+
+            @reported_join_tables << join_table
+            problem!(model: model, table: join_table, columns: columns, problem: :has_and_belongs_to_many)
+          end
+        end
+      end
+
       def resolve_attributes(model, attributes)
         attributes.flat_map do |attribute|
           reflection = model.reflect_on_association(attribute)

data/lib/active_record_doctor/detectors/short_primary_key_type.rb

@@ -20,6 +20,8 @@ module ActiveRecordDoctor
       end
 
       def detect
+        return if ActiveRecordDoctor::Utils.sqlite?
+
         each_table(except: config(:ignore_tables)) do |table|
           column = primary_key(table)
           next if column.nil?

data/lib/active_record_doctor/detectors/table_without_primary_key.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    class TableWithoutPrimaryKey < Base # :nodoc:
+      @description = "detect tables without primary keys"
+      @config = {
+        ignore_tables: {
+          description: "tables whose primary key existence should not be checked",
+          global: true
+        }
+      }
+
+      private
+
+      def message(table:)
+        "add a primary key to #{table}"
+      end
+
+      def detect
+        each_table(except: config(:ignore_tables)) do |table|
+          column = primary_key(table)
+          problem!(table: table) unless column
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/detectors/table_without_timestamps.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    class TableWithoutTimestamps < Base # :nodoc:
+      @description = "detect tables without created_at/updated_at columns"
+      @config = {
+        ignore_tables: {
+          description: "tables whose timestamp columns existence should not be checked",
+          global: true
+        }
+      }
+
+      private
+
+      TIMESTAMPS = {
+        "created_at" => "created_on",
+        "updated_at" => "updated_on"
+      }.freeze
+
+      def message(table:, column:)
+        "add a #{column} column to #{table}"
+      end
+
+      def detect
+        each_table(except: config(:ignore_tables)) do |table|
+          TIMESTAMPS.each do |column, alternative_column|
+            unless column(table, column) || column(table, alternative_column)
+              problem!(table: table, column: column)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/detectors/unindexed_foreign_keys.rb

@@ -27,7 +27,7 @@ module ActiveRecordDoctor
       def detect
         each_table(except: config(:ignore_tables)) do |table|
           each_column(table, except: config(:ignore_columns)) do |column|
-            next unless named_like_foreign_key?(column) || foreign_key?(table, column)
+            next unless looks_like_foreign_key?(column) || foreign_key?(table, column)
             next if indexed?(table, column)
             next if indexed_as_polymorphic?(table, column)
             next if connection.primary_key(table) == column.name
@@ -46,10 +46,6 @@ module ActiveRecordDoctor
         end
       end
 
-      def named_like_foreign_key?(column)
-        column.name.end_with?("_id")
-      end
-
       def foreign_key?(table, column)
         connection.foreign_keys(table).any? do |foreign_key|
           foreign_key.column == column.name

data/lib/active_record_doctor/runner.rb

@@ -27,7 +27,7 @@ module ActiveRecordDoctor # :nodoc:
       # We can't use #all? because of its short-circuit behavior - it stops
       # iteration and returns false upon the first falsey value. This
       # prevents other detectors from running if there's a failure.
-      ActiveRecordDoctor.detectors.each do |name, _|
+      ActiveRecordDoctor.detectors.each_key do |name|
         success = false if !run_one(name)
       end
 

data/lib/active_record_doctor/utils.rb

@@ -11,10 +11,8 @@ module ActiveRecordDoctor
         connection.adapter_name == "Mysql2"
       end
 
-      def expression_indexes_unsupported?(connection = ActiveRecord::Base.connection)
-        (ActiveRecord::VERSION::STRING < "5.0") ||
-          # Active Record is unable to correctly parse expression indexes for MySQL.
-          (mysql?(connection) && ActiveRecord::VERSION::STRING < "7.1")
+      def sqlite?(connection = ActiveRecord::Base.connection)
+        connection.adapter_name == "SQLite"
       end
     end
   end

data/lib/active_record_doctor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordDoctor
-  VERSION = "1.14.0"
+  VERSION = "2.0.0"
 end

data/lib/active_record_doctor.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "active_record_doctor/railtie" if defined?(Rails) && defined?(Rails::Railtie)
+require "active_record_doctor/railtie" if defined?(Rails::Railtie)
 require "active_record_doctor/utils"
 require "active_record_doctor/logger"
 require "active_record_doctor/logger/dummy"
@@ -20,6 +20,8 @@ require "active_record_doctor/detectors/unindexed_foreign_keys"
 require "active_record_doctor/detectors/incorrect_dependent_option"
 require "active_record_doctor/detectors/short_primary_key_type"
 require "active_record_doctor/detectors/mismatched_foreign_key_type"
+require "active_record_doctor/detectors/table_without_primary_key"
+require "active_record_doctor/detectors/table_without_timestamps"
 require "active_record_doctor/errors"
 require "active_record_doctor/help"
 require "active_record_doctor/runner"

data/lib/generators/active_record_doctor/add_indexes/add_indexes_generator.rb

@@ -47,7 +47,7 @@ module ActiveRecordDoctor
       # rubocop rule below.
 
       <<MIGRATION
-class IndexForeignKeysIn#{table.camelize} < ActiveRecord::Migration#{migration_version}
+class IndexForeignKeysIn#{table.camelize} < ActiveRecord::Migration[#{ActiveRecord::Migration.current_version}]
   def change
 #{add_indexes(table, indexes)}
   end
@@ -71,13 +71,5 @@ MIGRATION
         "    add_index :#{table}, #{columns.inspect}"
       end
     end
-
-    def migration_version
-      if ActiveRecord::VERSION::STRING >= "5.1"
-        "[#{ActiveRecord::Migration.current_version}]"
-      else
-        ""
-      end
-    end
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: active_record_doctor
 version: !ruby/object:Gem::Version
-  version: 1.14.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Greg Navis
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-08 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: minitest-fork_executor
   requirement: !ruby/object:Gem::Requirement
@@ -44,85 +43,98 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.3
+        version: 0.5.6
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.3
+        version: 0.5.6
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.4
+        version: 1.5.9
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.4
+        version: 1.5.9
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: 7.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 12.3.3
+        version: 13.2.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 12.3.3
+        version: 13.2.1
 - !ruby/object:Gem::Dependency
-  name: transient_record
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0.rc2
+        version: 1.68.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0.rc2
+        version: 1.68.0
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: transient_record
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.57.1
+        version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.57.1
-description:
+        version: 3.0.0
 email:
 - contact@gregnavis.com
 executables: []
@@ -132,6 +144,9 @@ files:
 - MIT-LICENSE.txt
 - README.md
 - lib/active_record_doctor.rb
+- lib/active_record_doctor/adapters/database.rb
+- lib/active_record_doctor/adapters/table.rb
+- lib/active_record_doctor/adapters/validators.rb
 - lib/active_record_doctor/config.rb
 - lib/active_record_doctor/config/default.rb
 - lib/active_record_doctor/config/loader.rb
@@ -147,6 +162,8 @@ files:
 - lib/active_record_doctor/detectors/missing_presence_validation.rb
 - lib/active_record_doctor/detectors/missing_unique_indexes.rb
 - lib/active_record_doctor/detectors/short_primary_key_type.rb
+- lib/active_record_doctor/detectors/table_without_primary_key.rb
+- lib/active_record_doctor/detectors/table_without_timestamps.rb
 - lib/active_record_doctor/detectors/undefined_table_references.rb
 - lib/active_record_doctor/detectors/unindexed_deleted_at.rb
 - lib/active_record_doctor/detectors/unindexed_foreign_keys.rb
@@ -169,7 +186,6 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -177,15 +193,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Identify database issues before they hit production.
 test_files: []