active_record_doctor 1.5.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: dd6b18b16b7a356e1760befd1d59d7f2b7a77ed3
-  data.tar.gz: ea1c526b3080d7c8ee5ae4e4eb9a833e3b797cc4
+SHA256:
+  metadata.gz: 296a8bbb4a326fd78afb08638435754646e22a4416dc18b02dc66f54198a9130
+  data.tar.gz: 5548b71ee3bb95344e34896a7c972cf39ce33f8a4bd1b03a1a2bf02b4081a1dd
 SHA512:
-  metadata.gz: 91035e0b5fa47e0d4e5b84a42f53573efc1c333555978a5130ecf05695b12aa17ffcf542b7e0d4c253332ad52b2688f5645e138bd755e3649ea88b0574e41c63
-  data.tar.gz: 137b3c1a9fd054e0b1af8fd1aad40f5b79ce068b0b0db458ca63d0f64cdf4c23342131a775a5f5148aec34e8c8ff2c32fd1e2a31b1bd86a69a3271c07e34b104
+  metadata.gz: 48c447ca18f35ee44db354414980f54d0ee9416ecc81b6b3fef9401afbaeb44b2951f0fabe43c89027d8783430bdbb6b055ca1000779e37d3729a171649ce795
+  data.tar.gz: 89ab1d3e4cca4df9c94022e0f11217b41239a3b5f2b3c579d8e466a4fe337909ab48f0b05d28eb5a67fc93afa4afe88a47c7c0ebbd3dc7d45c6d0259db22de40

data/README.md

@@ -3,11 +3,16 @@
 Active Record Doctor helps to keep the database in a good shape. Currently, it
 can:
 
-* index unindexed foreign keys
-* detect extraneous indexes
-* detect unindexed `deleted_at` columns
-* detect missing foreign key constraints
-* detect models referencing undefined tables
+* index unindexed foreign keys - [`active_record_doctor:unindexed_foreign_keys`](#indexing-unindexed-foreign-keys)
+* detect extraneous indexes - [`active_record_doctor:extraneous_indexes`](#removing-extraneous-indexes)
+* detect unindexed `deleted_at` columns - [`active_record_doctor:unindexed_deleted_at`](#detecting-unindexed-deleted_at-columns)
+* detect missing foreign key constraints - [`active_record_doctor:missing_foreign_keys`](#detecting-missing-foreign-key-constraints)
+* detect models referencing undefined tables - [`active_record_doctor:undefined_table_references`](#detecting-models-referencing-undefined-tables)
+* detect uniqueness validations not backed by an unique index - [`active_record_doctor:missing_unique_indexes`](#detecting-uniqueness-validations-not-backed-by-an-index)
+* detect missing non-`NULL` constraints - [`active_record_doctor:missing_non_null_constraint`](#detecting-missing-non-null-constraints)
+* detect missing presence validations - [`active_record_doctor:missing_presence_validation`](#detecting-missing-presence-validations)
+* detect incorrect presence validations on boolean columns - [`active_record_doctor:incorrect_boolean_presence_validation`](#detecting-incorrect-presence-validations-on-boolean-columns)
+* detect incorrect values of `dependent` on associations - [`active_record_doctor:incorrect_dependent_option`](#detecting-incorrect-dependent-option-on-associations)
 
 More features coming soon!
 
@@ -42,7 +47,7 @@ three-step process:
 1. Generate a list of unindexed foreign keys by running
 
   ```bash
-  rake active_record_doctor:unindexed_foreign_keys > unindexed_foreign_keys.txt
+  bundle exec rake active_record_doctor:unindexed_foreign_keys > unindexed_foreign_keys.txt
   ```
 
 2. Remove columns that should _not_ be indexed from `unindexed_foreign_keys.txt`
@@ -58,7 +63,7 @@ three-step process:
 4. Run the migrations
 
   ```bash
-  rake db:migrate
+  bundle exec rake db:migrate
   ```
 
 ### Removing Extraneous Indexes
@@ -83,7 +88,7 @@ To discover such indexes automatically just follow these steps:
 1. List extraneous indexes by running:
 
   ```bash
-  rake active_record_doctor:extraneous_indexes
+  bundle exec rake active_record_doctor:extraneous_indexes
   ```
 
 2. Confirm that each of the indexes can be indeed dropped.
@@ -113,7 +118,7 @@ of the time they should only cover columns satisfying `deleted_at IS NULL`.
 `deleted_at` column. Just run:
 
 ```
-rake active_record_doctor:unindexed_soft_delete
+bundle exec rake active_record_doctor:unindexed_deleted_at
 ```
 
 This will print a list of indexes that don't have the `deleted_at IS NULL`
@@ -134,7 +139,7 @@ add the constraint; for now, it's your job). You can obtain the list of foreign
 keys with the following command:
 
 ```bash
-rake active_record_doctor:missing_foreign_keys
+bundle exec rake active_record_doctor:missing_foreign_keys
 ```
 
 The output will look like:
@@ -167,10 +172,15 @@ cases where the name can be wrong (e.g. you forgot to commit a migration or
 changed the table name). Active Record Doctor can help you identify these cases
 before they hit production.
 
-The only  think you need to do is run:
+**IMPORTANT**. Models backed by views are supported only in:
+
+* Rails 5+ and _any_ database or
+* Rails 4.2 with PostgreSQL.
+
+The only think you need to do is run:
 
 ```
-rake active_record_doctor:undefined_table_references
+bundle exec rake active_record_doctor:undefined_table_references
 ```
 
 If there a model references an undefined table then you'll see a message like
@@ -184,6 +194,136 @@ The following models reference undefined tables:
 On top of that `rake` will exit with status code of 1. This allows you to use
 this check as part of your Continuous Integration pipeline.
 
+### Detecting Uniqueness Validations not Backed by an Index
+
+A model-level uniqueness validations should be backed by a database index in
+order to be robust. Otherwise you risk inserting duplicate values under heavy
+load.
+
+In order to detect such validations run:
+
+```
+bundle exec rake active_record_doctor:missing_unique_indexes
+```
+
+If there are such indexes then the command will print:
+
+```
+The following indexes should be created to back model-level uniqueness validations:
+  users: email
+```
+
+This means that you should create a unique index on `users.email`.
+
+### Detecting Missing Non-`NULL` Constraints
+
+If there's an unconditional presence validation on a column then it should be
+marked as non-`NULL`-able at the database level.
+
+In order to detect columns whose presence is required but that are marked
+`null: true` in the database run the following command:
+
+```
+bundle exec rake active_record_doctor:missing_non_null_constraint
+```
+
+The output of the command is similar to:
+
+```
+The following columns should be marked as `null: false`:
+  users: name
+
+```
+
+You can mark the columns mentioned in the output as `null: false` by creating a
+migration and calling `change_column_null`.
+
+This validator skips models whose corresponding database tables don't exist.
+
+### Detecting Missing Presence Validations
+
+If a column is marked as `null: false` then it's likely it should have the
+corresponding presence validator.
+
+In order to detect models lacking these validations run:
+
+```
+bundle exec rake active_record_doctor:missing_presence_validation
+```
+
+The output of the command looks like this:
+
+```
+The following models and columns should have presence validations:
+  User: email, name
+```
+
+This means `User` should have a presence validator on `email` and `name`.
+
+This validator skips models whose corresponding database tables don't exist.
+
+### Detecting Incorrect Presence Validations on Boolean Columns
+
+A boolean column's presence should be validated using inclusion or exclusion
+validators instead of the usual presence validator.
+
+In order to detect boolean columns whose presence is validated incorrectly run:
+
+```
+bundle exec rake active_record_doctor:incorrect_boolean_presence_validation
+```
+
+The output of the command looks like this:
+
+```
+The presence of the following boolean columns is validated incorrectly:
+  User: active
+```
+
+This means `active` is validated with `presence: true` instead of
+`inclusion: { in: [true, false] }` or `exclusion: { in: [nil] }`.
+
+This validator skips models whose corresponding database tables don't exist.
+
+### Detecting Incorrect `dependent` Option on Associations
+
+Cascading model deletions can be sped up with `dependent: :delete_all` (to
+delete all dependent models with one SQL query) but only if the deleted models
+have no callbacks as they're skipped.
+
+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
+
+In order to detect associations affected by the two aforementioned problems run
+the following command:
+
+```
+bundle exec rake active_record_doctor:incorrect_dependent_option
+```
+
+The output of the command looks like this:
+
+```
+The following associations might be using invalid dependent settings:
+  Company: users loads models one-by-one to invoke callbacks even though the related model defines none - consider using `dependent: :delete_all`
+  Post: comments skips callbacks that are defined on the associated model - consider changing to `dependent: :destroy` or similar
+```
+
+## Ruby and Rails Compatibility Policy
+
+The goal of the policy is to ensure proper functioning in reasonable
+combinations of Ruby and Rails versions. Specifically:
+
+1. If a Rails version is officially supported by the Rails Core Team then it's
+   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.
+
 ## Author
 
 This gem is developed and maintained by [Greg Navis](http://www.gregnavis.com).

data/lib/active_record_doctor.rb

@@ -1,4 +1,22 @@
-require "active_record_doctor/railtie" if defined?(Rails)
+# frozen_string_literal: true
 
-module ActiveRecordDoctor
+require "active_record_doctor/printers"
+require "active_record_doctor/printers/io_printer"
+require "active_record_doctor/railtie" if defined?(Rails) && defined?(Rails::Railtie)
+require "active_record_doctor/detectors"
+require "active_record_doctor/detectors/base"
+require "active_record_doctor/detectors/missing_presence_validation"
+require "active_record_doctor/detectors/missing_foreign_keys"
+require "active_record_doctor/detectors/missing_unique_indexes"
+require "active_record_doctor/detectors/incorrect_boolean_presence_validation"
+require "active_record_doctor/detectors/extraneous_indexes"
+require "active_record_doctor/detectors/unindexed_deleted_at"
+require "active_record_doctor/detectors/undefined_table_references"
+require "active_record_doctor/detectors/missing_non_null_constraint"
+require "active_record_doctor/detectors/unindexed_foreign_keys"
+require "active_record_doctor/detectors/incorrect_dependent_option"
+require "active_record_doctor/task"
+require "active_record_doctor/version"
+
+module ActiveRecordDoctor # :nodoc:
 end

data/lib/active_record_doctor/detectors.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext/class/subclasses"
+
+module ActiveRecordDoctor
+  # Container module for all detectors, implemented as separate classes.
+  module Detectors
+    def self.all
+      ActiveRecordDoctor::Detectors::Base.subclasses
+    end
+  end
+end

data/lib/active_record_doctor/detectors/base.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ActiveRecordDoctor
+  module Detectors
+    # Base class for all active_record_doctor detectors.
+    class Base
+      class << self
+        attr_reader :description
+
+        def run
+          new.run
+        end
+      end
+
+      private
+
+      def problems(problems, options = {})
+        [problems, options]
+      end
+
+      def connection
+        @connection ||= ActiveRecord::Base.connection
+      end
+
+      def indexes(table_name)
+        connection.indexes(table_name)
+      end
+
+      def tables
+        connection.tables
+      end
+
+      def table_exists?(table_name)
+        connection.table_exists?(table_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 # rubocop:disable Style/EmptyElse
+            # 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!
+      end
+
+      def models
+        ActiveRecord::Base.descendants
+      end
+    end
+  end
+end

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

@@ -1,32 +1,23 @@
-require "active_record_doctor/compatibility"
-require "active_record_doctor/printers/io_printer"
+# frozen_string_literal: true
 
-module ActiveRecordDoctor
-  module Tasks
-    class ExtraneousIndexes
-      include Compatibility
-
-      def self.run
-        new.run
-      end
+require "active_record_doctor/detectors/base"
 
-      def initialize(printer: ActiveRecordDoctor::Printers::IOPrinter.new)
-        @printer = printer
-      end
+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"
 
       def run
-        @printer.print_extraneous_indexes(extraneous_indexes)
+        problems(subindexes_of_multi_column_indexes + indexed_primary_keys)
       end
 
       private
 
-      def extraneous_indexes
-        subindexes_of_multi_column_indexes + indexed_primary_keys
-      end
-
       def subindexes_of_multi_column_indexes
         tables.reject do |table|
-          "schema_migrations" == table
+          table == "schema_migrations"
         end.flat_map do |table|
           indexes = indexes(table)
           maximum_indexes = indexes.select do |index|
@@ -51,7 +42,7 @@ module ActiveRecordDoctor
 
       def indexed_primary_keys
         @indexed_primary_keys ||= tables.reject do |table|
-          "schema_migrations" == table
+          table == "schema_migrations"
         end.map do |table|
           [
             table,
@@ -90,15 +81,7 @@ module ActiveRecordDoctor
       end
 
       def indexes(table_name)
-        @connection.indexes(table_name)
-      end
-
-      def tables
-        @tables ||= connection_tables
-      end
-
-      def connection
-        @connection ||= ActiveRecord::Base.connection
+        super.select { |index| index.columns.is_a?(Array) }
       end
     end
   end

data/lib/active_record_doctor/detectors/incorrect_boolean_presence_validation.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+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
+
+      private
+
+      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