module Shoulda::Matchers::ActiveModel

def allow_value(*values)

Returns:
  • (AllowValueMatcher) -
def allow_value(*values)
  if values.empty?
    raise ArgumentError, 'need at least one argument'
  else
    AllowValueMatcher.new(*values)
  end
end

def have_secure_password(attr = :password)

Returns:
  • (HaveSecurePasswordMatcher) -
def have_secure_password(attr = :password)
  HaveSecurePasswordMatcher.new(attr)
end

def validate_absence_of(attr)

Returns:
  • (ValidateAbsenceOfMatcher) -
def validate_absence_of(attr)
  ValidateAbsenceOfMatcher.new(attr)
end

def validate_acceptance_of(attr)

Returns:
  • (ValidateAcceptanceOfMatcher) -
def validate_acceptance_of(attr)
  ValidateAcceptanceOfMatcher.new(attr)
end

def validate_comparison_of(attr)

Returns:
  • (ValidateComparisonOfMatcher) -
def validate_comparison_of(attr)
  ValidateComparisonOfMatcher.new(attr)
end

def validate_confirmation_of(attr)

Returns:
  • (ValidateConfirmationOfMatcher) -
def validate_confirmation_of(attr)
  ValidateConfirmationOfMatcher.new(attr)
end

def validate_exclusion_of(attr)

Returns:
  • (ValidateExclusionOfMatcher) -
def validate_exclusion_of(attr)
  ValidateExclusionOfMatcher.new(attr)
end

def validate_inclusion_of(attr)

Returns:
  • (ValidateInclusionOfMatcher) -
def validate_inclusion_of(attr)
  ValidateInclusionOfMatcher.new(attr)
end

def validate_length_of(attr)

Returns:
  • (ValidateLengthOfMatcher) -
def validate_length_of(attr)
  ValidateLengthOfMatcher.new(attr)
end

def validate_numericality_of(attr)

Returns:
  • (ValidateNumericalityOfMatcher) -
def validate_numericality_of(attr)
  ValidateNumericalityOfMatcher.new(attr)
end

def validate_presence_of(attr)

Returns:
  • (ValidatePresenceOfMatcher) -
def validate_presence_of(attr)
  ValidatePresenceOfMatcher.new(attr)
end