Module ActiveModel::Validations::HelperMethods

Encapsulates the pattern of wanting to validate the acceptance of a terms of service check box (or similar agreement). Example:

  class Person < ActiveRecord::Base
    validates_acceptance_of :terms_of_service
    validates_acceptance_of :eula, :message => "must be abided"
  end

If the database column does not exist, the terms_of_service attribute is entirely virtual. This check is performed only if terms_of_service is not nil and by default on save.

Configuration options:

• :message - A custom error message (default is: “must be accepted”).
• :on - Specifies when this validation is active. Runs in all validation contexts by default (nil), other options are :create and :update.
• :allow_nil - Skip validation if attribute is nil (default is true).
• :accept - Specifies value that is considered accepted. The default value is a string “1”, which makes it easy to relate to an HTML checkbox. This should be set to true if you are validating a database column, since the attribute is typecast from “1” to true before validation.
• :if - Specifies a method, proc or string to call to determine if the validation should occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }). The method, proc or string should return or evaluate to a true or false value.
• :unless - Specifies a method, proc or string to call to determine if the validation should not occur (for example, :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }). The method, proc or string should return or evaluate to a true or false value.
• :strict - Specifies whether validation should be strict. See ActiveModel::Validation#validates! for more information.

Encapsulates the pattern of wanting to validate a password or email address field with a confirmation. For example:

  Model:
    class Person < ActiveRecord::Base
      validates_confirmation_of :user_name, :password
      validates_confirmation_of :email_address,
                                :message => "should match confirmation"
    end

  View:
    <%= password_field "person", "password" %>
    <%= password_field "person", "password_confirmation" %>

The added password_confirmation attribute is virtual; it exists only as an in-memory attribute for validating the password. To achieve this, the validation adds accessors to the model for the confirmation attribute.

NOTE: This check is performed only if password_confirmation is not nil, and by default only on save. To require confirmation, make sure to add a presence check for the confirmation attribute:

  validates_presence_of :password_confirmation, :if => :password_changed?

Configuration options:

• :message - A custom error message (default is: “doesn’t match confirmation”).
• :on - Specifies when this validation is active. Runs in all validation contexts by default (nil), other options are :create and :update.
• :if - Specifies a method, proc or string to call to determine if the validation should occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }). The method, proc or string should return or evaluate to a true or false value.
• :unless - Specifies a method, proc or string to call to determine if the validation should not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }). The method, proc or string should return or evaluate to a true or false value.
• :strict - Specifies whether validation should be strict. See ActiveModel::Validation#validates! for more information.

Validates that the value of the specified attribute is not in a particular enumerable object.

  class Person < ActiveRecord::Base
    validates_exclusion_of :username, :in => %w( admin superuser ), :message => "You don't belong here"
    validates_exclusion_of :age, :in => 30..60, :message => "This site is only for under 30 and over 60"
    validates_exclusion_of :format, :in => %w( mov avi ), :message => "extension %{value} is not allowed"
    validates_exclusion_of :password, :in => lambda { |p| [p.username, p.first_name] },
                           :message => "should not be the same as your username or first name"
  end

Configuration options:

• :in - An enumerable object of items that the value shouldn’t be part of. This can be supplied as a proc or lambda which returns an enumerable. If the enumerable is a range the test is performed with Range#cover? (backported in Active Support for 1.8), otherwise with include?.
• :message - Specifies a custom error message (default is: “is reserved”).
• :allow_nil - If set to true, skips this validation if the attribute is nil (default is false).
• :allow_blank - If set to true, skips this validation if the attribute is blank (default is false).
• :on - Specifies when this validation is active. Runs in all validation contexts by default (nil), other options are :create and :update.
• :if - Specifies a method, proc or string to call to determine if the validation should occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }). The method, proc or string should return or evaluate to a true or false value.
• :unless - Specifies a method, proc or string to call to determine if the validation should not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }). The method, proc or string should return or evaluate to a true or false value.
• :strict - Specifies whether validation should be strict. See ActiveModel::Validation#validates! for more information.

Validates whether the value of the specified attribute is of the correct form, going by the regular expression provided. You can require that the attribute matches the regular expression:

  class Person < ActiveRecord::Base
    validates_format_of :email, :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i, :on => :create
  end

Alternatively, you can require that the specified attribute does not match the regular expression:

  class Person < ActiveRecord::Base
    validates_format_of :email, :without => /NOSPAM/
  end

You can also provide a proc or lambda which will determine the regular expression that will be used to validate the attribute.

  class Person < ActiveRecord::Base
    # Admin can have number as a first letter in their screen name
    validates_format_of :screen_name,
                        :with => lambda{ |person| person.admin? ? /\A[a-z0-9][a-z0-9_\-]*\Z/i : /\A[a-z][a-z0-9_\-]*\Z/i }
  end

Note: use A and Z to match the start and end of the string, ^ and $ match the start/end of a line.

You must pass either :with or :without as an option. In addition, both must be a regular expression or a proc or lambda, or else an exception will be raised.

Configuration options:

• :message - A custom error message (default is: “is invalid”).
• :allow_nil - If set to true, skips this validation if the attribute is nil (default is false).
• :allow_blank - If set to true, skips this validation if the attribute is blank (default is false).
• :with - Regular expression that if the attribute matches will result in a successful validation. This can be provided as a proc or lambda returning regular expression which will be called at runtime.
• :without - Regular expression that if the attribute does not match will result in a successful validation. This can be provided as a proc or lambda returning regular expression which will be called at runtime.
• :on - Specifies when this validation is active. Runs in all validation contexts by default (nil), other options are :create and :update.
• :if - Specifies a method, proc or string to call to determine if the validation should occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }). The method, proc or string should return or evaluate to a true or false value.
• :unless - Specifies a method, proc or string to call to determine if the validation should not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }). The method, proc or string should return or evaluate to a true or false value.
• :strict - Specifies whether validation should be strict. See ActiveModel::Validation#validates! for more information.

Validates whether the value of the specified attribute is available in a particular enumerable object.

  class Person < ActiveRecord::Base
    validates_inclusion_of :gender, :in => %w( m f )
    validates_inclusion_of :age, :in => 0..99
    validates_inclusion_of :format, :in => %w( jpg gif png ), :message => "extension %{value} is not included in the list"
    validates_inclusion_of :states, :in => lambda{ |person| STATES[person.country] }
  end

Configuration options:

• :in - An enumerable object of available items. This can be supplied as a proc or lambda which returns an enumerable. If the enumerable is a range the test is performed with Range#cover? (backported in Active Support for 1.8), otherwise with include?.
• :message - Specifies a custom error message (default is: “is not included in the list”).
• :allow_nil - If set to true, skips this validation if the attribute is nil (default is false).
• :allow_blank - If set to true, skips this validation if the attribute is blank (default is false).
• :on - Specifies when this validation is active. Runs in all validation contexts by default (nil), other options are :create and :update.
• :if - Specifies a method, proc or string to call to determine if the validation should occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }). The method, proc or string should return or evaluate to a true or false value.
• :unless - Specifies a method, proc or string to call to determine if the validation should not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }). The method, proc or string should return or evaluate to a true or false value.
• :strict - Specifies whether validation should be strict. See ActiveModel::Validation#validates! for more information.

Validates that the specified attribute matches the length restrictions supplied. Only one option can be used at a time:

  class Person < ActiveRecord::Base
    validates_length_of :first_name, :maximum => 30
    validates_length_of :last_name, :maximum => 30, :message => "less than 30 if you don't mind"
    validates_length_of :fax, :in => 7..32, :allow_nil => true
    validates_length_of :phone, :in => 7..32, :allow_blank => true
    validates_length_of :user_name, :within => 6..20, :too_long => "pick a shorter name", :too_short => "pick a longer name"
    validates_length_of :zip_code, :minimum => 5, :too_short => "please enter at least 5 characters"
    validates_length_of :smurf_leader, :is => 4, :message => "papa is spelled with 4 characters... don't play me."
    validates_length_of :essay, :minimum => 100, :too_short => "Your essay must be at least 100 words.",
                        :tokenizer => lambda { |str| str.scan(/\w+/) }
  end

Configuration options:

• :minimum - The minimum size of the attribute.
• :maximum - The maximum size of the attribute.
• :is - The exact size of the attribute.
• :within - A range specifying the minimum and maximum size of the attribute.
• :in - A synonym(or alias) for :within.
• :allow_nil - Attribute may be nil; skip validation.
• :allow_blank - Attribute may be blank; skip validation.
• :too_long - The error message if the attribute goes over the maximum (default is: “is too long (maximum is %{count} characters)”).
• :too_short - The error message if the attribute goes under the minimum (default is: “is too short (min is %{count} characters)”).
• :wrong_length - The error message if using the :is method and the attribute is the wrong size (default is: “is the wrong length should be %{count} characters)”).
• :message - The error message to use for a :minimum, :maximum, or :is violation. An alias of the appropriate too_long/too_short/wrong_length message.
• :on - Specifies when this validation is active. Runs in all validation contexts by default (nil), other options are :create and :update.
• :if - Specifies a method, proc or string to call to determine if the validation should occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }). The method, proc or string should return or evaluate to a true or false value.
• :unless - Specifies a method, proc or string to call to determine if the validation should not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }). The method, proc or string should return or evaluate to a true or false value.
• :tokenizer - Specifies how to split up the attribute string. (e.g. :tokenizer => lambda {|str| str.scan(/w+/)} to count words as in above example). Defaults to lambda{ |value| value.split(//) } which counts individual characters.
• :strict - Specifies whether validation should be strict. See ActiveModel::Validation#validates! for more information.

Validates whether the value of the specified attribute is numeric by trying to convert it to a float with Kernel.Float (if only_integer is false) or applying it to the regular expression /A[+-]?d+Z/ (if only_integer is set to true).

  class Person < ActiveRecord::Base
    validates_numericality_of :value, :on => :create
  end

Configuration options:

• :message - A custom error message (default is: “is not a number”).
• :on - Specifies when this validation is active. Runs in all validation contexts by default (nil), other options are :create and :update.
• :only_integer - Specifies whether the value has to be an integer, e.g. an integral value (default is false).
• :allow_nil - Skip validation if attribute is nil (default is false). Notice that for fixnum and float columns empty strings are converted to nil.
• :greater_than - Specifies the value must be greater than the supplied value.
• :greater_than_or_equal_to - Specifies the value must be greater than or equal the supplied value.
• :equal_to - Specifies the value must be equal to the supplied value.
• :less_than - Specifies the value must be less than the supplied value.
• :less_than_or_equal_to - Specifies the value must be less than or equal the supplied value.
• :odd - Specifies the value must be an odd number.
• :even - Specifies the value must be an even number.
• :if - Specifies a method, proc or string to call to determine if the validation should occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }). The method, proc or string should return or evaluate to a true or false value.
• :unless - Specifies a method, proc or string to call to determine if the validation should not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }). The method, proc or string should return or evaluate to a true or false value.
• :strict - Specifies whether validation should be strict. See ActiveModel::Validation#validates! for more information.

The following checks can also be supplied with a proc or a symbol which corresponds to a method:

• :greater_than
• :greater_than_or_equal_to
• :equal_to
• :less_than
• :less_than_or_equal_to

For example:

  class Person < ActiveRecord::Base
    validates_numericality_of :width, :less_than => Proc.new { |person| person.height }
    validates_numericality_of :width, :greater_than => :minimum_weight
  end

Validates that the specified attributes are not blank (as defined by Object#blank?). Happens by default on save. Example:

  class Person < ActiveRecord::Base
    validates_presence_of :first_name
  end

The first_name attribute must be in the object and it cannot be blank.

If you want to validate the presence of a boolean field (where the real values are true and false), you will want to use validates_inclusion_of :field_name, :in => [true, false].

This is due to the way Object#blank? handles boolean values: false.blank? # => true.

Configuration options:

• :message - A custom error message (default is: “can’t be blank”).
• :on - Specifies when this validation is active. Runs in all validation contexts by default (nil), other options are :create and :update.
• :if - Specifies a method, proc or string to call to determine if the validation should occur (e.g. :if => :allow_validation, or :if => Proc.new { |user| user.signup_step > 2 }). The method, proc or string should return or evaluate to a true or false value.
• :unless - Specifies a method, proc or string to call to determine if the validation should not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }). The method, proc or string should return or evaluate to a true or false value.
• :strict - Specifies whether validation should be strict. See ActiveModel::Validation#validates! for more information.

Alias for validates_length_of