active_record_doctor 1.11.0 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fef82b1493488683e11bc72273e142479cb47234651a8aa772a83121960f9309
-  data.tar.gz: c99afc25d8307ff0814e0459790f3d7fcf0b015d9f37f118870a9a1cfa2cf460
+  metadata.gz: cc970595479a84692995f75b3e512f1b1a01dc6fc61eee9a738abbd402ac9e44
+  data.tar.gz: 3bd5807bc126459379478c24d14a5595a2ee207415cb71c86c82ebdfae5f19f3
 SHA512:
-  metadata.gz: ab75ff192c31cfc10cbd5c4106ca0033cc4d408c1e4977a417f76c53f2a2e73e37e5706162cd4807c700808e171756ddda022af6658b60f460d78109f9bea2ee
-  data.tar.gz: 075625a08ac5f192a68ed6c99409a4acf85cadb77ec117d6933186c2bf4d07e5aaf08928e9f30d5dd96b263e8e530a4a4da848ef5a4dfc82d5dae0df2475f7d2
+  metadata.gz: 4b0ac66a6f9037ce810ff73660735b816bc58d614dd7612b7c7849292741519cbecd6bdb7105c7392e01fc1621ce550e1b8ba0726573beca33ee6e10ec6e35da
+  data.tar.gz: c3d2d7b0448ccff98001c72fa6330b54f45364a43e3eff35ff7407d0e2aeaaf8c3070a3ce308992577fa41adf7cdde3a8ba2aa93db4c8955fd69e5ec7f29d03b

data/README.md

@@ -7,7 +7,7 @@ can detect:
 * unindexed `deleted_at` columns - [`active_record_doctor:unindexed_deleted_at`](#detecting-unindexed-deleted_at-columns)
 * missing foreign key constraints - [`active_record_doctor:missing_foreign_keys`](#detecting-missing-foreign-key-constraints)
 * models referencing undefined tables - [`active_record_doctor:undefined_table_references`](#detecting-models-referencing-undefined-tables)
-* uniqueness validations not backed by an unique index - [`active_record_doctor:missing_unique_indexes`](#detecting-uniqueness-validations-not-backed-by-an-index)
+* uniqueness validations not backed by a unique index - [`active_record_doctor:missing_unique_indexes`](#detecting-uniqueness-validations-not-backed-by-an-index)
 * missing non-`NULL` constraints - [`active_record_doctor:missing_non_null_constraint`](#detecting-missing-non-null-constraints)
 * missing presence validations - [`active_record_doctor:missing_presence_validation`](#detecting-missing-presence-validations)
 * incorrect presence validations on boolean columns - [`active_record_doctor:incorrect_boolean_presence_validation`](#detecting-incorrect-presence-validations-on-boolean-columns)
@@ -144,6 +144,33 @@ as extraneous.
 Configuration options for each detector are listed below. They can also be
 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:
+
+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:
+
+```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_/
+  ]
+end
+```
+
 ### Indexing Unindexed Foreign Keys
 
 Foreign keys should be indexed unless it's proven ineffective. However, Rails
@@ -158,7 +185,7 @@ three-step process:
   ```
 
 2. Remove columns that should _not_ be indexed from `unindexed_foreign_keys.txt`
-   as a column can look like a foreign key (i.e. end with `_id`) without being
+   as a column can look like a foreign key (i.e. ending with `_id`) without being
    one.
 
 3. Generate the migrations
@@ -209,7 +236,7 @@ To discover such indexes automatically just follow these steps:
 
 3. Create a migration to drop the indexes.
 
-The indexes aren't dropped automatically because there's usually just a few of
+The indexes aren't dropped automatically because there are usually just a few of
 them and it's a good idea to double-check that you won't drop something
 necessary.
 
@@ -265,11 +292,11 @@ Supported configuration options:
 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
+that in many legacy Rails apps, the constraint isn't enforced at the database
 level.
 
 `active_record_doctor` can automatically detect foreign keys that could benefit
-from a foreign key constraint (a future version will generate a migrations that
+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:
 
@@ -307,7 +334,7 @@ before they hit production.
 * Rails 5+ and _any_ database or
 * Rails 4.2 with PostgreSQL.
 
-The only think you need to do is run:
+The only thing you need to do is run:
 
 ```
 bundle exec rake active_record_doctor:undefined_table_references
@@ -320,7 +347,7 @@ this:
 Contract references a non-existent table or view named contract_records
 ```
 
-On top of that `rake` will exit with status code of 1. This allows you to use
+On top of that `rake` will exit with a status code of 1. This allows you to use
 this check as part of your Continuous Integration pipeline.
 
 Supported configuration options:
@@ -333,7 +360,7 @@ Supported configuration options:
 
 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 heavy load.
+duplicate values under a heavy load.
 
 In order to detect such validations run:
 
@@ -475,7 +502,7 @@ Supported configuration options:
 
 - `enabled` - set to `false` to disable the detector altogether
 - `ignore_models` - models whose validators should not be checked.
-- `ignore_columns` - attributes, written as Model.attribute, whose validators
+- `ignore_attributes` - attributes, written as Model.attribute, whose validators
   should not be checked.
 
 ### Detecting Incorrect `dependent` Option on Associations
@@ -489,7 +516,7 @@ 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
+  will be loaded one by one with no reason
 
 In order to detect associations affected by the two aforementioned problems run
 the following command:
@@ -530,8 +557,8 @@ The output of the command looks like this:
 change the type of companies.id to bigint
 ```
 
-The above means `comanies.id` should be migrated to a wider integer type. An
-example migration to accomplish this looks likes this:
+The above means `companies.id` should be migrated to a wider integer type. An
+example migration to accomplish this looks like this:
 
 ```ruby
 class ChangeCompaniesPrimaryKeyType < ActiveRecord::Migration[5.1]
@@ -565,7 +592,7 @@ bundle exec rake active_record_doctor:mismatched_foreign_key_type
 The output of the command looks like this:
 
 ```
-companies.user_id references a column of different type - foreign keys should be of the same type as the referenced column
+companies.user_id references a column of a different type - foreign keys should be of the same type as the referenced column
 ```
 
 Supported configuration options:
@@ -584,7 +611,7 @@ combinations of Ruby and Rails versions. Specifically:
    supported by `active_record_doctor`.
 2. If a Ruby version is compatible with a supported Rails version then it's
    also supported by `active_record_doctor`.
-3. Only most recent teeny Ruby versions and patch Rails versions are supported.
+3. Only the most recent teeny Ruby versions and patch Rails versions are supported.
 
 ## Author
 

data/lib/active_record_doctor/config/loader.rb

@@ -27,7 +27,7 @@ module ActiveRecordDoctor # :nodoc:
       end
 
       # The same global can be used by multiple detectors so we must remove
-      # duplicates to ensure they aren't reported mutliple times via the user
+      # duplicates to ensure they aren't reported multiple times via the user
       # interface (e.g. in error messages).
       recognized_globals.uniq!
 

data/lib/active_record_doctor/detectors/base.rb

@@ -139,7 +139,7 @@ module ActiveRecordDoctor
         # ActiveRecord 6.1+
         if connection.respond_to?(:supports_check_constraints?) && connection.supports_check_constraints?
           connection.check_constraints(table_name).select(&:validated?).map(&:expression)
-        elsif postgresql?
+        elsif Utils.postgresql?(connection)
           definitions =
             connection.select_values(<<-SQL)
               SELECT pg_get_constraintdef(oid, true)
@@ -164,17 +164,13 @@ module ActiveRecordDoctor
         self.class.underscored_name
       end
 
-      def postgresql?
-        ["PostgreSQL", "PostGIS"].include?(connection.adapter_name)
-      end
-
       def each_model(except: [], abstract: nil, existing_tables_only: false)
         log("Iterating over Active Record models") do
           models.each do |model|
             case
             when model.name.start_with?("HABTM_")
               log("#{model.name} - has-belongs-to-many model; skipping")
-            when except.include?(model.name)
+            when ignored?(model.name, except)
               log("#{model.name} - ignored via the configuration; skipping")
             when abstract && !model.abstract_class?
               log("#{model.name} - non-abstract model; skipping")
@@ -204,7 +200,7 @@ module ActiveRecordDoctor
         log(message) do
           indexes.each do |index|
             case
-            when except.include?(index.name)
+            when ignored?(index.name, except)
               log("#{index.name} - ignored via the configuration; skipping")
             when multicolumn_only && !index.columns.is_a?(Array)
               log("#{index.name} - single-column index; skipping")
@@ -221,7 +217,7 @@ module ActiveRecordDoctor
         log("Iterating over attributes of #{model.name}") do
           connection.columns(model.table_name).each do |column|
             case
-            when except.include?("#{model.name}.#{column.name}")
+            when ignored?("#{model.name}.#{column.name}", except)
               log("#{model.name}.#{column.name} - ignored via the configuration; skipping")
             when type && !Array(type).include?(column.type)
               log("#{model.name}.#{column.name} - ignored due to the #{column.type} type; skipping")
@@ -238,7 +234,7 @@ module ActiveRecordDoctor
         log("Iterating over columns of #{table_name}") do
           connection.columns(table_name).each do |column|
             case
-            when except.include?("#{table_name}.#{column.name}")
+            when ignored?("#{table_name}.#{column.name}", except)
               log("#{column.name} - ignored via the configuration; skipping")
             when only.nil? || only.include?(column.name)
               log(column.name.to_s) do
@@ -270,7 +266,7 @@ module ActiveRecordDoctor
         log("Iterating over tables") do
           tables.each do |table|
             case
-            when except.include?(table)
+            when ignored?(table, except)
               log("#{table} - ignored via the configuration; skipping")
             else
               log(table) do
@@ -281,18 +277,33 @@ module ActiveRecordDoctor
         end
       end
 
+      def each_data_source(except: [])
+        log("Iterating over data sources") do
+          connection.data_sources.each do |data_source|
+            if ignored?(data_source, except)
+              log("#{data_source} - ignored via the configuration; skipping")
+            else
+              log(data_source) do
+                yield(data_source)
+              end
+            end
+          end
+        end
+      end
+
       def each_association(model, except: [], type: [:has_many, :has_one, :belongs_to], has_scope: nil, through: nil)
         type = Array(type)
 
         log("Iterating over associations on #{model.name}") do
-          associations = []
-          type.each do |type1|
-            associations.concat(model.reflect_on_all_associations(type1))
-          end
+          associations = type.map do |type1|
+            # Skip inherited associations from STI to prevent them
+            # from being reported multiple times on subclasses.
+            model.reflect_on_all_associations(type1) - model.superclass.reflect_on_all_associations(type1)
+          end.flatten
 
           associations.each do |association|
             case
-            when except.include?("#{model.name}.#{association.name}")
+            when ignored?("#{model.name}.#{association.name}", except)
               log("#{model.name}.#{association.name} - ignored via the configuration; skipping")
             when through && !association.is_a?(ActiveRecord::Reflection::ThroughReflection)
               log("#{model.name}.#{association.name} - is not a through association; skipping")
@@ -310,6 +321,10 @@ module ActiveRecordDoctor
           end
         end
       end
+
+      def ignored?(name, patterns)
+        patterns.any? { |pattern| pattern === name } # rubocop:disable Style/CaseEquality
+      end
     end
   end
 end

data/lib/active_record_doctor/detectors/extraneous_indexes.rb

@@ -19,11 +19,13 @@ module ActiveRecordDoctor
 
       private
 
-      def message(extraneous_index:, replacement_indexes:)
+      def message(table:, extraneous_index:, replacement_indexes:)
         if replacement_indexes.nil?
-          "remove #{extraneous_index} - coincides with the primary key on the table"
+          "remove #{extraneous_index} from #{table} - coincides with the primary key on the table"
         else
-          "remove #{extraneous_index} - can be replaced by #{replacement_indexes.join(' or ')}"
+          # rubocop:disable Layout/LineLength
+          "remove the index #{extraneous_index} from the table #{table} - queries should be able to use the following #{'index'.pluralize(replacement_indexes.count)} instead: #{replacement_indexes.join(' or ')}"
+          # rubocop:enable Layout/LineLength
         end
       end
 
@@ -34,7 +36,7 @@ module ActiveRecordDoctor
 
       def subindexes_of_multi_column_indexes
         log(__method__) do
-          each_table(except: config(:ignore_tables)) do |table|
+          each_data_source(except: config(:ignore_tables)) do |table|
             each_index(table, except: config(:ignore_indexes), multicolumn_only: true) do |index, indexes|
               replacement_indexes = indexes.select do |other_index|
                 index != other_index && replaceable_with?(index, other_index)
@@ -46,6 +48,7 @@ module ActiveRecordDoctor
               end
 
               problem!(
+                table: table,
                 extraneous_index: index.name,
                 replacement_indexes: replacement_indexes.map(&:name).sort
               )
@@ -60,7 +63,7 @@ module ActiveRecordDoctor
             each_index(table, except: config(:ignore_indexes), multicolumn_only: true) do |index|
               primary_key = connection.primary_key(table)
               if index.columns == [primary_key] && index.where.nil?
-                problem!(extraneous_index: index.name, replacement_indexes: nil)
+                problem!(table: table, extraneous_index: index.name, replacement_indexes: nil)
               end
             end
           end
@@ -73,13 +76,16 @@ module ActiveRecordDoctor
         return false if index1.where != index2.where
         return false if opclasses(index1) != opclasses(index2)
 
+        index1_columns = Array(index1.columns)
+        index2_columns = Array(index2.columns)
+
         case [index1.unique, index2.unique]
         when [true, true]
-          (index2.columns - index1.columns).empty?
+          (index2_columns - index1_columns).empty?
         when [true, false]
           false
         else
-          prefix?(index1, index2)
+          prefix?(index1_columns, index2_columns)
         end
       end
 
@@ -88,8 +94,7 @@ module ActiveRecordDoctor
       end
 
       def prefix?(lhs, rhs)
-        lhs.columns.count <= rhs.columns.count &&
-          rhs.columns[0...lhs.columns.count] == lhs.columns
+        lhs.count <= rhs.count && rhs[0...lhs.count] == lhs
       end
     end
   end

data/lib/active_record_doctor/detectors/incorrect_boolean_presence_validation.rb

@@ -5,7 +5,7 @@ require "active_record_doctor/detectors/base"
 module ActiveRecordDoctor
   module Detectors
     class IncorrectBooleanPresenceValidation < Base # :nodoc:
-      @description = "detect persence (instead of inclusion) validators on boolean columns"
+      @description = "detect presence (instead of inclusion) validators on boolean columns"
       @config = {
         ignore_models: {
           description: "models whose validators should not be checked",

data/lib/active_record_doctor/detectors/incorrect_dependent_option.rb

@@ -18,7 +18,8 @@ module ActiveRecordDoctor
 
       private
 
-      def message(model:, association:, problem:, associated_models:, associated_models_type:)
+      def message(model:, association:, problem:, associated_models_type: nil,
+                  table_name: nil, column_name: nil, associated_models: [])
         associated_models.sort!
 
         models_part =
@@ -36,6 +37,9 @@ module ActiveRecordDoctor
         case problem
         when :invalid_through
           "ensure #{model}.#{association} is configured correctly - #{associated_models[0]}.#{association} may be undefined"
+        when :destroy_async
+          "don't use `dependent: :destroy_async` on #{model}.#{association} or remove the foreign key from #{table_name}.#{column_name} - " \
+          "associated models will be deleted in the same transaction along with #{model}"
         when :suggest_destroy
           "use `dependent: :destroy` or similar on #{model}.#{association} - associated #{models_part} callbacks that are currently skipped"
         when :suggest_delete
@@ -88,29 +92,45 @@ module ActiveRecordDoctor
 
             deletable_models, destroyable_models = associated_models.partition { |klass| deletable?(klass) }
 
-            if callback_action(association) == :invoke && destroyable_models.empty? && deletable_models.present?
-              suggestion =
-                case association.macro
-                when :has_many then :suggest_delete_all
-                when :has_one, :belongs_to then :suggest_delete
-                else raise("unsupported association type #{association.macro}")
-                end
-
-              problem!(
-                model: model.name,
-                association: association.name,
-                problem: suggestion,
-                associated_models: deletable_models.map(&:name),
-                associated_models_type: associated_models_type
-              )
-            elsif callback_action(association) == :skip && destroyable_models.present?
-              problem!(
-                model: model.name,
-                association: association.name,
-                problem: :suggest_destroy,
-                associated_models: destroyable_models.map(&:name),
-                associated_models_type: associated_models_type
-              )
+            case association.options[:dependent]
+            when :destroy_async
+              foreign_key = foreign_key(association.klass.table_name, model.table_name)
+              if foreign_key
+                problem!(
+                  model: model.name,
+                  association: association.name,
+                  table_name: foreign_key.from_table,
+                  column_name: foreign_key.column,
+                  problem: :destroy_async
+                )
+              end
+            when :destroy
+              if destroyable_models.empty? && deletable_models.present?
+                suggestion =
+                  case association.macro
+                  when :has_many then :suggest_delete_all
+                  when :has_one, :belongs_to then :suggest_delete
+                  else raise("unsupported association type #{association.macro}")
+                  end
+
+                problem!(
+                  model: model.name,
+                  association: association.name,
+                  problem: suggestion,
+                  associated_models: deletable_models.map(&:name),
+                  associated_models_type: associated_models_type
+                )
+              end
+            when :delete, :delete_all
+              if destroyable_models.present?
+                problem!(
+                  model: model.name,
+                  association: association.name,
+                  problem: :suggest_destroy,
+                  associated_models: destroyable_models.map(&:name),
+                  associated_models_type: associated_models_type
+                )
+              end
             end
           end
         end
@@ -127,13 +147,6 @@ module ActiveRecordDoctor
         end
       end
 
-      def callback_action(reflection)
-        case reflection.options[:dependent]
-        when :delete, :delete_all then :skip
-        when :destroy then :invoke
-        end
-      end
-
       def deletable?(model)
         !defines_destroy_callbacks?(model) &&
           dependent_models(model).all? do |dependent_model|

data/lib/active_record_doctor/detectors/mismatched_foreign_key_type.rb

@@ -29,7 +29,7 @@ module ActiveRecordDoctor
           each_foreign_key(table) do |foreign_key|
             from_column = column(table, foreign_key.column)
 
-            next if config(:ignore_columns).include?("#{table}.#{from_column.name}")
+            next if ignored?("#{table}.#{from_column.name}", config(:ignore_columns))
 
             to_table = foreign_key.to_table
             to_column = column(to_table, foreign_key.primary_key)

data/lib/active_record_doctor/detectors/missing_non_null_constraint.rb

@@ -26,14 +26,14 @@ module ActiveRecordDoctor
         table_models = models.select(&:table_exists?).group_by(&:table_name)
 
         table_models.each do |table, models|
-          next if config(:ignore_tables).include?(table)
+          next if ignored?(table, config(:ignore_tables))
 
           concrete_models = models.reject do |model|
             model.abstract_class? || sti_base_model?(model)
           end
 
           connection.columns(table).each do |column|
-            next if config(:ignore_columns).include?("#{table}.#{column.name}")
+            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 not_null_check_constraint_exists?(table, column)

data/lib/active_record_doctor/detectors/missing_unique_indexes.rb

@@ -22,9 +22,12 @@ module ActiveRecordDoctor
       def message(model:, table:, columns:, problem:)
         case problem
         when :validations
-          "add a unique index on #{table}(#{columns.join(', ')}) - validating uniqueness in the model without an index can lead to duplicates"
+          "add a unique index on #{table}(#{columns.join(', ')}) - validating uniqueness in #{model.name} without an index can lead to duplicates"
+        when :case_insensitive_validations
+          "add a unique expression index on #{table}(#{columns.join(', ')}) - validating case-insensitive uniqueness in #{model.name} " \
+          "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.first}) - using `has_one` in the #{model.name} model without an index can lead to duplicates"
+          "add a unique index on #{table}(#{columns.join(', ')}) - using `has_one` in #{model.name} without an index can lead to duplicates"
         end
       end
       # rubocop:enable Layout/LineLength
@@ -36,19 +39,44 @@ module ActiveRecordDoctor
 
       def validations_without_indexes
         each_model(except: config(:ignore_models), existing_tables_only: true) do |model|
-          model.validators.each do |validator|
+          # Skip inherited validators from STI to prevent them
+          # from being reported multiple times on subclasses.
+          validators = model.validators - model.superclass.validators
+          validators.each do |validator|
             scope = Array(validator.options.fetch(:scope, []))
 
             next unless validator.is_a?(ActiveRecord::Validations::UniquenessValidator)
-            next unless supported_validator?(validator)
+            next if conditional_validator?(validator)
+
+            # In Rails 6, default option values are no longer explicitly set on
+            # options so if the key is absent we must fetch the default value
+            # ourselves. case_sensitive is the default in 4.2+ so it's safe to
+            # put true literally.
+            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?
 
             validator.attributes.each do |attribute|
               columns = resolve_attributes(model, scope + [attribute])
 
-              next if unique_index?(model.table_name, columns)
               next if ignore_columns.include?("#{model.name}(#{columns.join(',')})")
 
-              problem!(model: model, table: model.table_name, columns: columns, problem: :validations)
+              columns[-1] = "lower(#{columns[-1]})" unless case_sensitive
+
+              next if unique_index?(model.table_name, columns)
+
+              if case_sensitive
+                problem!(model: model, table: model.table_name, columns: columns, problem: :validations)
+              else
+                problem!(
+                  model: model,
+                  table: model.table_name,
+                  columns: columns,
+                  problem: :case_insensitive_validations
+                )
+              end
             end
           end
         end
@@ -57,29 +85,27 @@ module ActiveRecordDoctor
       def has_ones_without_indexes # rubocop:disable Naming/PredicateName
         each_model do |model|
           each_association(model, type: :has_one, has_scope: false, through: false) do |has_one|
-            next if config(:ignore_models).include?(has_one.klass.name)
+            next if ignored?(has_one.klass.name, config(:ignore_models))
 
-            foreign_key = has_one.foreign_key
-            next if ignore_columns.include?(foreign_key.to_s)
+            columns =
+              if has_one.options[:as]
+                [has_one.type.to_s, has_one.foreign_key.to_s]
+              else
+                [has_one.foreign_key.to_s]
+              end
+            next if ignored?("#{has_one.klass.name}(#{columns.join(',')})", ignore_columns)
 
             table_name = has_one.klass.table_name
-            next if unique_index?(table_name, [foreign_key])
+            next if unique_index?(table_name, columns)
+            next if Array(connection.primary_key(table_name)) == columns
 
-            problem!(model: model, table: table_name, columns: [foreign_key], problem: :has_ones)
+            problem!(model: model, table: table_name, columns: columns, problem: :has_ones)
           end
         end
       end
 
-      def supported_validator?(validator)
-        validator.options[:if].nil? &&
-          validator.options[:unless].nil? &&
-          validator.options[:conditions].nil? &&
-
-          # In Rails 6, default option values are no longer explicitly set on
-          # options so if the key is absent we must fetch the default value
-          # ourselves. case_sensitive is the default in 4.2+ so it's safe to
-          # put true literally.
-          validator.options.fetch(:case_sensitive, true)
+      def conditional_validator?(validator)
+        (validator.options.keys & [:if, :unless, :conditions]).present?
       end
 
       def resolve_attributes(model, attributes)
@@ -99,17 +125,41 @@ module ActiveRecordDoctor
       def unique_index?(table_name, columns, scope = nil)
         columns = (Array(scope) + columns).map(&:to_s)
         indexes(table_name).any? do |index|
+          index_columns =
+            # For expression indexes, Active Record returns columns as string.
+            if index.columns.is_a?(String)
+              extract_index_columns(index.columns)
+            else
+              index.columns
+            end
+
           index.unique &&
             index.where.nil? &&
-            (Array(index.columns) - columns).empty?
+            (index_columns - columns).empty?
         end
       end
 
       def ignore_columns
         @ignore_columns ||= config(:ignore_columns).map do |column|
-          column.gsub(" ", "")
+          if column.is_a?(String)
+            column.gsub(" ", "")
+          else
+            column
+          end
         end
       end
+
+      def extract_index_columns(columns)
+        columns
+          .split(",")
+          .map(&:strip)
+          .map do |column|
+            column.gsub(/lower\(/i, "lower(")
+                  .gsub(/\((\w+)\)::\w+/, '\1') # (email)::string
+                  .gsub(/([`'"])(\w+)\1/, '\2') # quoted identifiers
+                  .gsub(/\A\((.+)\)\z/, '\1')   # remove surrounding braces from MySQL
+          end
+      end
     end
   end
 end

data/lib/active_record_doctor/detectors/short_primary_key_type.rb

@@ -23,7 +23,7 @@ module ActiveRecordDoctor
         each_table(except: config(:ignore_tables)) do |table|
           column = primary_key(table)
           next if column.nil?
-          next if bigint?(column) || uuid?(column)
+          next if !integer?(column) || bigint?(column)
 
           problem!(table: table, column: column.name)
         end
@@ -37,8 +37,8 @@ module ActiveRecordDoctor
         end
       end
 
-      def uuid?(column)
-        column.sql_type == "uuid"
+      def integer?(column)
+        column.type == :integer
       end
     end
   end