Module: ActiveModel::Validations::HelperMethods

### Home Classes Methods

### In Files

- lib/active_model/validations/acceptance.rb
- lib/active_model/validations/confirmation.rb
- lib/active_model/validations/exclusion.rb
- lib/active_model/validations/format.rb
- lib/active_model/validations/inclusion.rb
- lib/active_model/validations/length.rb
- lib/active_model/validations/numericality.rb
- lib/active_model/validations/presence.rb
- lib/active_model/validations/with.rb

### Methods

- #validates_acceptance_of
- #validates_confirmation_of
- #validates_exclusion_of
- #validates_format_of
- #validates_inclusion_of
- #validates_length_of
- #validates_numericality_of
- #validates_presence_of
- #validates_size_of

### Class/Module Index

Quicksearch

- ActiveModel
- ActiveModel::AttributeMethods
- ActiveModel::AttributeMethods::ClassMethods
- ActiveModel::AttributeMethods::ClassMethods::AttributeMethodMatcher
- ActiveModel::BlockValidator
- ActiveModel::Callbacks
- ActiveModel::Conversion
- ActiveModel::Dirty
- ActiveModel::EachValidator
- ActiveModel::Errors
- ActiveModel::Lint
- ActiveModel::Lint::Tests
- ActiveModel::MassAssignmentSecurity
- ActiveModel::MassAssignmentSecurity::BlackList
- ActiveModel::MassAssignmentSecurity::ClassMethods
- ActiveModel::MassAssignmentSecurity::Error
- ActiveModel::MassAssignmentSecurity::LoggerSanitizer
- ActiveModel::MassAssignmentSecurity::PermissionSet
- ActiveModel::MassAssignmentSecurity::Sanitizer
- ActiveModel::MassAssignmentSecurity::StrictSanitizer
- ActiveModel::MassAssignmentSecurity::WhiteList
- ActiveModel::MissingAttributeError
- ActiveModel::Name
- ActiveModel::Naming
- ActiveModel::Observer
- ActiveModel::ObserverArray
- ActiveModel::Observing
- ActiveModel::Observing::ClassMethods
- ActiveModel::SecurePassword
- ActiveModel::SecurePassword::ClassMethods
- ActiveModel::SecurePassword::InstanceMethodsOnActivation
- ActiveModel::Serialization
- ActiveModel::Serializers
- ActiveModel::Serializers::JSON
- ActiveModel::Serializers::Xml
- ActiveModel::StrictValidationFailed
- ActiveModel::Translation
- ActiveModel::Validations
- ActiveModel::Validations::AcceptanceValidator
- ActiveModel::Validations::Callbacks
- ActiveModel::Validations::Callbacks::ClassMethods
- ActiveModel::Validations::ClassMethods
- ActiveModel::Validations::ConfirmationValidator
- ActiveModel::Validations::ExclusionValidator
- ActiveModel::Validations::FormatValidator
- ActiveModel::Validations::HelperMethods
- ActiveModel::Validations::InclusionValidator
- ActiveModel::Validations::LengthValidator
- ActiveModel::Validations::NumericalityValidator
- ActiveModel::Validations::PresenceValidator
- ActiveModel::Validations::WithValidator
- ActiveModel::Validator

No matching classes.

# ActiveModel::Validations::HelperMethods

### Public Instance Methods

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

    # File lib/active_model/validations/acceptance.rb, line 62
    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. 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.

    # File lib/active_model/validations/confirmation.rb, line 62
    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 => 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?`.

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

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

    # File lib/active_model/validations/exclusion.rb, line 74
    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 => 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.

    # File lib/active_model/validations/format.rb, line 100
    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 => 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?`.

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

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

    # File lib/active_model/validations/inclusion.rb, line 74
    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 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.

    # File lib/active_model/validations/length.rb, line 120
    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").

- `: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

    # File lib/active_model/validations/numericality.rb, line 133
    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. 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.

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

validates_size_of(*attr_names) click to toggle source
Alias for: validates_length_of

[Validate]

Generated with the Darkfish Rdoc Generator 2.