active_record_doctor 1.11.0 → 1.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fef82b1493488683e11bc72273e142479cb47234651a8aa772a83121960f9309
-  data.tar.gz: c99afc25d8307ff0814e0459790f3d7fcf0b015d9f37f118870a9a1cfa2cf460
+  metadata.gz: d848e296c39f7994781bd645261eb45235450be36058fbdf7368ec6358ebeba5
+  data.tar.gz: a63cbbfe5b43fb3bf6daeaba24a6298073643d5b5c96696c27c084106fe54594
 SHA512:
-  metadata.gz: ab75ff192c31cfc10cbd5c4106ca0033cc4d408c1e4977a417f76c53f2a2e73e37e5706162cd4807c700808e171756ddda022af6658b60f460d78109f9bea2ee
-  data.tar.gz: 075625a08ac5f192a68ed6c99409a4acf85cadb77ec117d6933186c2bf4d07e5aaf08928e9f30d5dd96b263e8e530a4a4da848ef5a4dfc82d5dae0df2475f7d2
+  metadata.gz: 47411eea54d4c21329459dc7490090a535c53e9f3be912268ceed2f6e2588246cb07c9b90e758559d9b0c08de319f3dc6a4735c79511bc30c2ec7b058104c08e
+  data.tar.gz: 9596cb799a4346b3ec60562876750990b486efc7daebfda0834b028bf2db9075f04bf6b028185df6076ede3a7227cb9755a6ac9e8db609431d063261f3c0732d

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)
@@ -158,7 +158,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 +209,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 +265,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 +307,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 +320,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 +333,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 +475,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 +489,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 +530,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 +565,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 +584,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/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,10 +164,6 @@ 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|
@@ -281,14 +277,29 @@ module ActiveRecordDoctor
         end
       end
 
+      def each_data_source(except: [])
+        log("Iterating over data sources") do
+          connection.data_sources.each do |data_source|
+            if except.include?(data_source)
+              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

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_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,40 @@ 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 +142,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/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,40 @@ 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
@@ -59,27 +83,24 @@ module ActiveRecordDoctor
           each_association(model, type: :has_one, has_scope: false, through: false) do |has_one|
             next if config(:ignore_models).include?(has_one.klass.name)
 
-            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 ignore_columns.include?("#{model.name}(#{columns.join(',')})")
 
             table_name = has_one.klass.table_name
-            next if unique_index?(table_name, [foreign_key])
+            next if unique_index?(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,9 +120,17 @@ 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
 
@@ -110,6 +139,18 @@ module ActiveRecordDoctor
           column.gsub(" ", "")
         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

data/lib/active_record_doctor/detectors/unindexed_foreign_keys.rb

@@ -18,28 +18,43 @@ module ActiveRecordDoctor
 
       private
 
-      def message(table:, column:)
+      def message(table:, columns:)
         # rubocop:disable Layout/LineLength
-        "add an index on #{table}.#{column} - foreign keys are often used in database lookups and should be indexed for performance reasons"
+        "add an index on #{table}(#{columns.join(', ')}) - foreign keys are often used in database lookups and should be indexed for performance reasons"
         # rubocop:enable Layout/LineLength
       end
 
       def detect
         each_table(except: config(:ignore_tables)) do |table|
           each_column(table, except: config(:ignore_columns)) do |column|
-            next unless foreign_key?(column)
+            next unless named_like_foreign_key?(column) || foreign_key?(table, column)
             next if indexed?(table, column)
             next if indexed_as_polymorphic?(table, column)
 
-            problem!(table: table, column: column.name)
+            type_column_name = type_column_name(column)
+
+            columns =
+              if column_exists?(table, type_column_name)
+                [type_column_name, column.name]
+              else
+                [column.name]
+              end
+
+            problem!(table: table, columns: columns)
           end
         end
       end
 
-      def foreign_key?(column)
+      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
+        end
+      end
+
       def indexed?(table, column)
         connection.indexes(table).any? do |index|
           index.columns.first == column.name
@@ -47,9 +62,20 @@ module ActiveRecordDoctor
       end
 
       def indexed_as_polymorphic?(table, column)
-        type_column_name = column.name.sub(/_id\Z/, "_type")
         connection.indexes(table).any? do |index|
-          index.columns == [type_column_name, column.name]
+          index.columns[0, 2] == [type_column_name(column), column.name]
+        end
+      end
+
+      def column_exists?(table, column_name)
+        connection.columns(table).any? { |column| column.name == column_name }
+      end
+
+      def type_column_name(column)
+        if column.name.end_with?("_id")
+          column.name.sub(/_id\Z/, "_type")
+        else
+          "#{column.name}_type"
         end
       end
     end

data/lib/active_record_doctor/utils.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveRecordDoctor
+  module Utils # :nodoc:
+    class << self
+      def postgresql?(connection = ActiveRecord::Base.connection)
+        ["PostgreSQL", "PostGIS"].include?(connection.adapter_name)
+      end
+
+      def mysql?(connection = ActiveRecord::Base.connection)
+        connection.adapter_name == "Mysql2"
+      end
+
+      def expression_indexes_unsupported?(connection = ActiveRecord::Base.connection)
+        (ActiveRecord::VERSION::STRING < "5.0") ||
+          # Active Record < 6 is unable to correctly parse expression indexes for MySQL.
+          (mysql?(connection) && ActiveRecord::VERSION::STRING < "6.0")
+      end
+    end
+  end
+end

data/lib/active_record_doctor/version.rb

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

data/lib/active_record_doctor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_record_doctor/railtie" if defined?(Rails) && defined?(Rails::Railtie)
+require "active_record_doctor/utils"
 require "active_record_doctor/logger"
 require "active_record_doctor/logger/dummy"
 require "active_record_doctor/logger/hierarchical"
@@ -25,6 +26,7 @@ require "active_record_doctor/runner"
 require "active_record_doctor/version"
 require "active_record_doctor/config"
 require "active_record_doctor/config/loader"
+require "active_record_doctor/rake/task"
 
 module ActiveRecordDoctor # :nodoc:
 end

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

@@ -10,16 +10,16 @@ module ActiveRecordDoctor
       migration_descriptions = read_migration_descriptions(path)
       now = Time.now
 
-      migration_descriptions.each_with_index do |(table, columns), index|
+      migration_descriptions.each_with_index do |(table, indexes), index|
         timestamp = (now + index).strftime("%Y%m%d%H%M%S")
         file_name = "db/migrate/#{timestamp}_index_foreign_keys_in_#{table}.rb"
-        create_file(file_name, content(table, columns).tap { |x| puts x })
+        create_file(file_name, content(table, indexes).tap { |x| puts x })
       end
     end
 
     private
 
-    INPUT_LINE = /^add an index on (\w+)\.(\w+) - .*$/.freeze
+    INPUT_LINE = /^add an index on (\w+)\((.+)\) - .*$/.freeze
     private_constant :INPUT_LINE
 
     def read_migration_descriptions(path)
@@ -34,41 +34,41 @@ module ActiveRecordDoctor
         end
 
         table = match[1]
-        column = match[2]
+        columns = match[2].split(",").map(&:strip)
 
-        tables_to_columns[table] << column
+        tables_to_columns[table] << columns
       end
 
       tables_to_columns
     end
 
-    def content(table, columns)
+    def content(table, indexes)
       # In order to properly indent the resulting code, we must disable the
       # rubocop rule below.
 
       <<MIGRATION
 class IndexForeignKeysIn#{table.camelize} < ActiveRecord::Migration#{migration_version}
   def change
-#{add_indexes(table, columns)}
+#{add_indexes(table, indexes)}
   end
 end
 MIGRATION
     end
 
-    def add_indexes(table, columns)
-      columns.map do |column|
-        add_index(table, column)
+    def add_indexes(table, indexes)
+      indexes.map do |columns|
+        add_index(table, columns)
       end.join("\n")
     end
 
-    def add_index(table, column)
+    def add_index(table, columns)
       connection = ActiveRecord::Base.connection
 
-      index_name = connection.index_name(table, column)
+      index_name = connection.index_name(table, columns)
       if index_name.size > connection.index_name_length
-        "    add_index :#{table}, :#{column}, name: '#{index_name.first(connection.index_name_length)}'"
+        "    add_index :#{table}, #{columns.inspect}, name: '#{index_name.first(connection.index_name_length)}'"
       else
-        "    add_index :#{table}, :#{column}"
+        "    add_index :#{table}, #{columns.inspect}"
       end
     end
 

data/test/active_record_doctor/detectors/extraneous_indexes_test.rb

@@ -7,7 +7,7 @@ class ActiveRecordDoctor::Detectors::ExtraneousIndexesTest < Minitest::Test
     end
 
     assert_problems(<<OUTPUT)
-remove index_users_on_id - coincides with the primary key on the table
+remove index_users_on_id from users - coincides with the primary key on the table
 OUTPUT
   end
 
@@ -28,7 +28,7 @@ OUTPUT
     end
 
     assert_problems(<<OUTPUT)
-remove index_profiles_on_user_id - coincides with the primary key on the table
+remove index_profiles_on_user_id from profiles - coincides with the primary key on the table
 OUTPUT
   end
 
@@ -42,7 +42,7 @@ OUTPUT
     ActiveRecord::Base.connection.add_index :users, :email, name: "index_users_on_email"
 
     assert_problems(<<OUTPUT)
-remove index_users_on_email - can be replaced by unique_index_on_users_email
+remove the index index_users_on_email from the table users - queries should be able to use the following index instead: unique_index_on_users_email
 OUTPUT
   end
 
@@ -59,7 +59,7 @@ OUTPUT
     end
 
     assert_problems(<<OUTPUT)
-remove index_users_on_last_name - can be replaced by index_users_on_last_name_and_first_name_and_email or unique_index_on_users_last_name_and_first_name
+remove the index index_users_on_last_name from the table users - queries should be able to use the following indices instead: index_users_on_last_name_and_first_name_and_email or unique_index_on_users_last_name_and_first_name
 OUTPUT
   end
 
@@ -78,7 +78,7 @@ OUTPUT
     ActiveRecord::Base.connection.add_index :users, [:last_name, :first_name]
 
     assert_problems(<<OUTPUT)
-remove index_users_on_last_name_and_first_name - can be replaced by index_users_on_last_name_and_first_name_and_email or unique_index_on_users_last_name_and_first_name
+remove the index index_users_on_last_name_and_first_name from the table users - queries should be able to use the following indices instead: index_users_on_last_name_and_first_name_and_email or unique_index_on_users_last_name_and_first_name
 OUTPUT
   end
 
@@ -91,10 +91,36 @@ OUTPUT
     end
 
     assert_problems(<<OUTPUT)
-remove index_users_on_last_name_and_first_name - can be replaced by index_users_on_first_name
+remove the index index_users_on_last_name_and_first_name from the table users - queries should be able to use the following index instead: index_users_on_first_name
 OUTPUT
   end
 
+  def test_expression_index_not_covered_by_multicolumn_index
+    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
+
+    create_table(:users) do |t|
+      t.string :first_name
+      t.string :email
+      t.index "(lower(email))"
+      t.index [:first_name, :email]
+    end
+
+    refute_problems
+  end
+
+  def test_unique_expression_index_not_covered_by_unique_multicolumn_index
+    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
+
+    create_table(:users) do |t|
+      t.string :first_name
+      t.string :email
+      t.index "(lower(email))", unique: true
+      t.index [:first_name, :email], unique: true
+    end
+
+    refute_problems
+  end
+
   def test_not_covered_by_different_index_type
     create_table(:users) do |t|
       t.string :first_name
@@ -139,6 +165,33 @@ OUTPUT
     refute_problems
   end
 
+  def test_single_column_covered_by_multi_column_on_materialized_view_is_duplicate
+    skip("Only PostgreSQL supports materialized views") unless postgresql?
+
+    begin
+      create_table(:users) do |t|
+        t.string :first_name
+        t.string :last_name
+        t.integer :age
+      end
+
+      connection = ActiveRecord::Base.connection
+      connection.execute(<<-SQL)
+        CREATE MATERIALIZED VIEW user_initials AS
+          SELECT first_name, last_name FROM users
+      SQL
+
+      connection.add_index(:user_initials, [:last_name, :first_name])
+      connection.add_index(:user_initials, :last_name)
+
+      assert_problems(<<OUTPUT)
+remove the index index_user_initials_on_last_name from the table user_initials - queries should be able to use the following index instead: index_user_initials_on_last_name_and_first_name
+OUTPUT
+    ensure
+      connection.execute("DROP MATERIALIZED VIEW user_initials")
+    end
+  end
+
   def test_config_ignore_tables
     # The detector recognizes two kinds of errors and both must take
     # ignore_tables into account. We trigger those errors by indexing the

data/test/active_record_doctor/detectors/incorrect_dependent_option_test.rb

@@ -405,6 +405,45 @@ class ActiveRecordDoctor::Detectors::IncorrectDependentOptionTest < Minitest::Te
     OUTPUT
   end
 
+  def test_destroy_async_and_foreign_key_exists
+    skip("ActiveRecord < 6.1 doesn't support :destroy_async") if ActiveRecord::VERSION::STRING < "6.1"
+
+    create_table(:companies) do
+    end.define_model do
+      # We need an ActiveJob job defined to appease the ActiveRecord
+      class_attribute :destroy_association_async_job, default: Class.new
+
+      has_many :users, dependent: :destroy_async
+    end
+
+    create_table(:users) do |t|
+      t.references :company, foreign_key: true
+    end.define_model
+
+    assert_problems(<<~OUTPUT)
+      don't use `dependent: :destroy_async` on TransientRecord::Models::Company.users or remove the foreign key from users.company_id - \
+      associated models will be deleted in the same transaction along with TransientRecord::Models::Company
+    OUTPUT
+  end
+
+  def test_destroy_async_and_no_foreign_key
+    skip("ActiveRecord < 6.1 doesn't support :destroy_async") if ActiveRecord::VERSION::STRING < "6.1"
+
+    create_table(:companies) do
+    end.define_model do
+      # We need an ActiveJob job defined to appease the ActiveRecord
+      class_attribute :destroy_association_async_job, default: Class.new
+
+      has_many :users, dependent: :destroy_async
+    end
+
+    create_table(:users) do |t|
+      t.references :company, foreign_key: false
+    end.define_model
+
+    refute_problems
+  end
+
   def test_config_ignore_models
     create_table(:companies) do
     end.define_model do

data/test/active_record_doctor/detectors/missing_unique_indexes_test.rb

@@ -10,7 +10,7 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     end
 
     assert_problems(<<~OUTPUT)
-      add a unique index on users(email) - validating uniqueness in the model without an index can lead to duplicates
+      add a unique index on users(email) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
     OUTPUT
   end
 
@@ -39,8 +39,8 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     end
 
     assert_problems(<<~OUTPUT)
-      add a unique index on users(email) - validating uniqueness in the model without an index can lead to duplicates
-      add a unique index on users(ref_token) - validating uniqueness in the model without an index can lead to duplicates
+      add a unique index on users(email) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
+      add a unique index on users(ref_token) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
     OUTPUT
   end
 
@@ -55,6 +55,25 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     refute_problems
   end
 
+  def test_missing_unique_index_reported_only_on_base_class
+    create_table(:users) do |t|
+      t.string :type
+      t.string :email
+      t.string :name
+    end.define_model do
+      validates :email, uniqueness: true
+    end
+
+    define_model(:Client, TransientRecord::Models::User) do
+      validates :name, uniqueness: true
+    end
+
+    assert_problems(<<~OUTPUT)
+      add a unique index on users(email) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
+      add a unique index on users(name) - validating uniqueness in TransientRecord::Models::Client without an index can lead to duplicates
+    OUTPUT
+  end
+
   def test_present_partial_unique_index
     skip("MySQL doesn't support partial indexes") if mysql?
 
@@ -67,7 +86,7 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     end
 
     assert_problems(<<~OUTPUT)
-      add a unique index on users(email) - validating uniqueness in the model without an index can lead to duplicates
+      add a unique index on users(email) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
     OUTPUT
   end
 
@@ -82,7 +101,7 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     end
 
     assert_problems(<<~OUTPUT)
-      add a unique index on users(company_id, department_id, email) - validating uniqueness in the model without an index can lead to duplicates
+      add a unique index on users(company_id, department_id, email) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
     OUTPUT
   end
 
@@ -121,7 +140,7 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     end
 
     assert_problems(<<~OUTPUT)
-      add a unique index on users(account_id) - validating uniqueness in the model without an index can lead to duplicates
+      add a unique index on users(account_id) - validating uniqueness in TransientRecord::Models::User without an index can lead to duplicates
     OUTPUT
   end
 
@@ -148,7 +167,7 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     end
 
     assert_problems(<<~OUTPUT)
-      add a unique index on comments(commentable_type, commentable_id, title) - validating uniqueness in the model without an index can lead to duplicates
+      add a unique index on comments(commentable_type, commentable_id, title) - validating uniqueness in TransientRecord::Models::Comment without an index can lead to duplicates
     OUTPUT
   end
 
@@ -179,12 +198,112 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     refute_problems
   end
 
-  def test_conditions_is_skipped
-    assert_skipped(conditions: -> { where.not(email: nil) })
+  def test_case_insensitive_unique_index_exists
+    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
+
+    create_table(:users) do |t|
+      t.string :email
+
+      t.index :email, unique: true
+    end.define_model do
+      validates :email, uniqueness: { case_sensitive: false }
+    end
+
+    assert_problems(<<~OUTPUT)
+      add a unique expression index on users(lower(email)) - validating case-insensitive uniqueness in TransientRecord::Models::User without an expression index can lead to duplicates (a regular unique index is not enough)
+    OUTPUT
+  end
+
+  def test_case_insensitive_non_unique_lower_index_exists
+    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
+
+    create_table(:users) do |t|
+      t.string :email
+    end.define_model do
+      validates :email, uniqueness: { case_sensitive: false }
+    end
+
+    # ActiveRecord < 5 does not support expression indexes.
+    ActiveRecord::Base.connection.execute(<<-SQL)
+      CREATE INDEX index_users_on_lower_email ON users ((lower(email)))
+    SQL
+
+    assert_problems(<<~OUTPUT)
+      add a unique expression index on users(lower(email)) - validating case-insensitive uniqueness in TransientRecord::Models::User without an expression index can lead to duplicates (a regular unique index is not enough)
+    OUTPUT
+  end
+
+  def test_case_insensitive_unique_lower_index_exists
+    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
+
+    create_table(:users) do |t|
+      t.string :email
+    end.define_model do
+      validates :email, uniqueness: { case_sensitive: false }
+    end
+
+    # ActiveRecord < 5 does not support expression indexes.
+    ActiveRecord::Base.connection.execute(<<-SQL)
+      CREATE UNIQUE INDEX index_users_on_lower_email ON users ((lower(email)))
+    SQL
+
+    refute_problems
+  end
+
+  def test_case_insensitive_compound_unique_index_exists
+    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
+
+    create_table(:users) do |t|
+      t.string :email
+      t.integer :organization_id
+      t.index [:email, :organization_id], unique: true
+    end.define_model do
+      validates :email, uniqueness: { scope: :organization_id, case_sensitive: false }
+    end
+
+    assert_problems(<<~OUTPUT)
+      add a unique expression index on users(organization_id, lower(email)) - validating case-insensitive uniqueness in TransientRecord::Models::User without an expression index can lead to duplicates (a regular unique index is not enough)
+    OUTPUT
+  end
+
+  def test_case_insensitive_compound_non_unique_lower_index_exists
+    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
+
+    create_table(:users) do |t|
+      t.string :email
+      t.integer :organization_id
+    end.define_model do
+      validates :email, uniqueness: { scope: :organization_id, case_sensitive: false }
+    end
+
+    ActiveRecord::Base.connection.execute(<<-SQL)
+      CREATE INDEX index_users_on_lower_email_and_organization_id ON users ((lower(email)), organization_id)
+    SQL
+
+    assert_problems(<<~OUTPUT)
+      add a unique expression index on users(organization_id, lower(email)) - validating case-insensitive uniqueness in TransientRecord::Models::User without an expression index can lead to duplicates (a regular unique index is not enough)
+    OUTPUT
+  end
+
+  def test_case_insensitive_compound_unique_lower_index_exists
+    skip("Expression indexes are not supported") if ActiveRecordDoctor::Utils.expression_indexes_unsupported?
+
+    create_table(:users) do |t|
+      t.string :email
+      t.integer :organization_id
+    end.define_model do
+      validates :email, uniqueness: { scope: :organization_id, case_sensitive: false }
+    end
+
+    ActiveRecord::Base.connection.execute(<<-SQL)
+      CREATE UNIQUE INDEX index_users_on_lower_email_and_organization_id ON users ((lower(email)), organization_id)
+    SQL
+
+    refute_problems
   end
 
-  def test_case_insensitive_is_skipped
-    assert_skipped(case_sensitive: false)
+  def test_conditions_is_skipped
+    assert_skipped(conditions: -> { where.not(email: nil) })
   end
 
   def test_if_is_skipped
@@ -226,8 +345,8 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     end
 
     assert_problems(<<~OUTPUT)
-      add a unique index on accounts(user_id) - using `has_one` in the TransientRecord::Models::User model without an index can lead to duplicates
-      add a unique index on account_histories(account_id) - using `has_one` in the TransientRecord::Models::Account model without an index can lead to duplicates
+      add a unique index on accounts(user_id) - using `has_one` in TransientRecord::Models::User without an index can lead to duplicates
+      add a unique index on account_histories(account_id) - using `has_one` in TransientRecord::Models::Account without an index can lead to duplicates
     OUTPUT
   end
 
@@ -244,6 +363,24 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     refute_problems
   end
 
+  def test_missing_has_one_unique_index_reported_only_on_base_class
+    create_table(:users) do |t|
+      t.string :type
+    end.define_model do
+      has_one :account, class_name: "TransientRecord::Models::Account"
+    end
+
+    define_model(:Client, TransientRecord::Models::User)
+
+    create_table(:accounts) do |t|
+      t.integer :user_id
+    end.define_model
+
+    assert_problems(<<~OUTPUT)
+      add a unique index on accounts(user_id) - using `has_one` in TransientRecord::Models::User without an index can lead to duplicates
+    OUTPUT
+  end
+
   def test_has_one_with_index
     create_table(:users)
       .define_model do
@@ -257,6 +394,38 @@ class ActiveRecordDoctor::Detectors::MissingUniqueIndexesTest < Minitest::Test
     refute_problems
   end
 
+  def test_polymorphic_has_one_without_index
+    create_table(:users)
+      .define_model do
+        has_one :account, as: :accountable
+      end
+
+    create_table(:accounts) do |t|
+      t.belongs_to :accountable, polymorphic: true, index: false
+    end.define_model do
+      belongs_to :accountable, polymorphic: true
+    end
+
+    assert_problems(<<~OUTPUT)
+      add a unique index on accounts(accountable_type, accountable_id) - using `has_one` in TransientRecord::Models::User without an index can lead to duplicates
+    OUTPUT
+  end
+
+  def test_polymorphic_has_one_with_index
+    create_table(:users)
+      .define_model do
+        has_one :account, as: :accountable
+      end
+
+    create_table(:accounts) do |t|
+      t.belongs_to :accountable, polymorphic: true, index: { unique: true }
+    end.define_model do
+      belongs_to :accountable, polymorphic: true
+    end
+
+    refute_problems
+  end
+
   def test_config_ignore_models
     create_table(:users) do |t|
       t.string :email

data/test/active_record_doctor/detectors/short_primary_key_type_test.rb

@@ -25,6 +25,11 @@ class ActiveRecordDoctor::Detectors::ShortPrimaryKeyTypeTest < Minitest::Test
     OUTPUT
   end
 
+  def test_non_integer_and_non_uuid_primary_key_is_not_reported
+    create_table(:companies, id: :string, primary_key: :uuid)
+    refute_problems
+  end
+
   def test_long_integer_primary_key_is_not_reported
     create_table(:companies, id: :bigint)
     refute_problems

data/test/active_record_doctor/detectors/unindexed_foreign_keys_test.rb

@@ -10,10 +10,48 @@ class ActiveRecordDoctor::Detectors::UnindexedForeignKeysTest < Minitest::Test
     end
 
     assert_problems(<<~OUTPUT)
-      add an index on users.company_id - foreign keys are often used in database lookups and should be indexed for performance reasons
+      add an index on users(company_id) - foreign keys are often used in database lookups and should be indexed for performance reasons
     OUTPUT
   end
 
+  def test_unindexed_foreign_key_with_nonstandard_name_is_reported
+    skip("MySQL always indexes foreign keys") if mysql?
+
+    create_table(:companies)
+    create_table(:users) do |t|
+      t.integer :company
+      t.foreign_key :companies, column: :company
+    end
+
+    assert_problems(<<~OUTPUT)
+      add an index on users(company) - foreign keys are often used in database lookups and should be indexed for performance reasons
+    OUTPUT
+  end
+
+  def test_unindexed_polymorphic_foreign_key_is_reported
+    create_table(:notes) do |t|
+      t.integer :notable_id
+      t.string :notable_type
+    end
+
+    assert_problems(<<~OUTPUT)
+      add an index on notes(notable_type, notable_id) - foreign keys are often used in database lookups and should be indexed for performance reasons
+    OUTPUT
+  end
+
+  def test_indexed_polymorphic_foreign_key_is_not_reported
+    create_table(:notes) do |t|
+      t.string :title
+      t.integer :notable_id
+      t.string :notable_type
+
+      # Includes additional column except `notable`
+      t.index [:notable_type, :notable_id, :title]
+    end
+
+    refute_problems
+  end
+
   def test_indexed_foreign_key_is_not_reported
     create_table(:companies)
     create_table(:users) do |t|

data/test/generators/active_record_doctor/add_indexes/add_indexes_generator_test.rb

@@ -8,6 +8,10 @@ class ActiveRecordDoctor::AddIndexesGeneratorTest < Minitest::Test
   TIMESTAMP = Time.new(2021, 2, 1, 13, 15, 30)
 
   def test_create_migrations
+    create_table(:notes) do |t|
+      t.integer :notable_id, null: false
+      t.string :notable_type, null: false
+    end
     create_table(:users) do |t|
       t.integer :organization_id, null: false
       t.integer :account_id, null: false
@@ -21,9 +25,10 @@ class ActiveRecordDoctor::AddIndexesGeneratorTest < Minitest::Test
 
       path = File.join(dir, "indexes.txt")
       File.write(path, <<~INDEXES)
-        add an index on users.organization_id - foreign keys are often used in database lookups and should be indexed for performance reasons
-        add an index on users.account_id - foreign keys are often used in database lookups and should be indexed for performance reasons
-        add an index on organizations.owner_id - foreign keys are often used in database lookups and should be indexed for performance reasons
+        add an index on users(organization_id) - foreign keys are often used in database lookups and should be indexed for performance reasons
+        add an index on users(account_id) - foreign keys are often used in database lookups and should be indexed for performance reasons
+        add an index on organizations(owner_id) - foreign keys are often used in database lookups and should be indexed for performance reasons
+        add an index on notes(notable_type, notable_id) - foreign keys are often used in database lookups and should be indexed for performance reasons
       INDEXES
 
       capture_io do
@@ -36,25 +41,30 @@ class ActiveRecordDoctor::AddIndexesGeneratorTest < Minitest::Test
           load(File.join("db", "migrate", "20210201131531_index_foreign_keys_in_organizations.rb"))
           IndexForeignKeysInOrganizations.migrate(:up)
 
+          load(File.join("db", "migrate", "20210201131532_index_foreign_keys_in_notes.rb"))
+          IndexForeignKeysInNotes.migrate(:up)
+
           ::Object.send(:remove_const, :IndexForeignKeysInUsers)
           ::Object.send(:remove_const, :IndexForeignKeysInOrganizations)
+          ::Object.send(:remove_const, :IndexForeignKeysInNotes)
         end
       end
 
       assert_indexes([
+        ["notes", ["notable_type", "notable_id"]],
         ["users", ["organization_id"]],
         ["users", ["account_id"]],
         ["organizations", ["owner_id"]]
       ])
 
-      assert_equal(4, Dir.entries("./db/migrate").size)
+      assert_equal(5, Dir.entries("./db/migrate").size)
     end
   end
 
   def test_create_migrations_raises_when_malformed_inpout
     Tempfile.create do |file|
       file.write(<<~INDEXES)
-        add an index on users. - foreign keys are often used in database lookups and should be indexed for performance reasons
+        add an index on users() - foreign keys are often used in database lookups and should be indexed for performance reasons
       INDEXES
       file.flush
 
@@ -95,7 +105,7 @@ class ActiveRecordDoctor::AddIndexesGeneratorTest < Minitest::Test
 
       path = File.join(dir, "indexes.txt")
       File.write(path, <<~INDEXES)
-        add an index on organizations_migrated_from_legacy_app.legacy_owner_id_compatible_with_v1_to_v8 - foreign keys are often used in database lookups and should be indexed for performance reasons
+        add an index on organizations_migrated_from_legacy_app(legacy_owner_id_compatible_with_v1_to_v8) - foreign keys are often used in database lookups and should be indexed for performance reasons
       INDEXES
 
       capture_io do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record_doctor
 version: !ruby/object:Gem::Version
-  version: 1.11.0
+  version: 1.12.0
 platform: ruby
 authors:
 - Greg Navis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-16 00:00:00.000000000 Z
+date: 2023-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.4
+        version: 1.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.1.4
+        version: 1.3.0
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -159,6 +159,7 @@ files:
 - lib/active_record_doctor/railtie.rb
 - lib/active_record_doctor/rake/task.rb
 - lib/active_record_doctor/runner.rb
+- lib/active_record_doctor/utils.rb
 - lib/active_record_doctor/version.rb
 - lib/generators/active_record_doctor/add_indexes/USAGE
 - lib/generators/active_record_doctor/add_indexes/add_indexes_generator.rb
@@ -201,7 +202,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Identify database issues before they hit production.