module ActiveModel::Validations::HelperMethods

Validates that the specified attributes are blank (as defined by Object#present?).

class Person < ActiveRecord::Base
  validates_absence_of :first_name
end

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

Configuration options:

• :message - A custom error message (default is: “must 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::Validations::ClassMethods#validates for more information.

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.

Configuration options:

• :message - A custom error message (default is: “must be accepted”).

• :accept - Specifies a value that is considered accepted. Also accepts an array of possible values. The default value is an array [“1”, true], which makes it easy to relate to an HTML checkbox. This should be set to, or include, 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::Validations::ClassMethods#validates for more information.

Validates the value of a specified attribute fulfills all defined comparisons with another value, proc, or attribute.

class Person < ActiveRecord::Base
  validates_comparison_of :value, greater_than: 'the sum of its parts'
end

Configuration options:

• :message - A custom error message (default is: “failed comparison”).

• :greater_than - Specifies the value must be greater than the supplied value. The default error message for this option is _“must be greater than %{count}”_.

• :greater_than_or_equal_to - Specifies the value must be greater than or equal to the supplied value. The default error message for this option is _“must be greater than or equal to %{count}”_.

• :equal_to - Specifies the value must be equal to the supplied value. The default error message for this option is _“must be equal to %{count}”_.

• :less_than - Specifies the value must be less than the supplied value. The default error message for this option is _“must be less than %{count}”_.

• :less_than_or_equal_to - Specifies the value must be less than or equal to the supplied value. The default error message for this option is _“must be less than or equal to %{count}”_.

• :other_than - Specifies the value must not be equal to the supplied value. The default error message for this option is _“must be other than %{count}”_.

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

The validator requires at least one of the following checks to be supplied. Each will accept a proc, value, or a symbol which corresponds to a method:

• :greater_than

• :greater_than_or_equal_to

• :equal_to

• :less_than

• :less_than_or_equal_to

• :other_than

For example:

class Person < ActiveRecord::Base
  validates_comparison_of :birth_date, less_than_or_equal_to: -> { Date.today }
  validates_comparison_of :preferred_name, other_than: :given_name, allow_nil: true
end

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

• :case_sensitive - Looks for an exact match. Ignored by non-text columns (true by default).

There is also a list of default options supported by every validator: :if, :unless, :on, :allow_nil, :allow_blank, and :strict. See ActiveModel::Validations::ClassMethods#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::Validations::ClassMethods#validates for more information.

Validates that the specified attributes match the length restrictions supplied. Only one constraint option can be used at a time apart from :minimum and :maximum that can be combined together:

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 :words_in_essay, minimum: 100, too_short: 'Your essay must be at least 100 words.'

  private
    def words_in_essay
      essay.scan(/\w+/)
    end
end

Constraint 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.

Other options:

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

There is also a list of default options supported by every validator: :if, :unless, :on, and :strict. See ActiveModel::Validations::ClassMethods#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). Precision of Kernel.Float values are guaranteed up to 15 digits.

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 (default is false).

• :only_numeric - Specifies whether the value has to be an instance of Numeric (default is false). The default behavior is to attempt parsing the value if it is a String.

• :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. The default error message for this option is _“must be greater than %{count}”_.

• :greater_than_or_equal_to - Specifies the value must be greater than or equal the supplied value. The default error message for this option is _“must be greater than or equal to %{count}”_.

• :equal_to - Specifies the value must be equal to the supplied value. The default error message for this option is _“must be equal to %{count}”_.

• :less_than - Specifies the value must be less than the supplied value. The default error message for this option is _“must be less than %{count}”_.

• :less_than_or_equal_to - Specifies the value must be less than or equal the supplied value. The default error message for this option is _“must be less than or equal to %{count}”_.

• :other_than - Specifies the value must be other than the supplied value. The default error message for this option is _“must be other than %{count}”_.

• :odd - Specifies the value must be an odd number. The default error message for this option is _“must be odd”_.

• :even - Specifies the value must be an even number. The default error message for this option is _“must be even”_.

• :in - Check that the value is within a range. The default error message for this option is _“must be in %{count}”_.

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

• :other_than

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

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::Validations::ClassMethods#validates for more information.