active_record_doctor 1.7.0 → 1.9.0.rc1

data/lib/active_record_doctor/detectors/base.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module ActiveRecordDoctor
+  module Detectors
+    # Base class for all active_record_doctor detectors.
+    class Base
+      class << self
+        attr_reader :description, :config
+
+        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 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, 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
+      end
+
+      def 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
+        @views ||=
+          if connection.respond_to?(:views)
+            connection.views
+          elsif connection.adapter_name == "PostgreSQL"
+            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
+            # We don't support this Rails/database combination yet.
+            nil
+          end
+      end
+
+      def models(except: [])
+        ActiveRecord::Base.descendants.reject do |model|
+          model.name.start_with?("HABTM_") || except.include?(model.name)
+        end
+      end
+
+      def underscored_name
+        self.class.underscored_name
+      end
+    end
+  end
+end

data/lib/active_record_doctor/detectors/extraneous_indexes.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    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
+        }
+      }
+
+      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
+
+      def detect
+        subindexes_of_multi_column_indexes
+        indexed_primary_keys
+      end
+
+      def subindexes_of_multi_column_indexes
+        tables(except: config(:ignore_tables)).each do |table|
+          indexes = indexes(table)
+          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)
+
+            problem!(extraneous_index: index.name, replacement_indexes: replacement_indexes)
+          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)
+            next if index.columns != ["id"]
+
+            problem!(extraneous_index: index.name, replacement_indexes: nil)
+          end
+        end
+      end
+
+      def maximal?(indexes, index)
+        indexes.all? do |another_index|
+          index == another_index || !cover?(another_index, index)
+        end
+      end
+
+      # 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
+        when [false, true]
+          false
+        else
+          prefix?(rhs, lhs)
+        end
+      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) }
+      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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    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)
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/detectors/incorrect_dependent_option.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    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"
+        }
+      }
+
+      private
+
+      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
+
+      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)
+
+          associations.each do |association|
+            next if config(:ignore_associations).include?("#{model.name}.#{association.name}")
+
+            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
+      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|
+            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
+        # being deleted then theoretically we can't use :delete_all. It's a bit
+        # of an edge case as they usually are either absent or have no side
+        # effects but we're being pedantic -- they could be used for audit
+        # trial, for instance, and we don't want to skip that.
+        model._initialize_callbacks.present? ||
+          model._find_callbacks.present? ||
+          model._destroy_callbacks.present? ||
+          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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    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
+
+      def foreign_key?(table, column)
+        connection.foreign_keys(table).any? do |foreign_key|
+          foreign_key.options[:column] == column.name
+        end
+      end
+
+      def polymorphic_foreign_key?(table, column)
+        type_column_name = column.name.sub(/_id\Z/, "_type")
+        connection.columns(table).any? do |another_column|
+          another_column.name == type_column_name
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/detectors/missing_non_null_constraint.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    class MissingNonNullConstraint < Base # :nodoc:
+      @description = "detect columns whose presence is always validated but isn't enforced via a non-NULL 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(column:, table:)
+        "add `NOT NULL` to #{table}.#{column} - models validates its presence but it's not non-NULL in the database"
+      end
+
+      def detect
+        table_models = models.group_by(&:table_name)
+        table_models.delete_if { |table| table.nil? || !table_exists?(table) }
+
+        table_models.each do |table, models|
+          next if config(:ignore_tables).include?(table)
+
+          concrete_models = models.reject do |model|
+            model.abstract_class? || sti_base_model?(model)
+          end
+
+          connection.columns(table).each do |column|
+            next if config(:ignore_columns).include?("#{table}.#{column.name}")
+            next if !column.null
+            next if !concrete_models.all? { |model| non_null_needed?(model, column) }
+
+            problem!(column: column.name, table: table)
+          end
+        end
+      end
+
+      def sti_base_model?(model)
+        model.base_class == model &&
+          model.columns_hash.include?(model.inheritance_column.to_s)
+      end
+
+      def non_null_needed?(model, column)
+        # A foreign key can be validates via the column name (e.g. company_id)
+        # or the association name (e.g. company). We collect the allowed names
+        # in an array to check for their presence in the validator definition
+        # in one go.
+        attribute_name_forms = [column.name.to_sym]
+        belongs_to = model.reflect_on_all_associations(:belongs_to).find do |reflection|
+          reflection.foreign_key == column.name
+        end
+        attribute_name_forms << belongs_to.name.to_sym if belongs_to
+
+        model.validators.any? do |validator|
+          validator.is_a?(ActiveRecord::Validations::PresenceValidator) &&
+            (validator.attributes & attribute_name_forms).present? &&
+            !validator.options[:allow_nil] &&
+            !validator.options[:if] &&
+            !validator.options[:unless]
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/{tasks → detectors}/missing_presence_validation.rb

@@ -1,30 +1,44 @@
-require "active_record_doctor/tasks/base"
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
-  module Tasks
-    class MissingPresenceValidation < Base
-      def run
-        eager_load!
+  module Detectors
+    class MissingPresenceValidation < Base # :nodoc:
+      @description = "detect non-NULL columns without a corresponding presence validator"
+      @config = {
+        ignore_models: {
+          description: "models whose underlying tables' columns should not be checked",
+          global: true
+        },
+        ignore_attributes: {
+          description: "specific attributes, written as Model.attribute, that should not be checked"
+        }
+      }
+
+      private
 
-        success(hash_from_pairs(models.reject do |model|
-          model.table_name.nil? || model.table_name == 'schema_migrations'
-        end.map do |model|
-          [
-            model.name,
-            connection.columns(model.table_name).select do |column|
-              validator_needed?(model, column) &&
-                !validator_present?(model, column)
-            end.map(&:name)
-          ]
-        end.reject do |model_name, columns|
-          columns.empty?
-        end))
+      def message(column:, model:)
+        "add a `presence` validator to #{model}.#{column} - it's NOT NULL but lacks a validator"
       end
 
-      private
+      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 unless validator_needed?(model, column)
+            next if validator_present?(model, column)
+            next if config(:ignore_attributes).include?("#{model}.#{column.name}")
+
+            problem!(column: column.name, model: model.name)
+          end
+        end
+      end
 
       def validator_needed?(model, column)
-        ![model.primary_key, 'created_at', 'updated_at'].include?(column.name) &&
+        ![model.primary_key, "created_at", "updated_at"].include?(column.name) &&
           !column.null
       end
 
@@ -49,7 +63,7 @@ module ActiveRecordDoctor
         model.validators.any? do |validator|
           validator.is_a?(ActiveModel::Validations::ExclusionValidator) &&
             validator.attributes.include?(column.name.to_sym) &&
-              validator.options.fetch(:in, []).include?(nil)
+            validator.options.fetch(:in, []).include?(nil)
         end
       end