active_record_doctor 1.8.0 → 1.10.0

data/lib/active_record_doctor/config/loader.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module ActiveRecordDoctor # :nodoc:
+  class << self
+    # The config file that's currently being processed by .load_config.
+    attr_reader :current_config
+
+    # This method is part of the public API that is intended for use by
+    # active_record_doctor users. The remaining methods are considered to be
+    # public-not-published.
+    def configure(&block)
+      # If current_config is set it means that .configure was already called
+      # so we must raise an error.
+      raise ActiveRecordDoctor::Error::ConfigureCalledTwice if current_config
+
+      # Determine the recognized global and detector settings based on detector
+      # metadata. recognizedd_detectors maps detector names to setting names.
+      # recognized_globals contains global setting names.
+      recognized_detectors = {}
+      recognized_globals = []
+
+      ActiveRecordDoctor.detectors.each do |name, detector|
+        locals, globals = detector.locals_and_globals
+
+        recognized_detectors[name] = locals
+        recognized_globals.concat(globals)
+      end
+
+      # The same global can be used by multiple detectors so we must remove
+      # duplicates to ensure they aren't reported mutliple times via the user
+      # interface (e.g. in error messages).
+      recognized_globals.uniq!
+
+      # Prepare an empty configuration and call the loader. After .new returns
+      # @current_config will contain the configuration provided by the block.
+      @current_config = Config.new({}, {})
+      Loader.new(current_config, recognized_globals, recognized_detectors, &block)
+
+      # This method is part of the public API expected to be called by users.
+      # In order to avoid leaking internal objects, we return an explicit nil.
+      nil
+    end
+
+    def load_config(path)
+      begin
+        load(path)
+      rescue ActiveRecordDoctor::Error
+        raise
+      rescue LoadError
+        raise ActiveRecordDoctor::Error::ConfigurationFileMissing
+      rescue StandardError => e
+        raise ActiveRecordDoctor::Error::ConfigurationError[e]
+      end
+      raise ActiveRecordDoctor::Error::ConfigureNotCalled if current_config.nil?
+
+      # Store the configuration and reset @current_config. We cannot reset
+      # @current_config in .configure because that would prevent us from
+      # detecting multiple calls to that method.
+      config = @current_config
+      @current_config = nil
+
+      config
+    rescue ActiveRecordDoctor::Error => e
+      e.config_path = path
+      raise e
+    end
+
+    DEFAULT_CONFIG_PATH = File.join(__dir__, "default.rb").freeze
+    private_constant :DEFAULT_CONFIG_PATH
+
+    def load_config_with_defaults(path)
+      default_config = load_config(DEFAULT_CONFIG_PATH)
+      return default_config if path.nil?
+
+      config = load_config(path)
+      default_config.merge(config)
+    end
+  end
+
+  # A class used for loading user-provided configuration files.
+  class Loader
+    def initialize(config, recognized_globals, recognized_detectors, &block)
+      @config = config
+      @recognized_globals = recognized_globals
+      @recognized_detectors = recognized_detectors
+      instance_eval(&block)
+    end
+
+    def global(name, value)
+      name = name.to_sym
+
+      unless recognized_globals.include?(name)
+        raise ActiveRecordDoctor::Error::UnrecognizedGlobalSetting[
+          name,
+          recognized_globals
+        ]
+      end
+
+      if config.globals.include?(name)
+        raise ActiveRecordDoctor::Error::DuplicateGlobalSetting[name]
+      end
+
+      config.globals[name] = value
+    end
+
+    def detector(name, settings)
+      name = name.to_sym
+
+      recognized_settings = recognized_detectors[name]
+      if recognized_settings.nil?
+        raise ActiveRecordDoctor::Error::UnrecognizedDetectorName[
+          name,
+          recognized_detectors.keys
+        ]
+      end
+
+      if config.detectors.include?(name)
+        raise ActiveRecordDoctor::Error::DetectorConfiguredTwice[name]
+      end
+
+      unrecognized_settings = settings.keys - recognized_settings
+      unless unrecognized_settings.empty?
+        raise ActiveRecordDoctor::Error::UnrecognizedDetectorSettings[
+          name,
+          unrecognized_settings,
+          recognized_settings
+        ]
+      end
+
+      config.detectors[name] = settings
+    end
+
+    private
+
+    attr_reader :config, :recognized_globals, :recognized_detectors
+  end
+end

data/lib/active_record_doctor/config.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ActiveRecordDoctor # :nodoc:
+  Config = Struct.new(:globals, :detectors) do
+    def merge(config)
+      globals = self.globals.merge(config.globals)
+      detectors = self.detectors.merge(config.detectors) do |_name, self_settings, config_settings|
+        self_settings.merge(config_settings)
+      end
+
+      Config.new(globals, detectors)
+    end
+  end
+end

data/lib/active_record_doctor/detectors/base.rb

@@ -4,60 +4,181 @@ module ActiveRecordDoctor
   module Detectors
     # Base class for all active_record_doctor detectors.
     class Base
+      BASE_CONFIG = {
+        enabled: {
+          description: "set to false to disable the detector altogether"
+        }
+      }.freeze
+
       class << self
         attr_reader :description
 
-        def run
-          new.run
+        def run(config, io)
+          new(config, io).run
+        end
+
+        def underscored_name
+          name.demodulize.underscore.to_sym
+        end
+
+        def config
+          @config.merge(BASE_CONFIG)
+        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 if config(:enabled)
+        @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(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 tables
-        connection.tables
+      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 table_exists?(table_name)
-        connection.table_exists?(table_name)
+      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')
+          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 # 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)]
+      def not_null_check_constraint_exists?(table, column)
+        check_constraints(table).any? do |definition|
+          definition =~ /\A#{column.name} IS NOT NULL\z/i ||
+            definition =~ /\A#{connection.quote_column_name(column.name)} IS NOT NULL\z/i
+        end
+      end
+
+      def check_constraints(table_name)
+        # 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?
+          definitions =
+            connection.select_values(<<-SQL)
+              SELECT pg_get_constraintdef(oid, true)
+              FROM pg_constraint
+              WHERE contype = 'c'
+                AND convalidated
+                AND conrelid = #{connection.quote(table_name)}::regclass
+            SQL
+
+          definitions.map { |definition| definition[/CHECK \((.+)\)/m, 1] }
+        else
+          # We don't support this Rails/database combination yet.
+          []
+        end
+      end
+
+      def models(except: [])
+        ActiveRecord::Base.descendants.reject do |model|
+          model.name.start_with?("HABTM_") || except.include?(model.name)
+        end
       end
 
-      def eager_load!
-        Rails.application.eager_load!
+      def underscored_name
+        self.class.underscored_name
       end
 
-      def models
-        ActiveRecord::Base.descendants
+      def postgresql?
+        ["PostgreSQL", "PostGIS"].include?(connection.adapter_name)
       end
     end
   end

data/lib/active_record_doctor/detectors/extraneous_indexes.rb

@@ -4,77 +4,88 @@ 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
 
-          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)
-            ]
+          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)
+            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
-        @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)
+
+            primary_key = connection.primary_key(table)
+            next if index.columns != [primary_key] || index.where
+
+            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
+      def replaceable_with?(index1, index2)
+        return false if index1.type != index2.type
+        return false if index1.using != index2.using
+        return false if index1.where != index2.where
+        return false if opclasses(index1) != opclasses(index2)
 
-      # Does lhs cover rhs?
-      def cover?(lhs, rhs)
-        case [lhs.unique, rhs.unique]
+        case [index1.unique, index2.unique]
         when [true, true]
-          lhs.columns == rhs.columns
-        when [false, true]
+          (index2.columns - index1.columns).empty?
+        when [true, false]
           false
         else
-          prefix?(rhs, lhs)
+          prefix?(index1, index2)
         end
       end
 
+      def opclasses(index)
+        index.respond_to?(:opclasses) ? index.opclasses : nil
+      end
+
       def prefix?(lhs, rhs)
         lhs.columns.count <= rhs.columns.count &&
           rhs.columns[0...lhs.columns.count] == lhs.columns

data/lib/active_record_doctor/detectors/incorrect_boolean_presence_validation.rb

@@ -4,32 +4,40 @@ 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 unless model.table_exists?
+
+          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)