class Shoulda::Matchers::ActiveModel::Validator

def all_formatted_validation_error_messages
  format_validation_errors(all_validation_errors)
end

def all_validation_errors
  validation_result[:all_validation_errors]
end

def call
  !messages_match? && !captured_range_error?
end

def captured_range_error?
  !!@captured_range_error
end

def captured_validation_exception?
  @captured_validation_exception
end

def expects_strict?
  @expects_strict
end

def has_messages?
  messages.any?
end

def initialize(record, attribute, options = {})
  @record = record
  @attribute = attribute
  @context = options[:context]
  @expects_strict = options[:expects_strict]
  @expected_message = options[:expected_message]
  @_validation_result = nil
  @captured_validation_exception = false
  @captured_range_error = false
end

def matched_messages
  if @expected_message
    messages.grep(@expected_message)
  else
    messages
  end
end

def messages
  if expects_strict?
    [validation_exception_message]
  else
    validation_error_messages
  end
end

def messages_match?
  has_messages? &&
    type_of_message_matched? &&
    matched_messages.compact.any?
end

def perform_validation
  if context
    record.valid?(context)
  else
    record.valid?
  end
  all_validation_errors = record.errors.dup
  validation_error_messages =
    if record.errors.respond_to?(:[])
      record.errors[attribute]
    else
      record.errors.on(attribute)
    end
  {
    all_validation_errors: all_validation_errors,
    validation_error_messages: validation_error_messages,
    validation_exception_message: nil
  }
rescue ::ActiveModel::StrictValidationFailed => exception
  @captured_validation_exception = true
  {
    all_validation_errors: nil,
    validation_error_messages: [],
    validation_exception_message: exception.message
  }
end

def type_of_message_matched?
  expects_strict? == captured_validation_exception?
end

def validation_error_messages
  validation_result[:validation_error_messages]
end

def validation_exception_message
  validation_result[:validation_exception_message]
end

def validation_result
  @_validation_result ||= perform_validation
end