active_record_doctor 1.15.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de87f340b23468b20a336608acbb3adc75a1505845e9f03c03722199896a2582
-  data.tar.gz: b98205be522fc4a97d21d835fcf81d285209cdbb07b5ac8072d7c912cb544eb0
+  metadata.gz: 94e700a1c78ee5e9657d1107578c2932a84acba7f592ab6a416e5c063520a311
+  data.tar.gz: 8496adb8a597250ec95276fc9fbad50397667f7de2336f80405203b3a3c2a459
 SHA512:
-  metadata.gz: 492104d7e80292d96b91760e453c27aeff140b83eff8f78092a90a34c83dc1e7f1b0defe5d47fa15408c08eeb48c7c0ee61280108dd2f31f3eeba4712f3093d2
-  data.tar.gz: 2be286fd10dbbbf6b54eebe96ea44618e48906d6875fdfce0e2f1ae3ac5420b0ec95e7c1c25c378f26ba3ffb3c2a40267c4fa3daf14643410ea78e90484b5b91
+  metadata.gz: 79803ef2db49147fdf2daf5983a3f36fb895704d150347442bebdc192a6980ecb8cd438c23fe335941284e0a39aee8c3e1a725bfe3845c7a0d3dde03830068dc
+  data.tar.gz: 2feb5b594c369dc3d39e0f85540724474e5caa7573e0d0f18a5dcddd63d12113ec4c670ef374b475f237bd3d75fe7281bca0b0d219aac6582cbddbe59bdc2340

data/README.md

@@ -16,6 +16,7 @@ can detect:
 * 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:
 
@@ -160,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
 ```
 
@@ -270,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
 
@@ -303,16 +302,15 @@ Supported configuration options:
 
 ### Detecting Missing Foreign Key Constraints
 
-If `users.profile_id` references a row in `profiles` then this can be expressed
-at the database level with a foreign key constraint. It _forces_
-`users.profile_id` to point to an existing row in `profiles`. The problem is
-that in many legacy Rails apps, the constraint isn't enforced at the database
-level.
+If `User` defines a `belongs_to` association to `Profile` then the underlying
+column (`users.profile_id` by convention) should be marked as a foreign key in
+the database. If it's not then it's possible to end up in a situation where a
+user is referencing a non-existent profile.
 
 `active_record_doctor` can automatically detect foreign keys that could benefit
 from a foreign key constraint (a future version will generate a migration that
-add the constraint; for now, it's your job). You can obtain the list of foreign
-keys with the following command:
+add the constraint; for now, it's your job). You can obtain the list of missing
+foreign key constraints with the following command:
 
 ```bash
 bundle exec rake active_record_doctor:missing_foreign_keys
@@ -332,9 +330,9 @@ end
 Supported configuration options:
 
 - `enabled` - set to `false` to disable the detector altogether
-- `ignore_tables` - tables whose columns should not be checked.
-- `ignore_columns` - columns, written as table.column, that should not be
-  checked.
+- `ignore_models` - models whose associations should not be checked.
+- `ignore_associations` - associations, written as Model.association, that
+  should not be checked.
 
 ### Detecting Models Referencing Undefined Tables
 
@@ -403,7 +401,8 @@ Supported configuration options:
 
 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:
@@ -433,7 +432,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:
 
@@ -640,7 +640,30 @@ add a primary key to companies
 Supported configuration options:
 
 - `enabled` - set to `false` to disable the detector altogether
-- `ignore_tables` - tables whose primary key existense should not be checked
+- `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
 

data/lib/active_record_doctor/config/default.rb

@@ -36,8 +36,8 @@ ActiveRecordDoctor.configure do
 
   detector :missing_foreign_keys,
     enabled: true,
-    ignore_tables: [],
-    ignore_columns: []
+    ignore_models: [],
+    ignore_associations: []
 
   detector :missing_non_null_constraint,
     enabled: true,
@@ -64,6 +64,10 @@ ActiveRecordDoctor.configure do
     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 =
@@ -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")

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

@@ -7,12 +7,12 @@ module ActiveRecordDoctor
     class MissingForeignKeys < Base # :nodoc:
       @description = "detect foreign-key-like columns lacking an actual foreign key constraint"
       @config = {
-        ignore_tables: {
-          description: "tables whose columns should not be checked",
+        ignore_models: {
+          description: "models whose columns should not be checked",
           global: true
         },
-        ignore_columns: {
-          description: "columns, written as table.column, that should not be checked"
+        ignore_associations: {
+          description: "associations, written as Model.association, that should not be checked"
         }
       }
 
@@ -23,34 +23,19 @@ module ActiveRecordDoctor
       end
 
       def detect
-        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.
-            next unless named_like_foreign_key?(column)
-            next if foreign_key?(table, column)
-            next if polymorphic_foreign_key?(table, column)
-
-            problem!(table: table, column: column.name)
-          end
-        end
-      end
+        each_model(except: config(:ignore_models), existing_tables_only: true) do |model|
+          foreign_keys = connection.foreign_keys(model.table_name)
+          foreign_key_columns = foreign_keys.map { |key| key.options[:column] }
 
-      def named_like_foreign_key?(column)
-        column.name.end_with?("_id")
-      end
+          each_association(model, type: :belongs_to) do |association|
+            next if ignored?("#{model.name}.#{association.name}", config(:ignore_associations))
+            next if association.options[:polymorphic]
 
-      def foreign_key?(table, column)
-        connection.foreign_keys(table).any? do |foreign_key|
-          foreign_key.options[:column] == column.name
-        end
-      end
+            has_foreign_key = foreign_key_columns.include?(association.foreign_key)
+            next if has_foreign_key
 
-      def polymorphic_foreign_key?(table, column)
-        type_column_name = column.name.sub(/_id\Z/, "_type")
-        connection.columns(table).any? do |another_column|
-          another_column.name == type_column_name
+            problem!(table: model.table_name, column: association.foreign_key)
+          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)
@@ -50,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)
@@ -67,6 +81,7 @@ module ActiveRecordDoctor
         model.validators.select do |validator|
           validator.is_a?(ActiveRecord::Validations::PresenceValidator) &&
             !validator.options[:allow_nil] &&
+            validator.options[:on].blank? &&
             (rails_belongs_to_presence_validator?(validator) || !conditional_validator?(validator))
         end
       end

data/lib/active_record_doctor/detectors/missing_presence_validation.rb

@@ -21,79 +21,164 @@ module ActiveRecordDoctor
 
       private
 
-      def message(column:, model:)
-        "add a `presence` validator to #{model}.#{column} - it's NOT NULL but lacks a validator"
+      def message(type:, column:, reflection:, model:)
+        case type
+        when :missing_validator
+          "add a `presence` validator to #{model}.#{column} - it's NOT NULL but lacks a validator"
+        when :optional_association
+          "add `optional: false` to #{model}.#{reflection.name} - the foreign key #{reflection.foreign_key} is NOT NULL"
+        when :optional_polymorphic_association
+          "add `optional: false` to #{model}.#{reflection.name} - the foreign key #{reflection.foreign_key} or type #{reflection.foreign_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)
-
-            problem!(column: column.name, model: model.name)
+          # 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.
+              ignored?("#{model.name}.#{column.name}", config(:ignore_attributes))
           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)) &&
-          !default_value_instead_of_validation?(column)
-      end
+          # 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
 
-      def default_value_instead_of_validation?(column)
-        !column.default.nil? && config(:ignore_columns_with_default)
-      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|
+              attribute_names = [
+                column.name.to_sym,
+                column_name_to_association_name[column.name]
+              ].compact
+
+              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 & attribute_names).present?
+
+              # 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 & attribute_names).present? &&
+                  (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 & attribute_names).present? &&
+                  (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(:belongs_to).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
+            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
+            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 |reflection|
+            config(:ignore_attributes).include?("#{model.name}.#{reflection.name}")
+          end
+          problematic_polymorphic_associations.reject! do |reflection|
+            config(:ignore_attributes).include?("#{model.name}.#{reflection.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 |reflection|
+            problem!(type: :optional_polymorphic_association, column: nil, reflection: reflection, model: model.name)
+          end
+          problematic_associations.each do |reflection|
+            problem!(type: :optional_association, column: nil, reflection: reflection, model: model.name)
+          end
+          problematic_columns.each do |column|
+            problem!(type: :missing_validator, column: column.name, reflection: nil, 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

@@ -65,9 +65,8 @@ 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])

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

@@ -8,7 +8,7 @@ module ActiveRecordDoctor
       @description = "detect tables without primary keys"
       @config = {
         ignore_tables: {
-          description: "tables whose primary key existense should not be checked",
+          description: "tables whose primary key existence should not be checked",
           global: true
         }
       }

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.15.0"
+  VERSION = "2.0.1"
 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"
@@ -21,6 +21,7 @@ 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.15.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Greg Navis
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-28 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.5.6
+        version: 1.5.9
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.5.6
+        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
+        version: 1.68.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        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: []
@@ -148,6 +160,7 @@ files:
 - 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
@@ -170,7 +183,6 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -178,15 +190,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.5.11
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Identify database issues before they hit production.
 test_files: []