active_record_doctor 1.8.0 → 1.9.0.rc1

data/lib/active_record_doctor/detectors/missing_non_null_constraint.rb

@@ -4,39 +4,51 @@ require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
   module Detectors
-    # Detect model-level presence validators on columns that lack a non-NULL constraint thus allowing potentially
-    # invalid insertions.
-    class MissingNonNullConstraint < Base
-      @description = "Detect presence validators not backed by a non-NULL constraint"
-
-      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.table_name,
-            connection.columns(model.table_name).select do |column|
-              validator_needed?(model, column) &&
-                has_mandatory_presence_validator?(model, column) &&
-                column.null
-            end.map(&:name)
-          ]
-        end.reject do |_model_name, columns|
-          columns.empty?
-        end))
-      end
+    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 validator_needed?(model, column)
-        ![model.primary_key, "created_at", "updated_at"].include?(column.name)
+      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 has_mandatory_presence_validator?(model, column)
+      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

data/lib/active_record_doctor/detectors/missing_presence_validation.rb

@@ -4,31 +4,38 @@ require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
   module Detectors
-    # Detect models with non-NULL columns that lack the corresponding model-level validator.
-    class MissingPresenceValidation < Base
-      @description = "Detect non-NULL columns without a presence validator"
+    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"
+        }
+      }
 
-      def run
-        eager_load!
+      private
 
-        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|
-              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) &&

data/lib/active_record_doctor/detectors/missing_unique_indexes.rb

@@ -4,39 +4,49 @@ require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
   module Detectors
-    # Detect columns covered by a uniqueness validation that lack the corresponding unique index thus risking duplicate
-    # inserts.
-    class MissingUniqueIndexes < Base
-      @description = "Detect columns covered by a uniqueness validator without a unique index"
-
-      def run
-        eager_load!
-
-        problems(hash_from_pairs(models.reject do |model|
-          model.table_name.nil?
-        end.map do |model|
-          [
-            model.table_name,
-            model.validators.select do |validator|
-              table_name = model.table_name
-              scope = validator.options.fetch(:scope, [])
-
-              validator.is_a?(ActiveRecord::Validations::UniquenessValidator) &&
-                supported_validator?(validator) &&
-                !unique_index?(table_name, validator.attributes, scope)
-            end.map do |validator|
-              scope = Array(validator.options.fetch(:scope, []))
-              attributes = validator.attributes
-              (scope + attributes).map(&:to_s)
-            end
-          ]
-        end.reject do |_table_name, indexes|
-          indexes.empty?
-        end))
-      end
+    class MissingUniqueIndexes < Base # :nodoc:
+      @description = "detect uniqueness validators not backed by a database constraint"
+      @config = {
+        ignore_models: {
+          description: "models whose uniqueness validators should not be checked",
+          global: true
+        },
+        ignore_columns: {
+          description: "specific validators, written as Model(column1, column2, ...), that should not be checked"
+        }
+      }
 
       private
 
+      def message(table:, columns:)
+        # rubocop:disable Layout/LineLength
+        "add a unique index on #{table}(#{columns.join(', ')}) - validating uniqueness in the model without an index can lead to duplicates"
+        # rubocop:enable Layout/LineLength
+      end
+
+      def detect
+        ignore_columns = config(:ignore_columns).map do |column|
+          column.gsub(" ", "")
+        end
+
+        models(except: config(:ignore_models)).each do |model|
+          next if model.table_name.nil?
+
+          model.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 unique_index?(model.table_name, validator.attributes, scope)
+
+            columns = (scope + validator.attributes).map(&:to_s)
+            next if ignore_columns.include?("#{model.name}(#{columns.join(',')})")
+
+            problem!(table: model.table_name, columns: columns)
+          end
+        end
+      end
+
       def supported_validator?(validator)
         validator.options[:if].nil? &&
           validator.options[:unless].nil? &&

data/lib/active_record_doctor/detectors/short_primary_key_type.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
+
+module ActiveRecordDoctor
+  module Detectors
+    class ShortPrimaryKeyType < Base # :nodoc:
+      @description = "detect primary keys with short integer types"
+      @config = {
+        ignore_tables: {
+          description: "tables whose primary keys should not be checked",
+          global: true
+        }
+      }
+
+      private
+
+      def message(table:, column:)
+        "change the type of #{table}.#{column} to bigint"
+      end
+
+      def detect
+        tables(except: config(:ignore_tables)).each do |table|
+          column = primary_key(table)
+          next if column.nil?
+          next if bigint?(column)
+
+          problem!(table: table, column: column.name)
+        end
+      end
+
+      def bigint?(column)
+        if column.respond_to?(:bigint?)
+          column.bigint?
+        else
+          /\Abigint\b/.match?(column.sql_type)
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/detectors/undefined_table_references.rb

@@ -4,30 +4,29 @@ require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
   module Detectors
-    # Find models referencing non-existent database tables or views.
-    class UndefinedTableReferences < Base
-      @description = "Detect models referencing undefined tables or views"
+    class UndefinedTableReferences < Base # :nodoc:
+      @description = "detect models referencing undefined tables or views"
+      @config = {
+        ignore_models: {
+          description: "models whose underlying tables should not be checked for existence",
+          global: true
+        }
+      }
 
-      def run
-        eager_load!
+      private
 
-        # If we can't list views due to old Rails version or unsupported
-        # database then existing_views is nil. We inform the caller we haven't
-        # consulted views so that it can display an appropriate warning.
-        existing_views = views
+      def message(model:, table:)
+        "#{model} references a non-existent table or view named #{table}"
+      end
 
-        offending_models = models.select do |model|
-          model.table_name.present? &&
-            !tables.include?(model.table_name) &&
-            (
-              existing_views.nil? ||
-                !existing_views.include?(model.table_name)
-            )
-        end.map do |model|
-          [model.name, model.table_name]
-        end
+      def detect
+        models(except: config(:ignore_models)).each do |model|
+          next if model.table_name.nil?
+          next if tables.include?(model.table_name)
+          next if tables_and_views.include?(model.table_name)
 
-        problems(offending_models, views_checked: !existing_views.nil?)
+          problem!(model: model.name, table: model.table_name)
+        end
       end
     end
   end

data/lib/active_record_doctor/detectors/unindexed_deleted_at.rb

@@ -4,25 +4,51 @@ require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
   module Detectors
-    # Find unindexed deleted_at columns.
-    class UnindexedDeletedAt < Base
-      PATTERN = [
-        "deleted_at",
-        "discarded_at"
-      ].join("|").freeze
-
-      @description = "Detect unindexed deleted_at columns"
-
-      def run
-        problems(connection.tables.select do |table|
-          connection.columns(table).any? { |column| column.name =~ /^#{PATTERN}$/ }
-        end.flat_map do |table|
-          connection.indexes(table).reject do |index|
-            index.where =~ /\b#{PATTERN}\s+IS\s+NULL\b/i
-          end.map do |index|
-            index.name
+    class UnindexedDeletedAt < Base # :nodoc:
+      @description = "detect indexes that exclude deletion timestamp columns"
+      @config = {
+        ignore_tables: {
+          description: "tables whose indexes should not be checked",
+          global: true
+        },
+        ignore_columns: {
+          description: "specific columns, written as table.column, that should not be reported as unindexed"
+        },
+        ignore_indexes: {
+          description: "specific indexes that should not be reported as excluding a timestamp column"
+        },
+        column_names: {
+          description: "deletion timestamp column names"
+        }
+      }
+
+      private
+
+      def message(index:, column_name:)
+        # rubocop:disable Layout/LineLength
+        "consider adding `WHERE #{column_name} IS NULL` to #{index} - a partial index can speed lookups of soft-deletable models"
+        # rubocop:enable Layout/LineLength
+      end
+
+      def detect
+        tables(except: config(:ignore_tables)).each do |table|
+          timestamp_columns = connection.columns(table).reject do |column|
+            config(:ignore_columns).include?("#{table}.#{column.name}")
+          end.select do |column|
+            config(:column_names).include?(column.name)
+          end
+
+          next if timestamp_columns.empty?
+
+          timestamp_columns.each do |timestamp_column|
+            indexes(table, except: config(:ignore_indexes)).each do |index|
+              # TODO: whole word
+              next if index.where =~ /\b#{timestamp_column.name}\s+IS\s+NULL\b/i
+
+              problem!(index: index.name, column_name: timestamp_column.name)
+            end
           end
-        end)
+        end
       end
     end
   end

data/lib/active_record_doctor/detectors/unindexed_foreign_keys.rb

@@ -4,29 +4,40 @@ require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
   module Detectors
-    # Find foreign keys that lack indexes (usually recommended for performance reasons).
-    class UnindexedForeignKeys < Base
-      @description = "Detect foreign keys without an index on them"
-
-      def run
-        problems(hash_from_pairs(tables.reject do |table|
-          table == "schema_migrations"
-        end.map do |table|
-          [
-            table,
-            connection.columns(table).select do |column|
-              foreign_key?(column) &&
-                !indexed?(table, column) &&
-                !indexed_as_polymorphic?(table, column)
-            end.map(&:name)
-          ]
-        end.reject do |_table, columns|
-          columns.empty?
-        end))
-      end
+    class UnindexedForeignKeys < Base # :nodoc:
+      @description = "detect unindexed foreign keys"
+      @config = {
+        ignore_tables: {
+          description: "tables whose foreign keys should not be checked",
+          global: true
+        },
+        ignore_columns: {
+          description: "columns, written as table.column, that should not be checked"
+        }
+      }
 
       private
 
+      def message(table:, column:)
+        # 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"
+        # rubocop:enable Layout/LineLength
+      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}")
+
+            next unless foreign_key?(column)
+            next if indexed?(table, column)
+            next if indexed_as_polymorphic?(table, column)
+
+            problem!(table: table, column: column.name)
+          end
+        end
+      end
+
       def foreign_key?(column)
         column.name.end_with?("_id")
       end

data/lib/active_record_doctor/detectors.rb

@@ -3,11 +3,19 @@
 require "active_support"
 require "active_support/core_ext/class/subclasses"
 
-module ActiveRecordDoctor
+module ActiveRecordDoctor # :nodoc:
+  def self.detectors
+    @detectors ||=
+      begin
+        detectors = {}
+        ActiveRecordDoctor::Detectors::Base.subclasses.each do |detector|
+          detectors[detector.underscored_name] = detector
+        end
+        detectors
+      end
+  end
+
   # Container module for all detectors, implemented as separate classes.
   module Detectors
-    def self.all
-      ActiveRecordDoctor::Detectors::Base.subclasses
-    end
   end
 end