missing_presence_validation: recognize explicit foreign key validators

This commit allows a foreign key column to be explicitly validated via
a standalone validator. Without this change a false positive errors
would be reported. Additionally, only `belongs_to` associations are
considered for marking as optional, as `has_*` don't support the
`optional` nor `required` options.

Author: gregnavis

lib/active_record_doctor/detectors/missing_presence_validation.rb

@@ -76,28 +76,30 @@ def detect
           # that are validated directly or via an association name.
           model.validators.each do |validator|
             problematic_columns.reject! do |column|
-              # Translate a foreign key or type to the association name.
-              attribute = column_name_to_association_name[column.name] || column.name.to_sym
+              attribute_names = [
+                column.name.to_sym,
+                column_name_to_association_name[column.name]
+              ].compact
 
               case validator
 
               # A regular presence validator is enough if the column name is
               # listed among the attributes it's validating.
               when ActiveRecord::Validations::PresenceValidator
-                validator.attributes.include?(attribute)
+                (validator.attributes & attribute_names).present?
 
               # An inclusion validator ensures the column is not nil if it covers
               # the column and nil is NOT one of the values it allows.
               when ActiveModel::Validations::InclusionValidator
                 validator_items = inclusion_or_exclusion_validator_items(validator)
-                validator.attributes.include?(attribute) &&
+                (validator.attributes & attribute_names).present? &&
                   (validator_items.is_a?(Proc) || validator_items.exclude?(nil))
 
               # An exclusion validator ensures the column is not nil if it covers
               # the column and excludes nil as an allowed value explicitly.
               when ActiveModel::Validations::ExclusionValidator
                 validator_items = inclusion_or_exclusion_validator_items(validator)
-                validator.attributes.include?(attribute) &&
+                (validator.attributes & attribute_names).present? &&
                   (validator_items.is_a?(Proc) || validator_items.include?(nil))
 
               end
@@ -109,7 +111,7 @@ def detect
           problematic_associations = []
           problematic_polymorphic_associations = []
 
-          model.reflect_on_all_associations.each do |reflection|
+          model.reflect_on_all_associations(:belongs_to).each do |reflection|
             foreign_key_column = problematic_columns.find { |column| column.name == reflection.foreign_key }
             if reflection.polymorphic?
               # If the foreign key and type are not one of the columns that lack

test/active_record_doctor/detectors/missing_presence_validation_test.rb

@@ -261,6 +261,43 @@ def test_abstract_class
     refute_problems
   end
 
+  def test_both_foreign_key_column_and_association_validators_are_checked
+    Context.create_table(:registrations) do |t|
+      t.string :email, null: false
+    end.define_model do
+      # email is NOT NULL, but its presence is validated via the following
+      # required association, no complaints about the column should be set.
+      belongs_to :user, primary_key: :email, foreign_key: :email, inverse_of: :registrations, optional: false
+    end
+
+    Context.create_table(:users) do |t|
+      t.string :email, null: false
+    end.define_model do
+      has_many :registrations, primary_key: :email, foreign_key: :email, inverse_of: :user, dependent: nil
+      validates :email, presence: true
+    end
+
+    refute_problems
+  end
+
+  def test_explicit_foreign_key_validator_allows_optional_belongs_to
+    Context.create_table(:registrations) do |t|
+      t.string :email, null: false
+    end.define_model do
+      # The association below is optional, but email has an explicit presence
+      # validator so no errors should be reported.
+      belongs_to :user, primary_key: :email, foreign_key: :email, inverse_of: :registrations, optional: true
+      validates :email, presence: true
+    end
+
+    Context.create_table(:users) do
+    end.define_model do
+      has_many :registrations, primary_key: :email, foreign_key: :email, inverse_of: :user, dependent: nil
+    end
+
+    refute_problems
+  end
+
   def test_config_ignore_models
     Context.create_table(:users) do |t|
       t.string :name, null: false