active_record_doctor 1.7.2 → 1.8.0

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

@@ -1,14 +1,18 @@
-require "active_record_doctor/tasks/base"
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
-  module Tasks
+  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'
+      @description = "Detect columns covered by a uniqueness validator without a unique index"
 
       def run
         eager_load!
 
-        success(hash_from_pairs(models.reject do |model|
+        problems(hash_from_pairs(models.reject do |model|
           model.table_name.nil?
         end.map do |model|
           [

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

@@ -1,9 +1,12 @@
-require "active_record_doctor/tasks/base"
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
-  module Tasks
+  module Detectors
+    # Find models referencing non-existent database tables or views.
     class UndefinedTableReferences < Base
-      @description = 'Detect models referencing undefined tables or views'
+      @description = "Detect models referencing undefined tables or views"
 
       def run
         eager_load!
@@ -16,19 +19,15 @@ module ActiveRecordDoctor
         offending_models = models.select do |model|
           model.table_name.present? &&
             !tables.include?(model.table_name) &&
-            existing_views &&
-            !existing_views.include?(model.table_name)
+            (
+              existing_views.nil? ||
+                !existing_views.include?(model.table_name)
+            )
         end.map do |model|
           [model.name, model.table_name]
         end
 
-        [
-          [
-            offending_models, # Actual results
-            !existing_views.nil? # true if views were checked, false otherwise
-          ],
-          offending_models.blank?
-        ]
+        problems(offending_models, views_checked: !existing_views.nil?)
       end
     end
   end

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

@@ -1,14 +1,20 @@
-require "active_record_doctor/tasks/base"
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
-  module Tasks
+  module Detectors
+    # Find unindexed deleted_at columns.
     class UnindexedDeletedAt < Base
-      COLUMNS = %w[deleted_at discarded_at].freeze
-      PATTERN = COLUMNS.join('|').freeze
-      @description = 'Detect unindexed deleted_at columns'
+      PATTERN = [
+        "deleted_at",
+        "discarded_at"
+      ].join("|").freeze
+
+      @description = "Detect unindexed deleted_at columns"
 
       def run
-        success(connection.tables.select do |table|
+        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|

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

@@ -1,30 +1,33 @@
-require "active_record_doctor/tasks/base"
+# frozen_string_literal: true
+
+require "active_record_doctor/detectors/base"
 
 module ActiveRecordDoctor
-  module Tasks
+  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'
+      @description = "Detect foreign keys without an index on them"
 
       def run
-        success(hash_from_pairs(tables.select do |table|
-          "schema_migrations" != table
+        problems(hash_from_pairs(tables.reject do |table|
+          table == "schema_migrations"
         end.map do |table|
           [
             table,
             connection.columns(table).select do |column|
-              foreign_key?(table, column) &&
+              foreign_key?(column) &&
                 !indexed?(table, column) &&
                 !indexed_as_polymorphic?(table, column)
             end.map(&:name)
           ]
-        end.select do |table, columns|
-          !columns.empty?
+        end.reject do |_table, columns|
+          columns.empty?
         end))
       end
 
       private
 
-      def foreign_key?(table, column)
+      def foreign_key?(column)
         column.name.end_with?("_id")
       end
 
@@ -35,7 +38,7 @@ module ActiveRecordDoctor
       end
 
       def indexed_as_polymorphic?(table, column)
-        type_column_name = column.name.sub(/_id\Z/, '_type')
+        type_column_name = column.name.sub(/_id\Z/, "_type")
         connection.indexes(table).any? do |index|
           index.columns == [type_column_name, column.name]
         end

data/lib/active_record_doctor/printers.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 module ActiveRecordDoctor
-  module Printers
+  module Printers # :nodoc:
   end
 end

data/lib/active_record_doctor/printers/io_printer.rb

@@ -1,72 +1,79 @@
+# frozen_string_literal: true
+
 module ActiveRecordDoctor
   module Printers
+    # Default printer for displaying messages produced by active_record_doctor.
     class IOPrinter
-      def initialize(io = STDOUT)
+      def initialize(io = $stdout)
         @io = io
       end
 
-      def unindexed_foreign_keys(unindexed_foreign_keys)
+      def unindexed_foreign_keys(unindexed_foreign_keys, _options)
+        return if unindexed_foreign_keys.empty?
+
+        @io.puts("The following foreign keys should be indexed for performance reasons:")
         @io.puts(unindexed_foreign_keys.sort.map do |table, columns|
-          "#{table} #{columns.sort.join(' ')}"
+          "  #{table} #{columns.sort.join(' ')}"
         end.join("\n"))
       end
 
-      def extraneous_indexes(extraneous_indexes)
-        if extraneous_indexes.empty?
-          @io.puts("No indexes are extraneous.")
-        else
-          @io.puts("The following indexes are extraneous and can be removed:")
-          extraneous_indexes.each do |index, details|
-            reason, *params = details
-            case reason
-            when :multi_column
-              @io.puts("  #{index} (can be handled by #{params.join(', ')})")
-            when :primary_key
-              @io.puts("  #{index} (is a primary key of #{params[0]})")
-            else
-              fail("unknown reason #{reason.inspect}")
-            end
+      def extraneous_indexes(extraneous_indexes, _options)
+        return if extraneous_indexes.empty?
+
+        @io.puts("The following indexes are extraneous and can be removed:")
+        extraneous_indexes.each do |index, details|
+          reason, *params = details
+          case reason
+          when :multi_column
+            @io.puts("  #{index} (can be handled by #{params.join(', ')})")
+          when :primary_key
+            @io.puts("  #{index} (is a primary key of #{params[0]})")
+          else
+            raise("unknown reason #{reason.inspect}")
           end
         end
       end
 
-      def missing_foreign_keys(missing_foreign_keys)
+      def missing_foreign_keys(missing_foreign_keys, _options)
+        return if missing_foreign_keys.empty?
+
+        @io.puts("The following columns lack a foreign key constraint:")
         @io.puts(missing_foreign_keys.sort.map do |table, columns|
-          "#{table} #{columns.sort.join(' ')}"
+          "  #{table} #{columns.sort.join(' ')}"
         end.join("\n"))
       end
 
-      def undefined_table_references((models, views_checked))
+      def undefined_table_references(models, options)
         return if models.empty?
 
-        unless views_checked
-          @io.puts(<<EOS)
+        unless options.fetch(:views_checked)
+          @io.puts(<<WARNING)
 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
+WARNING
         end
 
-        @io.puts('The following models reference undefined tables:')
+        @io.puts("The following models reference undefined tables:")
         models.each do |model_name, table_name|
           @io.puts("  #{model_name} (the table #{table_name} is undefined)")
         end
       end
 
-      def unindexed_deleted_at(indexes)
+      def unindexed_deleted_at(indexes, _options)
         return if indexes.empty?
 
-        @io.puts('The following indexes should include `deleted_at IS NULL`:')
+        @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)
+      def missing_unique_indexes(indexes, _options)
         return if indexes.empty?
 
-        @io.puts('The following indexes should be created to back model-level uniqueness validations:')
+        @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(', ')}")
@@ -74,32 +81,53 @@ EOS
         end
       end
 
-      def missing_presence_validation(missing_presence_validators)
+      def missing_presence_validation(missing_presence_validators, _options)
         return if missing_presence_validators.empty?
 
-        @io.puts('The following models and columns should have presence validations:')
+        @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)
+      def missing_non_null_constraint(missing_non_null_constraints, _options)
         return if missing_non_null_constraints.empty?
 
-        @io.puts('The following columns should be marked as `null: false`:')
+        @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)
+      def incorrect_boolean_presence_validation(incorrect_boolean_presence_validations, _options)
         return if incorrect_boolean_presence_validations.empty?
 
-        @io.puts('The presence of the following boolean columns is validated incorrectly:')
+        @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
+
+      def incorrect_dependent_option(problems, _options)
+        return if problems.empty?
+
+        @io.puts("The following associations might be using invalid dependent settings:")
+        problems.each do |model, associations|
+          associations.each do |(name, problem)|
+            # rubocop:disable Layout/LineLength
+            message =
+              case problem
+              when :suggest_destroy then "skips callbacks that are defined on the associated model - consider changing to `dependent: :destroy` or similar"
+              when :suggest_delete then "loads the associated model before deleting it - consider using `dependent: :delete`"
+              when :suggest_delete_all then "loads models one-by-one to invoke callbacks even though the related model defines none - consider using `dependent: :delete_all`"
+              else next
+              end
+            # rubocop:enable Layout/LineLength
+
+            @io.puts("  #{model}: #{name} #{message}")
+          end
+        end
+      end
     end
   end
 end

data/lib/active_record_doctor/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecordDoctor
   class Railtie < Rails::Railtie
     rake_tasks do

data/lib/active_record_doctor/task.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveRecordDoctor
+  # Rake task for running a detector and reporting its results.
+  class Task
+    DEFAULT_PRINTER = ActiveRecordDoctor::Printers::IOPrinter.new
+
+    def initialize(detector_class, printer = DEFAULT_PRINTER)
+      @detector_class = detector_class
+      @printer = printer
+    end
+
+    def name
+      @detector_class.name.demodulize.underscore.to_sym
+    end
+
+    def description
+      @detector_class.description
+    end
+
+    def run
+      problems, options = @detector_class.run
+      @printer.public_send(name, problems, options)
+
+      problems.empty?
+    end
+  end
+end

data/lib/active_record_doctor/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecordDoctor
-  VERSION = "1.7.2"
+  VERSION = "1.8.0"
 end

data/lib/generators/active_record_doctor/add_indexes/add_indexes_generator.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveRecordDoctor
+  # Generate migrations that add missing indexes to the database.
   class AddIndexesGenerator < Rails::Generators::Base
     MigrationDescription = Struct.new(:table, :columns)
 
-    desc 'Generate migrations for the specified indexes'
-    argument :path, type: :string, default: nil, banner: 'PATH'
+    desc "Generate migrations for the specified indexes"
+    argument :path, type: :string, default: nil, banner: "PATH"
 
     def create_migrations
       migration_descriptions = read_migration_descriptions(path)
@@ -23,10 +26,10 @@ module ActiveRecordDoctor
         table, *columns = line.split(/\s+/)
 
         if table.empty?
-          fail("No table name in #{path} on line #{index + 1}. Ensure the line doesn't start with whitespace.")
+          raise("No table name in #{path} on line #{index + 1}. Ensure the line doesn't start with whitespace.")
         end
         if columns.empty?
-          fail("No columns for table #{table} in #{path} on line #{index + 1}.")
+          raise("No columns for table #{table} in #{path} on line #{index + 1}.")
         end
 
         MigrationDescription.new(table, columns)
@@ -34,13 +37,16 @@ module ActiveRecordDoctor
     end
 
     def content(migration_description)
-      <<EOF
+      # In order to properly indent the resulting code, we must disable the
+      # rubocop rule below.
+
+      <<MIGRATION
 class IndexForeignKeysIn#{migration_description.table.camelize} < ActiveRecord::Migration#{migration_version}
   def change
 #{add_indexes(migration_description)}
   end
 end
-EOF
+MIGRATION
     end
 
     def add_indexes(migration_description)
@@ -54,12 +60,10 @@ EOF
     end
 
     def migration_version
-      major = ActiveRecord::VERSION::MAJOR
-      minor = ActiveRecord::VERSION::MINOR
-      if major >= 5 && minor >= 1
-        "[#{major}.#{minor}]"
+      if ActiveRecord::VERSION::STRING >= "5.1"
+        "[#{version}]"
       else
-        ''
+        ""
       end
     end
   end

data/lib/tasks/active_record_doctor.rake

@@ -1,33 +1,33 @@
-require "active_record_doctor/tasks"
-require "active_record_doctor/tasks/unindexed_foreign_keys"
-require "active_record_doctor/tasks/extraneous_indexes"
-require "active_record_doctor/tasks/missing_foreign_keys"
-require "active_record_doctor/tasks/undefined_table_references"
-require "active_record_doctor/tasks/unindexed_deleted_at"
-require "active_record_doctor/tasks/missing_unique_indexes"
-require "active_record_doctor/tasks/missing_presence_validation"
-require "active_record_doctor/tasks/missing_non_null_constraint"
-require "active_record_doctor/tasks/incorrect_boolean_presence_validation"
+# frozen_string_literal: true
 
-namespace :active_record_doctor do
-  def mount(task_class)
-    name = task_class.name.demodulize.underscore.to_sym
-
-    desc task_class.description
-    task name => :environment do
-      result, success = task_class.run
-      success = true if success.nil?
+require "active_record_doctor/detectors"
+require "active_record_doctor/detectors/unindexed_foreign_keys"
+require "active_record_doctor/detectors/extraneous_indexes"
+require "active_record_doctor/detectors/missing_foreign_keys"
+require "active_record_doctor/detectors/undefined_table_references"
+require "active_record_doctor/detectors/unindexed_deleted_at"
+require "active_record_doctor/detectors/missing_unique_indexes"
+require "active_record_doctor/detectors/missing_presence_validation"
+require "active_record_doctor/detectors/missing_non_null_constraint"
+require "active_record_doctor/detectors/incorrect_boolean_presence_validation"
+require "active_record_doctor/detectors/incorrect_dependent_option"
+require "active_record_doctor/task"
 
-      printer = ActiveRecordDoctor::Printers::IOPrinter.new
-      printer.public_send(name, result)
+namespace :active_record_doctor do
+  tasks = ActiveRecordDoctor::Detectors.all.map do |detector_class|
+    ActiveRecordDoctor::Task.new(detector_class)
+  end
 
-      # nil doesn't indicate a failure but rather no explicit result. We assume
-      # success by default hence only false results in an erroneous exit code.
-      exit(1) if success == false
+  tasks.each do |task|
+    desc task.description
+    task task.name => :environment do
+      task.run or exit(1)
     end
   end
 
-  ActiveRecordDoctor::Tasks.all.each do |task|
-    mount task
+  desc "Run all active_record_doctor tasks"
+  task :all => :environment do
+    results = tasks.map { |task| task.run }
+    results.all? or exit(1)
   end
 end