Module: ActiveModel::Validations::HelperMethods

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

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”).

• :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.

There is also a list of default options supported by every validator: :if, :unless, :on, :allow_nil, :allow_blank, and :strict. See ActiveModel::Validation#validates for more information.

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

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. 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 %{translated_attribute_name}”).

There is also a list of default options supported by every validator: :if, :unless, :on, :allow_nil, :allow_blank, and :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: ->(person) { [person.username, person.first_name] },
                         message: 'should not be the same as your username or first name'
  validates_exclusion_of :karma, in: :reserved_karmas
end

Configuration options:

• :in - An enumerable object of items that the value shouldn't be part of. This can be supplied as a proc, lambda or symbol which returns an enumerable. If the enumerable is a range the test is performed with

• :within - A synonym(or alias) for :in Range#cover?, otherwise with include?.

• :message - Specifies a custom error message (default is: “is reserved”).

There is also a list of default options supported by every validator: :if, :unless, :on, :allow_nil, :allow_blank, and :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: ->(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.

Due to frequent misuse of ^ and $, you need to pass the multiline: true option in case you use any of these two anchors in the provided regular expression. In most cases, you should be using \A and \z.

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”).

• :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.

• :multiline - Set to true if your regular expression contains anchors that match the beginning or end of lines as opposed to the beginning or end of the string. These anchors are ^ and $.

There is also a list of default options supported by every validator: :if, :unless, :on, :allow_nil, :allow_blank, and :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: ->(person) { STATES[person.country] }
  validates_inclusion_of :karma, in: :available_karmas
end

Configuration options:

• :in - An enumerable object of available items. This can be supplied as a proc, lambda or symbol which returns an enumerable. If the enumerable is a numerical range the test is performed with Range#cover?, otherwise with include?. When using a proc or lambda the instance under validation is passed as an argument.

• :within - A synonym(or alias) for :in

• :message - Specifies a custom error message (default is: “is not included in the list”).

There is also a list of default options supported by every validator: :if, :unless, :on, :allow_nil, :allow_blank, and :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: ->(str) { str.scan(/\w+/) }
end

Configuration options:

• :minimum - The minimum size of the attribute.

• :maximum - The maximum size of the attribute. Allows nil by default if not used with :minimum.

• :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.

• :tokenizer - Specifies how to split up the attribute string. (e.g. tokenizer: ->(str) { str.scan(/\w+/) } to count words as in above example). Defaults to ->(value) { value.split(//) } which counts individual characters.

There is also a list of default options supported by every validator: :if, :unless, :on and :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”).

• :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 Integer 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.

• :other_than - Specifies the value must be other than the supplied value.

• :odd - Specifies the value must be an odd number.

• :even - Specifies the value must be an even number.

There is also a list of default options supported by every validator: :if, :unless, :on, :allow_nil, :allow_blank, and :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

• :only_integer

For example:

class Person < ActiveRecord::Base
  validates_numericality_of :width, less_than: ->(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.

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”).

There is also a list of default options supported by every validator: :if, :unless, :on, :allow_nil, :allow_blank, and :strict. See ActiveModel::Validation#validates for more information

Alias for #validates_length_of.