active_record_doctor 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dd6b18b16b7a356e1760befd1d59d7f2b7a77ed3
-  data.tar.gz: ea1c526b3080d7c8ee5ae4e4eb9a833e3b797cc4
+  metadata.gz: 01e06f004eba174cadece575f77fe83381f53133
+  data.tar.gz: d835060741b338b07a3f87aef33eff707ef32f98
 SHA512:
-  metadata.gz: 91035e0b5fa47e0d4e5b84a42f53573efc1c333555978a5130ecf05695b12aa17ffcf542b7e0d4c253332ad52b2688f5645e138bd755e3649ea88b0574e41c63
-  data.tar.gz: 137b3c1a9fd054e0b1af8fd1aad40f5b79ce068b0b0db458ca63d0f64cdf4c23342131a775a5f5148aec34e8c8ff2c32fd1e2a31b1bd86a69a3271c07e34b104
+  metadata.gz: e07f92a2fd4b200fd5d9e0ef50e1b5a516347b8216080071648bca31c6e72683ceb01d85e125002e4aa0cd5f48a8020ca43097488a67906c15be443e68783da4
+  data.tar.gz: 2faca055adba20d77aac44658adb35d40243f491b533a088e5ca44615d16f36e4cee7deca99b1a37607127c5f2bc276e5dac0aa56c34f0b5aa87b611667afd3e

data/README.md

@@ -8,6 +8,9 @@ can:
 * detect unindexed `deleted_at` columns
 * detect missing foreign key constraints
 * detect models referencing undefined tables
+* detect uniqueness validations not backed by an unique index
+* detect missing non-`NULL` constraints
+* detect missing presence validations
 
 More features coming soon!
 
@@ -42,7 +45,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 +61,7 @@ three-step process:
 4. Run the migrations
 
   ```bash
-  rake db:migrate
+  bundle exec rake db:migrate
   ```
 
 ### Removing Extraneous Indexes
@@ -83,7 +86,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 +116,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 +137,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:
@@ -170,7 +173,7 @@ before they hit production.
 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 +187,70 @@ 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`.
+
+### 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`.
+
 ## Author
 
 This gem is developed and maintained by [Greg Navis](http://www.gregnavis.com).

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,13 +30,13 @@ 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)
         return if models.empty?
 
         @io.puts('The following models reference undefined tables:')
@@ -45,7 +45,7 @@ module ActiveRecordDoctor
         end
       end
 
-      def print_unindexed_deleted_at(indexes)
+      def unindexed_deleted_at(indexes)
         return if indexes.empty?
 
         @io.puts('The following indexes should include `deleted_at IS NULL`:')
@@ -53,6 +53,35 @@ module ActiveRecordDoctor
           @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
     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,7 @@
 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,64 @@
+require "active_record_doctor/printers/io_printer"
+
+module ActiveRecordDoctor
+  module Tasks
+    class Base
+      def self.run
+        new.run
+      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 Rails::VERSION::MAJOR == 5
+            connection.data_sources
+          else
+            connection.tables
+          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

data/lib/active_record_doctor/tasks/extraneous_indexes.rb

@@ -1,29 +1,14 @@
-require "active_record_doctor/compatibility"
-require "active_record_doctor/printers/io_printer"
+require "active_record_doctor/tasks/base"
 
 module ActiveRecordDoctor
   module Tasks
-    class ExtraneousIndexes
-      include Compatibility
-
-      def self.run
-        new.run
-      end
-
-      def initialize(printer: ActiveRecordDoctor::Printers::IOPrinter.new)
-        @printer = printer
-      end
-
+    class ExtraneousIndexes < Base
       def run
-        @printer.print_extraneous_indexes(extraneous_indexes)
+        success(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
@@ -90,15 +75,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.kind_of?(Array) }
       end
     end
   end

data/lib/active_record_doctor/tasks/missing_foreign_keys.rb

@@ -1,27 +1,10 @@
-require "active_record_doctor/compatibility"
-require "active_record_doctor/printers/io_printer"
+require "active_record_doctor/tasks/base"
 
 module ActiveRecordDoctor
   module Tasks
-    class MissingForeignKeys
-      include Compatibility
-
-      def self.run
-        new.run
-      end
-
-      def initialize(printer: ActiveRecordDoctor::Printers::IOPrinter.new)
-        @printer = printer
-      end
-
+    class MissingForeignKeys < Base
       def run
-        @printer.print_missing_foreign_keys(missing_foreign_keys)
-      end
-
-      private
-
-      def missing_foreign_keys
-        hash_from_pairs(connection_tables.select do |table|
+        success(hash_from_pairs(tables.select do |table|
           "schema_migrations" != table
         end.map do |table|
           [
@@ -37,9 +20,11 @@ module ActiveRecordDoctor
           ]
         end.select do |table, columns|
           !columns.empty?
-        end)
+        end))
       end
 
+      private
+
       def id?(table, column)
         column.name.end_with?("_id")
       end
@@ -56,14 +41,6 @@ module ActiveRecordDoctor
           another_column.name == type_column_name
         end
       end
-
-      def connection
-        @connection ||= ActiveRecord::Base.connection
-      end
-
-      def hash_from_pairs(pairs)
-        Hash[*pairs.flatten(1)]
-      end
     end
   end
 end

data/lib/active_record_doctor/tasks/missing_non_null_constraint.rb

@@ -0,0 +1,42 @@
+require "active_record_doctor/tasks/base"
+
+module ActiveRecordDoctor
+  module Tasks
+    class MissingNonNullConstraint < Base
+      def run
+        eager_load!
+
+        success(hash_from_pairs(models.reject do |model|
+          model.table_name.nil? || model.table_name == 'schema_migrations'
+        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
+
+      private
+
+      def validator_needed?(model, column)
+        ![model.primary_key, 'created_at', 'updated_at'].include?(column.name)
+      end
+
+      def has_mandatory_presence_validator?(model, column)
+        model.validators.any? do |validator|
+          validator.is_a?(ActiveRecord::Validations::PresenceValidator) &&
+            validator.attributes.include?(column.name.to_sym) &&
+            !validator.options[:allow_nil] &&
+            !validator.options[:if] &&
+            !validator.options[:unless]
+        end
+      end
+    end
+  end
+end