active_record_doctor 1.4.1 → 1.7.2

data/lib/active_record_doctor/tasks/extraneous_indexes.rb

@@ -1,29 +1,16 @@
-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
+      @description = 'Detect extraneous indexes'
 
       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 +77,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/incorrect_boolean_presence_validation.rb

@@ -0,0 +1,37 @@
+require "active_record_doctor/tasks/base"
+
+module ActiveRecordDoctor
+  module Tasks
+    class IncorrectBooleanPresenceValidation < Base
+      @description = 'Detect boolean columns with presence/absence instead of includes/excludes validators'
+
+      def run
+        eager_load!
+
+        success(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

data/lib/active_record_doctor/tasks/missing_foreign_keys.rb

@@ -1,27 +1,12 @@
-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
+      @description = 'Detect association columns without a foreign key constraint'
 
       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 +22,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 +43,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,56 @@
+require "active_record_doctor/tasks/base"
+
+module ActiveRecordDoctor
+  module Tasks
+    class MissingNonNullConstraint < Base
+      @description = 'Detect presence validators not backed by a non-NULL constraint'
+
+      def run
+        eager_load!
+
+        success(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.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)
+        # A foreign key can be validates via the column name (e.g. company_id)
+        # or the association name (e.g. company). We collect the allowed names
+        # in an array to check for their presence in the validator definition
+        # in one go.
+        attribute_name_forms = [column.name.to_sym]
+        belongs_to = model.reflect_on_all_associations(:belongs_to).find do |reflection|
+          reflection.foreign_key == column.name
+        end
+        attribute_name_forms << belongs_to.name.to_sym if belongs_to
+
+        model.validators.any? do |validator|
+          validator.is_a?(ActiveRecord::Validations::PresenceValidator) &&
+            (validator.attributes & attribute_name_forms).present? &&
+            !validator.options[:allow_nil] &&
+            !validator.options[:if] &&
+            !validator.options[:unless]
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/tasks/missing_presence_validation.rb

@@ -0,0 +1,75 @@
+require "active_record_doctor/tasks/base"
+
+module ActiveRecordDoctor
+  module Tasks
+    class MissingPresenceValidation < Base
+      @description = 'Detect non-NULL columns without a presence validator'
+
+      def run
+        eager_load!
+
+        success(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|
+              validator_needed?(model, column) &&
+                !validator_present?(model, column)
+            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) &&
+          !column.null
+      end
+
+      def validator_present?(model, column)
+        if column.type == :boolean
+          inclusion_validator_present?(model, column) ||
+            exclusion_validator_present?(model, column)
+        else
+          presence_validator_present?(model, column)
+        end
+      end
+
+      def inclusion_validator_present?(model, column)
+        model.validators.any? do |validator|
+          validator.is_a?(ActiveModel::Validations::InclusionValidator) &&
+            validator.attributes.include?(column.name.to_sym) &&
+            !validator.options.fetch(:in, []).include?(nil)
+        end
+      end
+
+      def exclusion_validator_present?(model, column)
+        model.validators.any? do |validator|
+          validator.is_a?(ActiveModel::Validations::ExclusionValidator) &&
+            validator.attributes.include?(column.name.to_sym) &&
+              validator.options.fetch(:in, []).include?(nil)
+        end
+      end
+
+      def presence_validator_present?(model, column)
+        allowed_attributes = [column.name.to_sym]
+
+        belongs_to = model.reflect_on_all_associations(:belongs_to).find do |reflection|
+          reflection.foreign_key == column.name
+        end
+        allowed_attributes << belongs_to.name.to_sym if belongs_to
+
+        model.validators.any? do |validator|
+          validator.is_a?(ActiveRecord::Validations::PresenceValidator) &&
+            (validator.attributes & allowed_attributes).present?
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/tasks/missing_unique_indexes.rb

@@ -0,0 +1,57 @@
+require "active_record_doctor/tasks/base"
+
+module ActiveRecordDoctor
+  module Tasks
+    class MissingUniqueIndexes < Base
+      @description = 'Detect columns covered by a uniqueness validator without a unique index'
+
+      def run
+        eager_load!
+
+        success(hash_from_pairs(models.reject do |model|
+          model.table_name.nil?
+        end.map do |model|
+          [
+            model.table_name,
+            model.validators.select do |validator|
+              table_name = model.table_name
+              scope = validator.options.fetch(:scope, [])
+
+              validator.is_a?(ActiveRecord::Validations::UniquenessValidator) &&
+                supported_validator?(validator) &&
+                !unique_index?(table_name, validator.attributes, scope)
+            end.map do |validator|
+              scope = Array(validator.options.fetch(:scope, []))
+              attributes = validator.attributes
+              (scope + attributes).map(&:to_s)
+            end
+          ]
+        end.reject do |_table_name, indexes|
+          indexes.empty?
+        end))
+      end
+
+      private
+
+      def supported_validator?(validator)
+        validator.options[:if].nil? &&
+          validator.options[:unless].nil? &&
+          validator.options[:conditions].nil? &&
+
+          # In Rails 6, default option values are no longer explicitly set on
+          # options so if the key is absent we must fetch the default value
+          # ourselves. case_sensitive is the default in 4.2+ so it's safe to
+          # put true literally.
+          validator.options.fetch(:case_sensitive, true)
+      end
+
+      def unique_index?(table_name, columns, scope)
+        columns = (Array(scope) + columns).map(&:to_s)
+
+        indexes(table_name).any? do |index|
+          index.columns.to_set == columns.to_set && index.unique
+        end
+      end
+    end
+  end
+end

data/lib/active_record_doctor/tasks/undefined_table_references.rb

@@ -1,33 +1,34 @@
-require "active_record_doctor/compatibility"
-require "active_record_doctor/printers/io_printer"
+require "active_record_doctor/tasks/base"
 
 module ActiveRecordDoctor
   module Tasks
-    class UndefinedTableReferences
-      include Compatibility
-
-      def self.run
-        new.run
-      end
-
-      def initialize(printer: ActiveRecordDoctor::Printers::IOPrinter.new)
-        @printer = printer
-      end
+    class UndefinedTableReferences < Base
+      @description = 'Detect models referencing undefined tables or views'
 
       def run
-        @printer.print_undefined_table_references(undefined_table_references)
-        undefined_table_references.present? ? 1 : 0
-      end
-
-      private
+        eager_load!
 
-      def undefined_table_references
-        Rails.application.eager_load!
+        # If we can't list views due to old Rails version or unsupported
+        # database then existing_views is nil. We inform the caller we haven't
+        # consulted views so that it can display an appropriate warning.
+        existing_views = views
 
-        ActiveRecord::Base.descendants.select do |model|
+        offending_models = models.select do |model|
           model.table_name.present? &&
-            !model.connection.tables.include?(model.table_name)
+            !tables.include?(model.table_name) &&
+            existing_views &&
+            !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?
+        ]
       end
     end
   end

data/lib/active_record_doctor/tasks/unindexed_deleted_at.rb

@@ -0,0 +1,23 @@
+require "active_record_doctor/tasks/base"
+
+module ActiveRecordDoctor
+  module Tasks
+    class UnindexedDeletedAt < Base
+      COLUMNS = %w[deleted_at discarded_at].freeze
+      PATTERN = COLUMNS.join('|').freeze
+      @description = 'Detect unindexed deleted_at columns'
+
+      def run
+        success(connection.tables.select do |table|
+          connection.columns(table).any? { |column| column.name =~ /^#{PATTERN}$/ }
+        end.flat_map do |table|
+          connection.indexes(table).reject do |index|
+            index.where =~ /\b#{PATTERN}\s+IS\s+NULL\b/i
+          end.map do |index|
+            index.name
+          end
+        end)
+      end
+    end
+  end
+end

data/lib/active_record_doctor/tasks/unindexed_foreign_keys.rb

@@ -1,27 +1,12 @@
-require "active_record_doctor/compatibility"
-require "active_record_doctor/printers/io_printer"
+require "active_record_doctor/tasks/base"
 
 module ActiveRecordDoctor
   module Tasks
-    class UnindexedForeignKeys
-      include Compatibility
-
-      def self.run
-        new.run
-      end
-
-      def initialize(printer: ActiveRecordDoctor::Printers::IOPrinter.new)
-        @printer = printer
-      end
+    class UnindexedForeignKeys < Base
+      @description = 'Detect foreign keys without an index on them'
 
       def run
-        @printer.print_unindexed_foreign_keys(unindexed_foreign_keys)
-      end
-
-      private
-
-      def unindexed_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|
           [
@@ -34,9 +19,11 @@ module ActiveRecordDoctor
           ]
         end.select do |table, columns|
           !columns.empty?
-        end)
+        end))
       end
 
+      private
+
       def foreign_key?(table, column)
         column.name.end_with?("_id")
       end
@@ -53,14 +40,6 @@ module ActiveRecordDoctor
           index.columns == [type_column_name, column.name]
         end
       end
-
-      def connection
-        @connection ||= ActiveRecord::Base.connection
-      end
-
-      def hash_from_pairs(pairs)
-        Hash[*pairs.flatten(1)]
-      end
     end
   end
 end