# module ActiveModel::Validations::HelperMethods

### Public Instance Methods

validates_absence_of(*attr_names) click to toggle source

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

    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#validates` for more information

    # File lib/active_model/validations/absence.rb, line 26
    def validates_absence_of(*attr_names)
      validates_with AbsenceValidator, _merge_attributes(attr_names)
    end

validates_acceptance_of(*attr_names) click to toggle source

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 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#validates` for more information.

    # File lib/active_model/validations/acceptance.rb, line 99
    def validates_acceptance_of(*attr_names)
      validates_with AcceptanceValidator, _merge_attributes(attr_names)
    end

validates_confirmation_of(*attr_names) click to toggle source

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#validates` for more information

    # File lib/active_model/validations/confirmation.rb, line 73
    def validates_confirmation_of(*attr_names)
      validates_with ConfirmationValidator, _merge_attributes(attr_names)
    end

validates_exclusion_of(*attr_names) click to toggle source

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 numerical, time or datetime 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` `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::Validations#validates` for more information

    # File lib/active_model/validations/exclusion.rb, line 42
    def validates_exclusion_of(*attr_names)
      validates_with ExclusionValidator, _merge_attributes(attr_names)
    end

validates_format_of(*attr_names) click to toggle source

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#validates` for more information

    # File lib/active_model/validations/format.rb, line 108
    def validates_format_of(*attr_names)
      validates_with FormatValidator, _merge_attributes(attr_names)
    end

validates_inclusion_of(*attr_names) click to toggle source

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, time or datetime 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::Validations#validates` for more information

    # File lib/active_model/validations/inclusion.rb, line 40
    def validates_inclusion_of(*attr_names)
      validates_with InclusionValidator, _merge_attributes(attr_names)
    end

validates_length_of(*attr_names) click to toggle source

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#validates` for more information

    # File lib/active_model/validations/length.rb, line 114
    def validates_length_of(*attr_names)
      validates_with LengthValidator, _merge_attributes(attr_names)
    end

Also aliased as: validates_size_of
validates_numericality_of(*attr_names) click to toggle source

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::Validations#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

    # File lib/active_model/validations/numericality.rb, line 158
    def validates_numericality_of(*attr_names)
      validates_with NumericalityValidator, _merge_attributes(attr_names)
    end

validates_presence_of(*attr_names) click to toggle source

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

    # File lib/active_model/validations/presence.rb, line 33
    def validates_presence_of(*attr_names)
      validates_with PresenceValidator, _merge_attributes(attr_names)
    end

validates_size_of(*attr_names)
Alias for: validates_length_of