active_record_doctor 1.8.0 → 1.9.0.rc1

data/lib/active_record_doctor/detectors/base.rb

@@ -5,33 +5,126 @@ module ActiveRecordDoctor
     # Base class for all active_record_doctor detectors.
     class Base
       class << self
-        attr_reader :description
+        attr_reader :description, :config
 
-        def run
-          new.run
+        def run(config, io)
+          new(config, io).run
         end
+
+        def underscored_name
+          name.demodulize.underscore.to_sym
+        end
+
+        def locals_and_globals
+          locals = []
+          globals = []
+
+          config.each do |key, metadata|
+            locals << key
+            globals << key if metadata[:global]
+          end
+
+          [locals, globals]
+        end
+      end
+
+      def initialize(config, io)
+        @problems = []
+        @config = config
+        @io = io
+      end
+
+      def run
+        @problems = []
+
+        detect
+        @problems.each do |problem|
+          @io.puts(message(**problem))
+        end
+
+        success = @problems.empty?
+        @problems = nil
+        success
       end
 
       private
 
-      def problems(problems, options = {})
-        [problems, options]
+      def config(key)
+        local = @config.detectors.fetch(underscored_name).fetch(key)
+        return local if !self.class.config.fetch(key)[:global]
+
+        global = @config.globals[key]
+        return local if global.nil?
+
+        # Right now, all globals are arrays so we can merge them here. Once
+        # we add non-array globals we'll need to support per-global merging.
+        Array.new(local).concat(global)
+      end
+
+      def detect
+        raise("#detect should be implemented by a subclass")
+      end
+
+      def message(**_attrs)
+        raise("#message should be implemented by a subclass")
+      end
+
+      def problem!(**attrs)
+        @problems << attrs
+      end
+
+      def warning(message)
+        puts(message)
       end
 
       def connection
         @connection ||= ActiveRecord::Base.connection
       end
 
-      def indexes(table_name)
-        connection.indexes(table_name)
+      def indexes(table_name, except: [])
+        connection.indexes(table_name).reject do |index|
+          except.include?(index.name)
+        end
       end
 
-      def tables
-        connection.tables
+      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
       end
 
       def table_exists?(table_name)
-        connection.table_exists?(table_name)
+        if ActiveRecord::VERSION::STRING >= "5.1"
+          connection.table_exists?(table_name)
+        else
+          connection.data_source_exists?(table_name)
+        end
+      end
+
+      def tables_and_views
+        if connection.respond_to?(:data_sources)
+          connection.data_sources
+        else
+          connection.tables
+        end
+      end
+
+      def primary_key(table_name)
+        primary_key_name = connection.primary_key(table_name)
+        return nil if primary_key_name.nil?
+
+        column(table_name, primary_key_name)
+      end
+
+      def column(table_name, column_name)
+        connection.columns(table_name).find { |column| column.name == column_name }
       end
 
       def views
@@ -42,22 +135,20 @@ module ActiveRecordDoctor
             ActiveRecord::Base.connection.execute(<<-SQL).map { |tuple| tuple.fetch("relname") }
               SELECT c.relname FROM pg_class c WHERE c.relkind IN ('m', 'v')
             SQL
-          else # rubocop:disable Style/EmptyElse
+          else
             # We don't support this Rails/database combination yet.
             nil
           end
       end
 
-      def hash_from_pairs(pairs)
-        Hash[*pairs.flatten(1)]
-      end
-
-      def eager_load!
-        Rails.application.eager_load!
+      def models(except: [])
+        ActiveRecord::Base.descendants.reject do |model|
+          model.name.start_with?("HABTM_") || except.include?(model.name)
+        end
       end
 
-      def models
-        ActiveRecord::Base.descendants
+      def underscored_name
+        self.class.underscored_name
       end
     end
   end

data/lib/active_record_doctor/detectors/extraneous_indexes.rb

@@ -4,55 +4,60 @@ require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
   module Detectors
-    # Detect indexes whose function can be overtaken by other indexes. For example, an index on columns A, B, and C
-    # can also serve as an index on A and A, B.
-    class ExtraneousIndexes < Base
-      @description = "Detect extraneous indexes"
+    class ExtraneousIndexes < Base # :nodoc:
+      @description = "identify indexes that can be dropped without degrading performance"
+      @config = {
+        ignore_tables: {
+          description: "tables whose indexes should never be reported as extraneous",
+          global: true
+        },
+        ignore_indexes: {
+          description: "indexes that should never be reported as extraneous",
+          global: true
+        }
+      }
 
-      def run
-        problems(subindexes_of_multi_column_indexes + indexed_primary_keys)
+      private
+
+      def message(extraneous_index:, replacement_indexes:)
+        if replacement_indexes.nil?
+          "remove #{extraneous_index} - coincides with the primary key on the table"
+        else
+          "remove #{extraneous_index} - can be replaced by #{replacement_indexes.join(' or ')}"
+        end
       end
 
-      private
+      def detect
+        subindexes_of_multi_column_indexes
+        indexed_primary_keys
+      end
 
       def subindexes_of_multi_column_indexes
-        tables.reject do |table|
-          table == "schema_migrations"
-        end.flat_map do |table|
+        tables(except: config(:ignore_tables)).each do |table|
           indexes = indexes(table)
-          maximum_indexes = indexes.select do |index|
-            maximal?(indexes, index)
-          end
+          maximal_indexes = indexes.select { |index| maximal?(indexes, index) }
+
+          indexes.each do |index|
+            next if maximal_indexes.include?(index)
+
+            replacement_indexes = maximal_indexes.select do |maximum_index|
+              cover?(maximum_index, index)
+            end.map(&:name).sort
+
+            next if config(:ignore_indexes).include?(index.name)
 
-          indexes.reject do |index|
-            maximum_indexes.include?(index)
-          end.map do |extraneous_index|
-            [
-              extraneous_index.name,
-              [
-                :multi_column,
-                maximum_indexes.select do |maximum_index|
-                  cover?(maximum_index, extraneous_index)
-                end.map(&:name).sort
-              ].flatten(1)
-            ]
+            problem!(extraneous_index: index.name, replacement_indexes: replacement_indexes)
           end
         end
       end
 
       def indexed_primary_keys
-        @indexed_primary_keys ||= tables.reject do |table|
-          table == "schema_migrations"
-        end.map do |table|
-          [
-            table,
-            indexes(table).select do |index|
-              index.columns == ["id"]
-            end
-          ]
-        end.flat_map do |table, indexes|
-          indexes.map do |index|
-            [index.name, [:primary_key, table]]
+        tables(except: config(:ignore_tables)).each do |table|
+          indexes(table).each do |index|
+            next if config(:ignore_indexes).include?(index.name)
+            next if index.columns != ["id"]
+
+            problem!(extraneous_index: index.name, replacement_indexes: nil)
           end
         end
       end
@@ -65,6 +70,8 @@ module ActiveRecordDoctor
 
       # Does lhs cover rhs?
       def cover?(lhs, rhs)
+        return false unless compatible_options?(lhs, rhs)
+
         case [lhs.unique, rhs.unique]
         when [true, true]
           lhs.columns == rhs.columns
@@ -83,6 +90,25 @@ module ActiveRecordDoctor
       def indexes(table_name)
         super.select { |index| index.columns.is_a?(Array) }
       end
+
+      def compatible_options?(lhs, rhs)
+        lhs.type == rhs.type &&
+          lhs.using == rhs.using &&
+          lhs.where == rhs.where &&
+          same_opclasses?(lhs, rhs)
+      end
+
+      def same_opclasses?(lhs, rhs)
+        if ActiveRecord::VERSION::STRING >= "5.2"
+          rhs.columns.all? do |column|
+            lhs_opclass = lhs.opclasses.is_a?(Hash) ? lhs.opclasses[column] : lhs.opclasses
+            rhs_opclass = rhs.opclasses.is_a?(Hash) ? rhs.opclasses[column] : rhs.opclasses
+            lhs_opclass == rhs_opclass
+          end
+        else
+          true
+        end
+      end
     end
   end
 end

data/lib/active_record_doctor/detectors/incorrect_boolean_presence_validation.rb

@@ -4,32 +4,41 @@ require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
   module Detectors
-    # Find instances of boolean column presence validations that use presence/absence instead of includes/excludes.
-    class IncorrectBooleanPresenceValidation < Base
-      @description = "Detect boolean columns with presence/absence instead of includes/excludes validators"
-
-      def run
-        eager_load!
-
-        problems(hash_from_pairs(models.reject do |model|
-          model.table_name.nil? ||
-            model.table_name == "schema_migrations" ||
-            !table_exists?(model.table_name)
-        end.map do |model|
-          [
-            model.name,
-            connection.columns(model.table_name).select do |column|
-              column.type == :boolean &&
-                has_presence_validator?(model, column)
-            end.map(&:name)
-          ]
-        end.reject do |_model_name, columns|
-          columns.empty?
-        end))
-      end
+    class IncorrectBooleanPresenceValidation < Base # :nodoc:
+      @description = "detect persence (instead of inclusion) validators on boolean columns"
+      @config = {
+        ignore_models: {
+          description: "models whose validators should not be checked",
+          global: true
+        },
+        ignore_attributes: {
+          description: "attributes, written as Model.attribute, whose validators should not be checked"
+        }
+      }
 
       private
 
+      def message(model:, attribute:)
+        # rubocop:disable Layout/LineLength
+        "replace the `presence` validator on #{model}.#{attribute} with `inclusion` - `presence` can't be used on booleans"
+        # rubocop:enable Layout/LineLength
+      end
+
+      def detect
+        models(except: config(:ignore_models)).each do |model|
+          next if model.table_name.nil?
+          next unless table_exists?(model.table_name)
+
+          connection.columns(model.table_name).each do |column|
+            next if config(:ignore_attributes).include?("#{model.name}.#{column.name}")
+            next unless column.type == :boolean
+            next unless has_presence_validator?(model, column)
+
+            problem!(model: model.name, attribute: column.name)
+          end
+        end
+      end
+
       def has_presence_validator?(model, column)
         model.validators.any? do |validator|
           validator.kind == :presence && validator.attributes.include?(column.name.to_sym)

data/lib/active_record_doctor/detectors/incorrect_dependent_option.rb

@@ -4,55 +4,79 @@ require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
   module Detectors
-    # Find has_many/has_one associations with dependent options not taking the
-    # related model's callbacks into account.
-    class IncorrectDependentOption < Base
-      # rubocop:disable Layout/LineLength
-      @description = "Detect associations that should use a different dependent option based on callbacks on the related model"
-      # rubocop:enable Layout/LineLength
+    class IncorrectDependentOption < Base # :nodoc:
+      @description = "detect associations with incorrect dependent options"
+      @config = {
+        ignore_models: {
+          description: "models whose associations should not be checked",
+          global: true
+        },
+        ignore_associations: {
+          description: "associations, written as Model.association, that should not be checked"
+        }
+      }
 
-      def run
-        eager_load!
+      private
 
-        problems(hash_from_pairs(models.reject do |model|
-          model.table_name.nil?
-        end.map do |model|
-          [
-            model.name,
-            associations_with_incorrect_dependent_options(model)
-          ]
-        end.reject do |_model_name, associations|
-          associations.empty?
-        end))
+      def message(model:, association:, problem:)
+        # rubocop:disable Layout/LineLength
+        case problem
+        when :suggest_destroy
+          "use `dependent: :destroy` or similar on #{model}.#{association} - the associated model has callbacks that are currently skipped"
+        when :suggest_delete
+          "use `dependent: :delete` or similar on #{model}.#{association} - the associated model has no callbacks and can be deleted without loading"
+        when :suggest_delete_all
+          "use `dependent: :delete_all` or similar on #{model}.#{association} - associated models have no validations and can be deleted in bulk"
+        end
+        # rubocop:enable Layout/LineLength
       end
 
-      private
+      def detect
+        models(except: config(:ignore_models)).each do |model|
+          next if model.table_name.nil?
+
+          associations = model.reflect_on_all_associations(:has_many) +
+                         model.reflect_on_all_associations(:has_one) +
+                         model.reflect_on_all_associations(:belongs_to)
 
-      def associations_with_incorrect_dependent_options(model)
-        reflections = model.reflect_on_all_associations(:has_many) + model.reflect_on_all_associations(:has_one)
-        reflections.map do |reflection|
-          if callback_action(reflection) == :invoke && !defines_destroy_callbacks?(reflection.klass)
-            suggestion =
-              case reflection.macro
-              when :has_many then :suggest_delete_all
-              when :has_one then :suggest_delete
-              else raise("unsupported association type #{reflection.macro}")
-              end
+          associations.each do |association|
+            next if config(:ignore_associations).include?("#{model.name}.#{association.name}")
 
-            [reflection.name, suggestion]
-          elsif callback_action(reflection) == :skip && defines_destroy_callbacks?(reflection.klass)
-            [reflection.name, :suggest_destroy]
+            if callback_action(association) == :invoke && deletable?(association.klass)
+              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)
+            elsif callback_action(association) == :skip && !deletable?(association.klass)
+              problem!(model: model.name, association: association.name, problem: :suggest_destroy)
+            end
           end
-        end.compact
+        end
       end
 
       def callback_action(reflection)
         case reflection.options[:dependent]
-        when :delete_all then :skip
+        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|
+            foreign_key = foreign_key(dependent_model.table_name, model.table_name)
+
+            foreign_key.nil? ||
+              foreign_key.on_delete == :nullify || (
+                foreign_key.on_delete == :cascade && deletable?(dependent_model)
+              )
+          end
+      end
+
       def defines_destroy_callbacks?(model)
         # Destroying an associated model involves loading it first hence
         # initialize and find are present. If they are defined on the model
@@ -66,6 +90,18 @@ module ActiveRecordDoctor
           model._commit_callbacks.present? ||
           model._rollback_callbacks.present?
       end
+
+      def dependent_models(model)
+        reflections = model.reflect_on_all_associations(:has_many) +
+                      model.reflect_on_all_associations(:has_one)
+        reflections.map(&:klass)
+      end
+
+      def foreign_key(from_table, to_table)
+        connection.foreign_keys(from_table).find do |foreign_key|
+          foreign_key.to_table == to_table
+        end
+      end
     end
   end
 end

data/lib/active_record_doctor/detectors/mismatched_foreign_key_type.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    class MismatchedForeignKeyType < Base # :nodoc:
+      @description = "detect foreign key type mismatches"
+      @config = {
+        ignore_tables: {
+          description: "tables whose foreign keys should not be checked",
+          global: true
+        },
+        ignore_columns: {
+          description: "foreign keys, written as table.column, that should not be checked"
+        }
+      }
+
+      private
+
+      def message(table:, column:)
+        # rubocop:disable Layout/LineLength
+        "#{table}.#{column} references a column of different type - foreign keys should be of the same type as the referenced column"
+        # rubocop:enable Layout/LineLength
+      end
+
+      def detect
+        tables(except: config(:ignore_tables)).each do |table|
+          connection.foreign_keys(table).each do |foreign_key|
+            from_column = column(table, foreign_key.column)
+
+            next if config(:ignore_columns).include?("#{table}.#{from_column.name}")
+
+            to_table = foreign_key.to_table
+            primary_key = primary_key(to_table)
+
+            next if from_column.sql_type == primary_key.sql_type
+
+            problem!(table: table, column: from_column.name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/detectors/missing_foreign_keys.rb

@@ -4,32 +4,41 @@ require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
   module Detectors
-    # Find foreign-key like columns lacking an actual foreign key constraint.
-    class MissingForeignKeys < Base
-      @description = "Detect association columns without a foreign key constraint"
-
-      def run
-        problems(hash_from_pairs(tables.reject do |table|
-          table == "schema_migrations"
-        end.map do |table|
-          [
-            table,
-            connection.columns(table).select do |column|
-              # We need to skip polymorphic associations as they can reference
-              # multiple tables but a foreign key constraint can reference
-              # a single predefined table.
-              named_like_foreign_key?(column) &&
-                !foreign_key?(table, column) &&
-                !polymorphic_foreign_key?(table, column)
-            end.map(&:name)
-          ]
-        end.reject do |_table, columns|
-          columns.empty?
-        end))
-      end
+    class MissingForeignKeys < Base # :nodoc:
+      @description = "detect foreign-key-like columns lacking an actual foreign key constraint"
+      @config = {
+        ignore_tables: {
+          description: "tables whose columns should not be checked",
+          global: true
+        },
+        ignore_columns: {
+          description: "columns, written as table.column, that should not be checked"
+        }
+      }
 
       private
 
+      def message(table:, column:)
+        "create a foreign key on #{table}.#{column} - looks like an association without a foreign key constraint"
+      end
+
+      def detect
+        tables(except: config(:ignore_tables)).each do |table|
+          connection.columns(table).each do |column|
+            next if config(:ignore_columns).include?("#{table}.#{column.name}")
+
+            # We need to skip polymorphic associations as they can reference
+            # multiple tables but a foreign key constraint can reference
+            # a single predefined table.
+            next unless named_like_foreign_key?(column)
+            next if foreign_key?(table, column)
+            next if polymorphic_foreign_key?(table, column)
+
+            problem!(table: table, column: column.name)
+          end
+        end
+      end
+
       def named_like_foreign_key?(column)
         column.name.end_with?("_id")
       end