I have been attempting an interesting problem in a parent child object relationship regarding validators…

Both the parent and child have different validators via validate… or validates…

I want to store the result of each validator across all of them

the valid? command is run on the parent (edited)

when I run valid? on the parent I can verify with break points all 4 validators 2 on the parent and 2 on child are executed correctly

I am looking to monkey patch the process that loops through each of them

This is an example from AI

  def run_validations!(context = nil)
    @validator_results = {}

    # Gather all validators from this class and its ancestors.
    # Note: self.class.validators normally already merges them,
    # but using ancestors ensures we capture everything.
    all_validators = self.class.ancestors
                         .select { |ancestor| ancestor.respond_to?(:_validators) }
                         .map { |ancestor| ancestor.send(:_validators) }
                         .uniq


    

    all_validators.each do |validator|
      # Capture errors before running the validator.
      errors_before = errors.dup

      # Run the validator on self.
      validator.validate(self)

      # Determine if the validator added any new errors.
      new_errors = errors.to_hash.deep_dup.reject { |attr, messages| errors_before[attr] == messages }
      passed = new_errors.empty?

      @validator_results[validator.class.name] = {
        passed: passed,
        new_errors: new_errors
      }
    end
    debugger
    errors.empty?
  end

The method should return all 4 validators but does not

all_validators = self.class.ancestors
                         .select { |ancestor| ancestor.respond_to?(:_validators) }
                         .map { |ancestor| ancestor.send(:_validators) }
                         .uniq

thoughts?

I know this must be possible, I just can’t see where to patch

After much trial and error, I found a pattern that works.

All of my validators return a true or false to the caller, I can in turn see if they are all valid via a single call. Wow that was fun!

_service_validation_results.values.all?

Here are the methods that run the validations without monkey patching or breaking the callbacks!

def _run_validations!
    self._service_validation_results = {}

    # Standard validators from self.class.validators
    _all_standard_validators.each_with_index do |validator, index|
      attribute = validator.attributes.first

      validator.validate( self )

      self._service_validation_results["#{attribute}_#{validator.kind}_#{index}"] = errors[attribute].empty?
    end

    # Custom validators from _validate_callbacks
    _all_custom_validators.each_with_index do |callback, index|
      method_name = callback.filter

      next unless method_name.is_a?( Symbol )

      send( method_name )

      self._service_validation_results["custom_#{method_name}_#{index}"] = errors.empty?
    end
  end

  def _all_standard_validators
    ( [ self.class ] + self.class.ancestors )
      .select { |klass| klass < ActiveModel::Validations }
      .flat_map( &:validators )
      .uniq
  end

  def _all_custom_validators
    classes = ( [ self.class ] + self.class.ancestors ).select { |klass| klass < ActiveModel::Validations }
    callbacks =
      classes.flat_map do |klass|
        klass._validate_callbacks.select { |cb| cb.filter.is_a?( Symbol ) }
      end
    callbacks.uniq( &:filter )
  end

Thoughts my friends?