active_record_doctor 1.10.0 → 1.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e1bf7642b1c7b471fbf78956825067ff070d261d4c47a182d1aaf00f10b98b7
-  data.tar.gz: 6e6fc746327d6db30c282d7964ae778b254107281d9626a251f8593d6ce85db4
+  metadata.gz: d848e296c39f7994781bd645261eb45235450be36058fbdf7368ec6358ebeba5
+  data.tar.gz: a63cbbfe5b43fb3bf6daeaba24a6298073643d5b5c96696c27c084106fe54594
 SHA512:
-  metadata.gz: a0a2d71947728b9d6a130901d94d1ed8c2ede9dde209e91897a8beb8b757da2fea854b89a3a3f6223d658c203e75e687edbee2af37b2203ddb24b28e831439e8
-  data.tar.gz: f0fe87dd6acf379ef946bc513504342c3977bf5c4d7f71eca79290c693b318f0a838c31b95111f68635579cdfa26249d5a95fd456817b6a3c32023c1b4fe0fd1
+  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:
@@ -509,7 +509,7 @@ Supported configuration options:
 
 - `enabled` - set to `false` to disable the detector altogether
 - `ignore_models` - models whose associations should not be checked.
-- `ignore_columns` - associations, written as Model.association, that should not
+- `ignore_associations` - associations, written as Model.association, that should not
   be checked.
 
 ### Detecting Primary Keys Having Short Integer Types
@@ -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

@@ -13,8 +13,8 @@ module ActiveRecordDoctor
       class << self
         attr_reader :description
 
-        def run(config, io)
-          new(config, io).run
+        def run(*args, **kwargs, &block)
+          new(*args, **kwargs, &block).run
         end
 
         def underscored_name
@@ -38,23 +38,36 @@ module ActiveRecordDoctor
         end
       end
 
-      def initialize(config, io)
+      def initialize(config:, logger:, io:)
         @problems = []
         @config = config
+        @logger = logger
         @io = io
       end
 
       def run
-        @problems = []
+        log(underscored_name) do
+          @problems = []
 
-        detect if config(:enabled)
-        @problems.each do |problem|
-          @io.puts(message(**problem))
-        end
+          if config(:enabled)
+            detect
+          else
+            log("disabled; skipping")
+          end
 
-        success = @problems.empty?
-        @problems = nil
-        success
+          @problems.each do |problem|
+            @io.puts(message(**problem))
+          end
+
+          success = @problems.empty?
+          if success
+            log("No problems found")
+          else
+            log("Found #{@problems.count} problem(s)")
+          end
+          @problems = nil
+          success
+        end
       end
 
       private
@@ -79,7 +92,16 @@ module ActiveRecordDoctor
         raise("#message should be implemented by a subclass")
       end
 
+      def log(message, &block)
+        @logger.log(message, &block)
+      end
+
       def problem!(**attrs)
+        log("Problem found") do
+          attrs.each do |key, value|
+            log("#{key}: #{value.inspect}")
+          end
+        end
         @problems << attrs
       end
 
@@ -91,23 +113,8 @@ module ActiveRecordDoctor
         @connection ||= ActiveRecord::Base.connection
       end
 
-      def indexes(table_name, except: [])
-        connection.indexes(table_name).reject do |index|
-          except.include?(index.name)
-        end
-      end
-
-      def tables(except: [])
-        tables =
-          if ActiveRecord::VERSION::STRING >= "5.1"
-            connection.tables
-          else
-            connection.data_sources
-          end
-
-        tables.reject do |table|
-          except.include?(table)
-        end
+      def indexes(table_name)
+        connection.indexes(table_name)
       end
 
       def primary_key(table_name)
@@ -121,24 +128,6 @@ module ActiveRecordDoctor
         connection.columns(table_name).find { |column| column.name == column_name }
       end
 
-      def views
-        @views ||=
-          if connection.respond_to?(:views)
-            connection.views
-          elsif postgresql?
-            ActiveRecord::Base.connection.select_values(<<-SQL)
-              SELECT relname FROM pg_class WHERE relkind IN ('m', 'v')
-            SQL
-          elsif connection.adapter_name == "Mysql2"
-            ActiveRecord::Base.connection.select_values(<<-SQL)
-              SHOW FULL TABLES WHERE table_type = 'VIEW'
-            SQL
-          else
-            # We don't support this Rails/database combination yet.
-            []
-          end
-      end
-
       def not_null_check_constraint_exists?(table, column)
         check_constraints(table).any? do |definition|
           definition =~ /\A#{column.name} IS NOT NULL\z/i ||
@@ -150,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)
@@ -167,18 +156,170 @@ module ActiveRecordDoctor
         end
       end
 
-      def models(except: [])
-        ActiveRecord::Base.descendants.reject do |model|
-          model.name.start_with?("HABTM_") || except.include?(model.name)
-        end
+      def models
+        ActiveRecord::Base.descendants
       end
 
       def underscored_name
         self.class.underscored_name
       end
 
-      def postgresql?
-        ["PostgreSQL", "PostGIS"].include?(connection.adapter_name)
+      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)
+              log("#{model.name} - ignored via the configuration; skipping")
+            when abstract && !model.abstract_class?
+              log("#{model.name} - non-abstract model; skipping")
+            when abstract == false && model.abstract_class?
+              log("#{model.name} - abstract model; skipping")
+            when existing_tables_only && (model.table_name.nil? || !model.table_exists?)
+              log("#{model.name} - backed by a non-existent table #{model.table_name}; skipping")
+            else
+              log(model.name) do
+                yield(model)
+              end
+            end
+          end
+        end
+      end
+
+      def each_index(table_name, except: [], multicolumn_only: false)
+        indexes = connection.indexes(table_name)
+
+        message =
+          if multicolumn_only
+            "Iterating over multi-column indexes on #{table_name}"
+          else
+            "Iterating over indexes on #{table_name}"
+          end
+
+        log(message) do
+          indexes.each do |index|
+            case
+            when except.include?(index.name)
+              log("#{index.name} - ignored via the configuration; skipping")
+            when multicolumn_only && !index.columns.is_a?(Array)
+              log("#{index.name} - single-column index; skipping")
+            else
+              log("Index #{index.name} on #{table_name}") do
+                yield(index, indexes)
+              end
+            end
+          end
+        end
+      end
+
+      def each_attribute(model, except: [], type: nil)
+        log("Iterating over attributes of #{model.name}") do
+          connection.columns(model.table_name).each do |column|
+            case
+            when except.include?("#{model.name}.#{column.name}")
+              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")
+            else
+              log("#{model.name}.#{column.name}") do
+                yield(column)
+              end
+            end
+          end
+        end
+      end
+
+      def each_column(table_name, only: nil, except: [])
+        log("Iterating over columns of #{table_name}") do
+          connection.columns(table_name).each do |column|
+            case
+            when except.include?("#{table_name}.#{column.name}")
+              log("#{column.name} - ignored via the configuration; skipping")
+            when only.nil? || only.include?(column.name)
+              log(column.name.to_s) do
+                yield(column)
+              end
+            end
+          end
+        end
+      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|
+            log("#{foreign_key.name} - #{foreign_key.from_table}(#{foreign_key.options[:column]}) to #{foreign_key.to_table}(#{foreign_key.options[:primary_key]})") do # rubocop:disable Layout/LineLength
+              yield(foreign_key)
+            end
+          end
+        end
+      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|
+            case
+            when except.include?(table)
+              log("#{table} - ignored via the configuration; skipping")
+            else
+              log(table) do
+                yield(table)
+              end
+            end
+          end
+        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.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}")
+              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")
+            when through == false && association.is_a?(ActiveRecord::Reflection::ThroughReflection)
+              log("#{model.name}.#{association.name} - is a through association; skipping")
+            when has_scope && association.scope.nil?
+              log("#{model.name}.#{association.name} - doesn't have a scope; skipping")
+            when has_scope == false && association.scope
+              log("#{model.name}.#{association.name} - has a scope; skipping")
+            else
+              log("#{association.macro} :#{association.name}") do
+                yield(association)
+              end
+            end
+          end
+        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
 
@@ -33,35 +35,37 @@ module ActiveRecordDoctor
       end
 
       def subindexes_of_multi_column_indexes
-        tables(except: config(:ignore_tables)).each do |table|
-          indexes = indexes(table)
-
-          indexes.each do |index|
-            next if config(:ignore_indexes).include?(index.name)
-
-            replacement_indexes = indexes.select do |other_index|
-              index != other_index && replaceable_with?(index, other_index)
+        log(__method__) do
+          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)
+              end
+
+              if replacement_indexes.empty?
+                log("Found no replacement indexes; skipping")
+                next
+              end
+
+              problem!(
+                table: table,
+                extraneous_index: index.name,
+                replacement_indexes: replacement_indexes.map(&:name).sort
+              )
             end
-
-            next if replacement_indexes.empty?
-
-            problem!(
-              extraneous_index: index.name,
-              replacement_indexes: replacement_indexes.map(&:name).sort
-            )
           end
         end
       end
 
       def indexed_primary_keys
-        tables(except: config(:ignore_tables)).each do |table|
-          indexes(table).each do |index|
-            next if config(:ignore_indexes).include?(index.name)
-
-            primary_key = connection.primary_key(table)
-            next if index.columns != [primary_key] || index.where
-
-            problem!(extraneous_index: index.name, replacement_indexes: nil)
+        log(__method__) do
+          each_table(except: config(:ignore_tables)) do |table|
+            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!(table: table, extraneous_index: index.name, replacement_indexes: nil)
+              end
+            end
           end
         end
       end
@@ -72,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
 
@@ -87,12 +94,7 @@ module ActiveRecordDoctor
       end
 
       def prefix?(lhs, rhs)
-        lhs.columns.count <= rhs.columns.count &&
-          rhs.columns[0...lhs.columns.count] == lhs.columns
-      end
-
-      def indexes(table_name)
-        super.select { |index| index.columns.is_a?(Array) }
+        lhs.count <= rhs.count && rhs[0...lhs.count] == lhs
       end
     end
   end

data/lib/active_record_doctor/detectors/incorrect_boolean_presence_validation.rb

@@ -25,11 +25,8 @@ module ActiveRecordDoctor
       end
 
       def detect
-        models(except: config(:ignore_models)).each do |model|
-          next unless model.table_exists?
-
-          connection.columns(model.table_name).each do |column|
-            next if config(:ignore_attributes).include?("#{model.name}.#{column.name}")
+        each_model(except: config(:ignore_models), existing_tables_only: true) do |model|
+          each_attribute(model, except: config(:ignore_attributes)) do |column|
             next unless column.type == :boolean
             next unless has_presence_validator?(model, column)