active_record_doctor 1.10.0 → 1.12.0

data/lib/active_record_doctor/detectors/incorrect_dependent_option.rb

@@ -18,7 +18,8 @@ module ActiveRecordDoctor
 
       private
 
-      def message(model:, association:, problem:, associated_models:)
+      def message(model:, association:, problem:, associated_models_type: nil,
+                  table_name: nil, column_name: nil, associated_models: [])
         associated_models.sort!
 
         models_part =
@@ -28,57 +29,109 @@ module ActiveRecordDoctor
             "models #{associated_models.join(', ')} have"
           end
 
+        if associated_models_type
+          models_part = "#{associated_models_type} #{models_part}"
+        end
+
         # rubocop:disable Layout/LineLength
         case problem
+        when :invalid_through
+          "ensure #{model}.#{association} is configured correctly - #{associated_models[0]}.#{association} may be undefined"
+        when :destroy_async
+          "don't use `dependent: :destroy_async` on #{model}.#{association} or remove the foreign key from #{table_name}.#{column_name} - "\
+            "associated models will be deleted in the same transaction along with #{model}"
         when :suggest_destroy
-          "use `dependent: :destroy` or similar on #{model}.#{association} - the associated #{models_part} callbacks that are currently skipped"
+          "use `dependent: :destroy` or similar on #{model}.#{association} - associated #{models_part} callbacks that are currently skipped"
         when :suggest_delete
-          "use `dependent: :delete` or similar on #{model}.#{association} - the associated #{models_part} no callbacks and can be deleted without loading"
+          "use `dependent: :delete` or similar on #{model}.#{association} - associated #{models_part} no callbacks and can be deleted without loading"
         when :suggest_delete_all
-          "use `dependent: :delete_all` or similar on #{model}.#{association} - associated #{models_part} no validations and can be deleted in bulk"
+          "use `dependent: :delete_all` or similar on #{model}.#{association} - associated #{models_part} no callbacks and can be deleted in bulk"
         end
         # rubocop:enable Layout/LineLength
       end
 
       def detect
-        models(except: config(:ignore_models)).each do |model|
-          next unless model.table_exists?
-
-          associations = model.reflect_on_all_associations(:has_many) +
-                         model.reflect_on_all_associations(:has_one) +
-                         model.reflect_on_all_associations(:belongs_to)
-
-          associations.each do |association|
-            next if config(:ignore_associations).include?("#{model.name}.#{association.name}")
+        each_model(except: config(:ignore_models), existing_tables_only: true) do |model|
+          each_association(model, except: config(:ignore_associations)) do |association|
+            # A properly configured :through association will have a non-nil
+            # source_reflection. If it's nil then it indicates the :through
+            # model lacks the next leg in the :through relationship. For
+            # instance, if user has many comments through posts then a nil
+            # source_reflection means that Post doesn't define +has_many :comments+.
+            if through?(association) && association.source_reflection.nil?
+              log("through association with nil source_reflection")
+
+              through_association = model.reflect_on_association(association.options.fetch(:through))
+              association_on_join_model = through_association.klass.reflect_on_association(association.name)
+
+              # We report a problem only if the +has_many+ association mentioned
+              # above is actually missing. We let the detector continue in other
+              # cases, risking an exception, as the absence of source_reflection
+              # must be caused by something else in those cases. Each further
+              # exception will be handled on a case-by-case basis.
+              if association_on_join_model.nil?
+                problem!(
+                  model: model.name,
+                  association: association.name,
+                  problem: :invalid_through,
+                  associated_models: [through_association.klass.name],
+                  associated_models_type: "join"
+                )
+                next
+              end
+            end
 
-            associated_models =
+            associated_models, associated_models_type =
               if association.polymorphic?
-                models_having(as: association.name)
+                [models_having_association_with_options(as: association.name), nil]
+              elsif through?(association)
+                [[association.source_reflection.active_record], "join"]
               else
-                [association.klass]
+                [[association.klass], nil]
               end
 
             deletable_models, destroyable_models = associated_models.partition { |klass| deletable?(klass) }
 
-            if callback_action(association) == :invoke && destroyable_models.empty? && deletable_models.present?
-              suggestion =
-                case association.macro
-                when :has_many then :suggest_delete_all
-                when :has_one, :belongs_to then :suggest_delete
-                else raise("unsupported association type #{association.macro}")
-                end
-
-              problem!(model: model.name, association: association.name, problem: suggestion,
-                       associated_models: deletable_models.map(&:name))
-            elsif callback_action(association) == :skip && destroyable_models.present?
-              problem!(model: model.name, association: association.name, problem: :suggest_destroy,
-                       associated_models: destroyable_models.map(&:name))
+            case association.options[:dependent]
+            when :destroy_async
+              foreign_key = foreign_key(association.klass.table_name, model.table_name)
+              if foreign_key
+                problem!(model: model.name, association: association.name,
+                         table_name: foreign_key.from_table, column_name: foreign_key.column, problem: :destroy_async)
+              end
+            when :destroy
+              if destroyable_models.empty? && deletable_models.present?
+                suggestion =
+                  case association.macro
+                  when :has_many then :suggest_delete_all
+                  when :has_one, :belongs_to then :suggest_delete
+                  else raise("unsupported association type #{association.macro}")
+                  end
+
+                problem!(
+                  model: model.name,
+                  association: association.name,
+                  problem: suggestion,
+                  associated_models: deletable_models.map(&:name),
+                  associated_models_type: associated_models_type
+                )
+              end
+            when :delete, :delete_all
+              if destroyable_models.present?
+                problem!(
+                  model: model.name,
+                  association: association.name,
+                  problem: :suggest_destroy,
+                  associated_models: destroyable_models.map(&:name),
+                  associated_models_type: associated_models_type
+                )
+              end
             end
           end
         end
       end
 
-      def models_having(as:)
+      def models_having_association_with_options(as:)
         models.select do |model|
           associations = model.reflect_on_all_associations(:has_one) +
                          model.reflect_on_all_associations(:has_many)
@@ -89,13 +142,6 @@ module ActiveRecordDoctor
         end
       end
 
-      def callback_action(reflection)
-        case reflection.options[:dependent]
-        when :delete, :delete_all then :skip
-        when :destroy then :invoke
-        end
-      end
-
       def deletable?(model)
         !defines_destroy_callbacks?(model) &&
           dependent_models(model).all? do |dependent_model|
@@ -108,6 +154,10 @@ module ActiveRecordDoctor
           end
       end
 
+      def through?(reflection)
+        reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+      end
+
       def defines_destroy_callbacks?(model)
         # Destroying an associated model involves loading it first hence
         # initialize and find are present. If they are defined on the model

data/lib/active_record_doctor/detectors/incorrect_length_validation.rb

@@ -31,14 +31,9 @@ module ActiveRecordDoctor
       end
 
       def detect
-        models(except: config(:ignore_models)).each do |model|
-          next unless model.table_exists?
-
-          connection.columns(model.table_name).each do |column|
-            next if config(:ignore_attributes).include?("#{model.name}.#{column.name}")
-            next if ![:string, :text].include?(column.type)
-
-            model_maximum = maximum_allowed_by_validations(model)
+        each_model(except: config(:ignore_models), existing_tables_only: true) do |model|
+          each_attribute(model, except: config(:ignore_attributes), type: [:string, :text]) do |column|
+            model_maximum = maximum_allowed_by_validations(model, column.name.to_sym)
             next if model_maximum == column.limit
 
             problem!(
@@ -52,9 +47,11 @@ module ActiveRecordDoctor
         end
       end
 
-      def maximum_allowed_by_validations(model)
+      def maximum_allowed_by_validations(model, column)
         length_validator = model.validators.find do |validator|
-          validator.kind == :length && validator.options.include?(:maximum)
+          validator.kind == :length &&
+            validator.options.include?(:maximum) &&
+            validator.attributes.include?(column)
         end
         length_validator ? length_validator.options[:maximum] : nil
       end

data/lib/active_record_doctor/detectors/mismatched_foreign_key_type.rb

@@ -18,25 +18,32 @@ module ActiveRecordDoctor
 
       private
 
-      def message(table:, column:)
+      def message(from_table:, from_column:, from_type:, to_table:, to_column:, to_type:)
         # rubocop:disable Layout/LineLength
-        "#{table}.#{column} references a column of different type - foreign keys should be of the same type as the referenced column"
+        "#{from_table}.#{from_column} is a foreign key of type #{from_type} and references #{to_table}.#{to_column} of type #{to_type} - foreign keys should be of the same type as the referenced column"
         # rubocop:enable Layout/LineLength
       end
 
       def detect
-        tables(except: config(:ignore_tables)).each do |table|
-          connection.foreign_keys(table).each do |foreign_key|
+        each_table(except: config(:ignore_tables)) do |table|
+          each_foreign_key(table) do |foreign_key|
             from_column = column(table, foreign_key.column)
 
             next if config(:ignore_columns).include?("#{table}.#{from_column.name}")
 
             to_table = foreign_key.to_table
-            primary_key = primary_key(to_table)
-
-            next if from_column.sql_type == primary_key.sql_type
-
-            problem!(table: table, column: from_column.name)
+            to_column = column(to_table, foreign_key.primary_key)
+
+            next if from_column.sql_type == to_column.sql_type
+
+            problem!(
+              from_table: table,
+              from_column: from_column.name,
+              from_type: from_column.sql_type,
+              to_table: to_table,
+              to_column: to_column.name,
+              to_type: to_column.sql_type
+            )
           end
         end
       end

data/lib/active_record_doctor/detectors/missing_foreign_keys.rb

@@ -23,10 +23,8 @@ module ActiveRecordDoctor
       end
 
       def detect
-        tables(except: config(:ignore_tables)).each do |table|
-          connection.columns(table).each do |column|
-            next if config(:ignore_columns).include?("#{table}.#{column.name}")
-
+        each_table(except: config(:ignore_tables)) do |table|
+          each_column(table, except: config(:ignore_columns)) do |column|
             # We need to skip polymorphic associations as they can reference
             # multiple tables but a foreign key constraint can reference
             # a single predefined table.

data/lib/active_record_doctor/detectors/missing_non_null_constraint.rb

@@ -23,8 +23,7 @@ module ActiveRecordDoctor
       end
 
       def detect
-        table_models = models.group_by(&:table_name)
-        table_models.delete_if { |_table, models| !models.first.table_exists? }
+        table_models = models.select(&:table_exists?).group_by(&:table_name)
 
         table_models.each do |table, models|
           next if config(:ignore_tables).include?(table)
@@ -50,19 +49,22 @@ module ActiveRecordDoctor
       end
 
       def non_null_needed?(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
+          reflection.foreign_key == column.name ||
+            (reflection.polymorphic? && reflection.foreign_type == column.name)
         end
-        attribute_name_forms << belongs_to.name.to_sym if belongs_to
 
-        model.validators.any? do |validator|
+        required_presence_validators(model).any? do |validator|
+          attributes = validator.attributes
+
+          attributes.include?(column.name.to_sym) ||
+            (belongs_to && attributes.include?(belongs_to.name.to_sym))
+        end
+      end
+
+      def required_presence_validators(model)
+        model.validators.select do |validator|
           validator.is_a?(ActiveRecord::Validations::PresenceValidator) &&
-            (validator.attributes & attribute_name_forms).present? &&
             !validator.options[:allow_nil] &&
             !validator.options[:if] &&
             !validator.options[:unless]

data/lib/active_record_doctor/detectors/missing_presence_validation.rb

@@ -23,13 +23,10 @@ module ActiveRecordDoctor
       end
 
       def detect
-        models(except: config(:ignore_models)).each do |model|
-          next unless model.table_exists?
-
-          connection.columns(model.table_name).each do |column|
+        each_model(except: config(:ignore_models), existing_tables_only: true) do |model|
+          each_attribute(model, except: config(:ignore_attributes)) do |column|
             next unless validator_needed?(model, column)
             next if validator_present?(model, column)
-            next if config(:ignore_attributes).include?("#{model}.#{column.name}")
 
             problem!(column: column.name, model: model.name)
           end
@@ -52,17 +49,23 @@ module ActiveRecordDoctor
 
       def inclusion_validator_present?(model, column)
         model.validators.any? do |validator|
+          validator_items = inclusion_validator_items(validator)
+          return true if validator_items.is_a?(Proc)
+
           validator.is_a?(ActiveModel::Validations::InclusionValidator) &&
             validator.attributes.include?(column.name.to_sym) &&
-            !validator.options.fetch(:in, []).include?(nil)
+            !validator_items.include?(nil)
         end
       end
 
       def exclusion_validator_present?(model, column)
         model.validators.any? do |validator|
+          validator_items = inclusion_validator_items(validator)
+          return true if validator_items.is_a?(Proc)
+
           validator.is_a?(ActiveModel::Validations::ExclusionValidator) &&
             validator.attributes.include?(column.name.to_sym) &&
-            validator.options.fetch(:in, []).include?(nil)
+            validator_items.include?(nil)
         end
       end
 
@@ -79,6 +82,10 @@ module ActiveRecordDoctor
             (validator.attributes & allowed_attributes).present?
         end
       end
+
+      def inclusion_validator_items(validator)
+        validator.options[:in] || validator.options[:within] || []
+      end
     end
   end
 end

data/lib/active_record_doctor/detectors/missing_unique_indexes.rb

@@ -22,9 +22,12 @@ module ActiveRecordDoctor
       def message(model:, table:, columns:, problem:)
         case problem
         when :validations
-          "add a unique index on #{table}(#{columns.join(', ')}) - validating uniqueness in the model without an index can lead to duplicates"
+          "add a unique index on #{table}(#{columns.join(', ')}) - validating uniqueness in #{model.name} without an index can lead to duplicates"
+        when :case_insensitive_validations
+          "add a unique expression index on #{table}(#{columns.join(', ')}) - validating case-insensitive uniqueness in #{model.name} "\
+            "without an expression index can lead to duplicates (a regular unique index is not enough)"
         when :has_ones
-          "add a unique index on #{table}(#{columns.first}) - using `has_one` in the #{model.name} model without an index can lead to duplicates"
+          "add a unique index on #{table}(#{columns.join(', ')}) - using `has_one` in #{model.name} without an index can lead to duplicates"
         end
       end
       # rubocop:enable Layout/LineLength
@@ -35,57 +38,69 @@ module ActiveRecordDoctor
       end
 
       def validations_without_indexes
-        models(except: config(:ignore_models)).each do |model|
-          next unless model.table_exists?
-
-          model.validators.each do |validator|
+        each_model(except: config(:ignore_models), existing_tables_only: true) do |model|
+          # Skip inherited validators from STI to prevent them
+          # from being reported multiple times on subclasses.
+          validators = model.validators - model.superclass.validators
+          validators.each do |validator|
             scope = Array(validator.options.fetch(:scope, []))
 
             next unless validator.is_a?(ActiveRecord::Validations::UniquenessValidator)
-            next unless supported_validator?(validator)
+            next if conditional_validator?(validator)
+
+            # 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.
+            case_sensitive = validator.options.fetch(:case_sensitive, true)
+
+            # ActiveRecord < 5.0 does not support expression indexes,
+            # so this will always be a false positive.
+            next if !case_sensitive && Utils.expression_indexes_unsupported?
 
             validator.attributes.each do |attribute|
               columns = resolve_attributes(model, scope + [attribute])
 
-              next if unique_index?(model.table_name, columns)
               next if ignore_columns.include?("#{model.name}(#{columns.join(',')})")
 
-              problem!(model: model, table: model.table_name, columns: columns, problem: :validations)
+              columns[-1] = "lower(#{columns[-1]})" unless case_sensitive
+
+              next if unique_index?(model.table_name, columns)
+
+              if case_sensitive
+                problem!(model: model, table: model.table_name, columns: columns, problem: :validations)
+              else
+                problem!(model: model, table: model.table_name, columns: columns,
+                         problem: :case_insensitive_validations)
+              end
             end
           end
         end
       end
 
       def has_ones_without_indexes # rubocop:disable Naming/PredicateName
-        models.each do |model|
-          has_ones = model.reflect_on_all_associations(:has_one)
-          has_ones.each do |has_one|
-            next if has_one.is_a?(ActiveRecord::Reflection::ThroughReflection) || has_one.scope
-
-            association_model = has_one.klass
-            next if config(:ignore_models).include?(association_model.name)
-
-            foreign_key = has_one.foreign_key
-            next if ignore_columns.include?(foreign_key.to_s)
-
-            table_name = association_model.table_name
-            next if unique_index?(table_name, [foreign_key])
-
-            problem!(model: model, table: table_name, columns: [foreign_key], problem: :has_ones)
+        each_model do |model|
+          each_association(model, type: :has_one, has_scope: false, through: false) do |has_one|
+            next if config(:ignore_models).include?(has_one.klass.name)
+
+            columns =
+              if has_one.options[:as]
+                [has_one.type.to_s, has_one.foreign_key.to_s]
+              else
+                [has_one.foreign_key.to_s]
+              end
+            next if ignore_columns.include?("#{model.name}(#{columns.join(',')})")
+
+            table_name = has_one.klass.table_name
+            next if unique_index?(table_name, columns)
+
+            problem!(model: model, table: table_name, columns: columns, problem: :has_ones)
           end
         end
       end
 
-      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)
+      def conditional_validator?(validator)
+        (validator.options.keys & [:if, :unless, :conditions]).present?
       end
 
       def resolve_attributes(model, attributes)
@@ -105,9 +120,17 @@ module ActiveRecordDoctor
       def unique_index?(table_name, columns, scope = nil)
         columns = (Array(scope) + columns).map(&:to_s)
         indexes(table_name).any? do |index|
+          index_columns =
+            # For expression indexes, Active Record returns columns as string.
+            if index.columns.is_a?(String)
+              extract_index_columns(index.columns)
+            else
+              index.columns
+            end
+
           index.unique &&
             index.where.nil? &&
-            (Array(index.columns) - columns).empty?
+            (index_columns - columns).empty?
         end
       end
 
@@ -116,6 +139,18 @@ module ActiveRecordDoctor
           column.gsub(" ", "")
         end
       end
+
+      def extract_index_columns(columns)
+        columns
+          .split(",")
+          .map(&:strip)
+          .map do |column|
+            column.gsub(/lower\(/i, "lower(")
+                  .gsub(/\((\w+)\)::\w+/, '\1') # (email)::string
+                  .gsub(/([`'"])(\w+)\1/, '\2') # quoted identifiers
+                  .gsub(/\A\((.+)\)\z/, '\1')   # remove surrounding braces from MySQL
+          end
+      end
     end
   end
 end

data/lib/active_record_doctor/detectors/short_primary_key_type.rb

@@ -20,10 +20,10 @@ module ActiveRecordDoctor
       end
 
       def detect
-        tables(except: config(:ignore_tables)).each do |table|
+        each_table(except: config(:ignore_tables)) do |table|
           column = primary_key(table)
           next if column.nil?
-          next if bigint?(column) || uuid?(column)
+          next if !integer?(column) || bigint?(column)
 
           problem!(table: table, column: column.name)
         end
@@ -37,8 +37,8 @@ module ActiveRecordDoctor
         end
       end
 
-      def uuid?(column)
-        column.sql_type == "uuid"
+      def integer?(column)
+        column.type == :integer
       end
     end
   end

data/lib/active_record_doctor/detectors/undefined_table_references.rb

@@ -20,8 +20,8 @@ module ActiveRecordDoctor
       end
 
       def detect
-        models(except: config(:ignore_models)).each do |model|
-          next if model.table_exists? || views.include?(model.table_name)
+        each_model(except: config(:ignore_models), abstract: false) do |model|
+          next if connection.data_source_exists?(model.table_name)
 
           problem!(model: model.name, table: model.table_name)
         end

data/lib/active_record_doctor/detectors/unindexed_deleted_at.rb

@@ -31,20 +31,12 @@ module ActiveRecordDoctor
       end
 
       def detect
-        tables(except: config(:ignore_tables)).each do |table|
-          timestamp_columns = connection.columns(table).reject do |column|
-            config(:ignore_columns).include?("#{table}.#{column.name}")
-          end.select do |column|
-            config(:column_names).include?(column.name)
-          end
-
-          next if timestamp_columns.empty?
-
-          timestamp_columns.each do |timestamp_column|
-            indexes(table, except: config(:ignore_indexes)).each do |index|
-              next if index.where =~ /\b#{timestamp_column.name}\s+IS\s+(NOT\s+)?NULL\b/i
+        each_table(except: config(:ignore_tables)) do |table|
+          each_column(table, only: config(:column_names), except: config(:ignore_columns)) do |column|
+            each_index(table, except: config(:ignore_indexes)) do |index|
+              next if index.where =~ /\b#{column.name}\s+IS\s+(NOT\s+)?NULL\b/i
 
-              problem!(index: index.name, column_name: timestamp_column.name)
+              problem!(index: index.name, column_name: column.name)
             end
           end
         end

data/lib/active_record_doctor/detectors/unindexed_foreign_keys.rb

@@ -18,30 +18,43 @@ module ActiveRecordDoctor
 
       private
 
-      def message(table:, column:)
+      def message(table:, columns:)
         # rubocop:disable Layout/LineLength
-        "add an index on #{table}.#{column} - foreign keys are often used in database lookups and should be indexed for performance reasons"
+        "add an index on #{table}(#{columns.join(', ')}) - foreign keys are often used in database lookups and should be indexed for performance reasons"
         # rubocop:enable Layout/LineLength
       end
 
       def detect
-        tables(except: config(:ignore_tables)).each do |table|
-          connection.columns(table).each do |column|
-            next if config(:ignore_columns).include?("#{table}.#{column.name}")
-
-            next unless foreign_key?(column)
+        each_table(except: config(:ignore_tables)) do |table|
+          each_column(table, except: config(:ignore_columns)) do |column|
+            next unless named_like_foreign_key?(column) || foreign_key?(table, column)
             next if indexed?(table, column)
             next if indexed_as_polymorphic?(table, column)
 
-            problem!(table: table, column: column.name)
+            type_column_name = type_column_name(column)
+
+            columns =
+              if column_exists?(table, type_column_name)
+                [type_column_name, column.name]
+              else
+                [column.name]
+              end
+
+            problem!(table: table, columns: columns)
           end
         end
       end
 
-      def foreign_key?(column)
+      def named_like_foreign_key?(column)
         column.name.end_with?("_id")
       end
 
+      def foreign_key?(table, column)
+        connection.foreign_keys(table).any? do |foreign_key|
+          foreign_key.column == column.name
+        end
+      end
+
       def indexed?(table, column)
         connection.indexes(table).any? do |index|
           index.columns.first == column.name
@@ -49,9 +62,20 @@ module ActiveRecordDoctor
       end
 
       def indexed_as_polymorphic?(table, column)
-        type_column_name = column.name.sub(/_id\Z/, "_type")
         connection.indexes(table).any? do |index|
-          index.columns == [type_column_name, column.name]
+          index.columns[0, 2] == [type_column_name(column), column.name]
+        end
+      end
+
+      def column_exists?(table, column_name)
+        connection.columns(table).any? { |column| column.name == column_name }
+      end
+
+      def type_column_name(column)
+        if column.name.end_with?("_id")
+          column.name.sub(/_id\Z/, "_type")
+        else
+          "#{column.name}_type"
         end
       end
     end