active_record_doctor 1.4.1 → 1.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b6e1c0cae1aa647256ff7eafb6a839e1b21efa82
-  data.tar.gz: 6ca222532fbd13abd9aba412c4dfa3ece725ec94
+SHA256:
+  metadata.gz: 649707d9a4a22831b3733778ad05614cc71f8edb704a68e9b18bd784a350daf9
+  data.tar.gz: 6e0fc8fe22ba882549152203c3a92f3eeebd3effb3f4eead6245001849b9e5de
 SHA512:
-  metadata.gz: 06e9c8db1abc13bdc3cadbf7c72b2d6f25d7fa8b87be116227dcb7a59aaf9475cb35f1cca9d5e679ffed123741d77424bf0a4a80e7a72c53c00a004a830f11c6
-  data.tar.gz: 0501fb31dd03bc30a9d51344f632fcec82e1ee4ceaa7e2e288360676b39c98978e7129a43c5e368098e1c7d16ea332dfcf863db5b2910bb37cb778326ff3f2b5
+  metadata.gz: 437df56684da87b78b3336337cabe138f5375c54673a5d02da29b06fa9d238e1c9fa34a4cf9973b7bf944a0ef8ebbed5ec9dd9d9d12612f87e16597292ff22aa
+  data.tar.gz: 3ee83bab9d6dc5c88c4c47d33d69d30ecf373bb6ab4798accfc681066fd0a1a4580295f29a869c69a9ff582c925f7c2cb328b345429a92623942995a0416e1d6

data/README.md

@@ -3,10 +3,15 @@
 Active Record Doctor helps to keep the database in a good shape. Currently, it
 can:
 
-* index unindexed foreign keys
-* detect extraneous indexes
-* 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)
 
 More features coming soon!
 
@@ -41,7 +46,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`
@@ -57,7 +62,7 @@ three-step process:
 4. Run the migrations
 
   ```bash
-  rake db:migrate
+  bundle exec rake db:migrate
   ```
 
 ### Removing Extraneous Indexes
@@ -82,7 +87,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.
@@ -101,6 +106,24 @@ example, if there's a unique index on `users.login` and a non-unique index on
 `users.login, users.domain` then the tool will _not_ suggest dropping
 `users.login` as it could violate the uniqueness assumption.
 
+### Detecting Unindexed `deleted_at` Columns
+
+If you soft-delete some models (e.g. with `paranoia`) then you need to modify
+your indexes to include only non-deleted rows. Otherwise they will include
+logically non-existent rows. This will make them larger and slower to use. Most
+of the time they should only cover columns satisfying `deleted_at IS NULL`.
+
+`active_record_doctor` can automatically detect indexes on tables with a
+`deleted_at` column. Just run:
+
+```
+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`
+clause. Currently, `active_record_doctor` cannot automatically generate
+appropriate migrations. You need to do that manually.
+
 ### Detecting Missing Foreign Key Constraints
 
 If `users.profile_id` references a row in `profiles` then this can be expressed
@@ -115,7 +138,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:
@@ -148,10 +171,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
@@ -165,6 +193,108 @@ 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.
+
+## 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,18 @@
-require "active_record_doctor/railtie" if defined?(Rails)
+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/tasks"
+require "active_record_doctor/tasks/base"
+require "active_record_doctor/tasks/missing_presence_validation"
+require "active_record_doctor/tasks/missing_foreign_keys"
+require "active_record_doctor/tasks/missing_unique_indexes"
+require "active_record_doctor/tasks/incorrect_boolean_presence_validation"
+require "active_record_doctor/tasks/extraneous_indexes"
+require "active_record_doctor/tasks/unindexed_deleted_at"
+require "active_record_doctor/tasks/undefined_table_references"
+require "active_record_doctor/tasks/missing_non_null_constraint"
+require "active_record_doctor/tasks/unindexed_foreign_keys"
+require "active_record_doctor/version"
 
 module ActiveRecordDoctor
 end

data/lib/active_record_doctor/printers/io_printer.rb

@@ -1,17 +1,17 @@
 module ActiveRecordDoctor
   module Printers
     class IOPrinter
-      def initialize(io: STDOUT)
+      def initialize(io = STDOUT)
         @io = io
       end
 
-      def print_unindexed_foreign_keys(unindexed_foreign_keys)
+      def unindexed_foreign_keys(unindexed_foreign_keys)
         @io.puts(unindexed_foreign_keys.sort.map do |table, columns|
           "#{table} #{columns.sort.join(' ')}"
         end.join("\n"))
       end
 
-      def print_extraneous_indexes(extraneous_indexes)
+      def extraneous_indexes(extraneous_indexes)
         if extraneous_indexes.empty?
           @io.puts("No indexes are extraneous.")
         else
@@ -30,18 +30,74 @@ module ActiveRecordDoctor
         end
       end
 
-      def print_missing_foreign_keys(missing_foreign_keys)
+      def missing_foreign_keys(missing_foreign_keys)
         @io.puts(missing_foreign_keys.sort.map do |table, columns|
           "#{table} #{columns.sort.join(' ')}"
         end.join("\n"))
       end
 
-      def print_undefined_table_references(models)
+      def undefined_table_references((models, views_checked))
         return if models.empty?
 
+        unless views_checked
+          @io.puts(<<EOS)
+WARNING: Models backed by database views are supported only in Rails 5+ OR
+Rails 4.2 + PostgreSQL. It seems this is NOT your setup. Therefore, such models
+will be erroneously reported below as not having their underlying tables/views.
+Consider upgrading Rails or disabling this task temporarily.
+EOS
+        end
+
         @io.puts('The following models reference undefined tables:')
-        models.each do |model|
-          @io.puts("  #{model.name} (the table #{model.table_name} is undefined)")
+        models.each do |model_name, table_name|
+          @io.puts("  #{model_name} (the table #{table_name} is undefined)")
+        end
+      end
+
+      def unindexed_deleted_at(indexes)
+        return if indexes.empty?
+
+        @io.puts('The following indexes should include `deleted_at IS NULL`:')
+        indexes.each do |index|
+          @io.puts("  #{index}")
+        end
+      end
+
+      def missing_unique_indexes(indexes)
+        return if indexes.empty?
+
+        @io.puts('The following indexes should be created to back model-level uniqueness validations:')
+        indexes.each do |table, arrays_of_columns|
+          arrays_of_columns.each do |columns|
+            @io.puts("  #{table}: #{columns.join(', ')}")
+          end
+        end
+      end
+
+      def missing_presence_validation(missing_presence_validators)
+        return if missing_presence_validators.empty?
+
+        @io.puts('The following models and columns should have presence validations:')
+        missing_presence_validators.each do |model_name, array_of_columns|
+          @io.puts("  #{model_name}: #{array_of_columns.join(', ')}")
+        end
+      end
+
+      def missing_non_null_constraint(missing_non_null_constraints)
+        return if missing_non_null_constraints.empty?
+
+        @io.puts('The following columns should be marked as `null: false`:')
+        missing_non_null_constraints.each do |table, columns|
+          @io.puts("  #{table}: #{columns.join(', ')}")
+        end
+      end
+
+      def incorrect_boolean_presence_validation(incorrect_boolean_presence_validations)
+        return if incorrect_boolean_presence_validations.empty?
+
+        @io.puts('The presence of the following boolean columns is validated incorrectly:')
+        incorrect_boolean_presence_validations.each do |table, columns|
+          @io.puts("  #{table}: #{columns.join(', ')}")
         end
       end
     end

data/lib/active_record_doctor/railtie.rb

@@ -1,7 +1,7 @@
 module ActiveRecordDoctor
   class Railtie < Rails::Railtie
     rake_tasks do
-      load "tasks/active_record_doctor_tasks.rake"
+      load "tasks/active_record_doctor.rake"
     end
   end
 end

data/lib/active_record_doctor/tasks.rb

@@ -1,4 +1,10 @@
+require "active_support"
+require "active_support/core_ext/class/subclasses"
+
 module ActiveRecordDoctor
   module Tasks
+    def self.all
+      ActiveRecordDoctor::Tasks::Base.subclasses
+    end
   end
 end

data/lib/active_record_doctor/tasks/base.rb

@@ -0,0 +1,86 @@
+require "active_record_doctor/printers/io_printer"
+
+module ActiveRecordDoctor
+  module Tasks
+    class Base
+      def self.run
+        new.run
+      end
+
+      def self.description
+        @description
+      end
+
+      def initialize(printer = ActiveRecordDoctor::Printers::IOPrinter.new)
+        @printer = printer
+      end
+
+      private
+
+      def success(result)
+        [result, true]
+      end
+
+      def connection
+        @connection ||= ActiveRecord::Base.connection
+      end
+
+      def indexes(table_name)
+        connection.indexes(table_name)
+      end
+
+      def tables
+        @tables ||=
+          if ActiveRecord::VERSION::MAJOR == 5
+            connection.data_sources
+          else
+            connection.tables
+          end
+      end
+
+      def table_exists?(table_name)
+        connection.table_exists?(table_name)
+      end
+
+      def views
+        @views ||=
+          if ActiveRecord::VERSION::MAJOR == 5
+            connection.views
+          elsif connection.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+            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 hash_from_pairs(pairs)
+        Hash[*pairs.flatten(1)]
+      end
+
+      def eager_load!
+        # We call GC.start to make the test suite work. It's (probably) not
+        # needed for use during development. However, if we remove it then the
+        # test suite will start accumulating temporary model classes in the
+        # object space. Running the garbage collector gets rid of them.
+        GC.start
+
+        Rails.application.eager_load!
+      end
+
+      def models
+        descendants(ActiveRecord::Base)
+      end
+
+      def descendants(superclass)
+        superclass.descendants
+      end
+
+      def descendant?(klass, superclass)
+        !klass.nil? && (klass.superclass == superclass || descendant?(klass.superclass, superclass))
+      end
+    end
+  end
+end