module ActiveModel::Validations::HelperMethods

def _merge_attributes(attr_names)
  options = attr_names.extract_options!.symbolize_keys
  attr_names.flatten!
  options[:attributes] = attr_names
  options
end

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

* :message - A custom error message (default is: "must be blank").
Configuration options:

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

end
validates_absence_of :first_name
class Person < ActiveRecord::Base

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

def validates_absence_of(*attr_names)
  validates_with AbsenceValidator, _merge_attributes(attr_names)
end

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

before validation.
a database column, since the attribute is typecast from "1" to +true+
checkbox. This should be set to, or include, +true+ if you are validating
an array ["1", true], which makes it easy to relate to an HTML
Also accepts an array of possible values. The default value is
* :accept - Specifies a value that is considered accepted.
accepted").
* :message - A custom error message (default is: "must be
Configuration options:

is not +nil+.
is entirely virtual. This check is performed only if +terms_of_service+
If the database column does not exist, the +terms_of_service+ attribute

end
validates_acceptance_of :eula, message: 'must be abided'
validates_acceptance_of :terms_of_service
class Person < ActiveRecord::Base

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

def validates_acceptance_of(*attr_names)
  validates_with AcceptanceValidator, _merge_attributes(attr_names)
end

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

For example:

* :other_than
* :less_than_or_equal_to
* :less_than
* :equal_to
* :greater_than_or_equal_to
* :greater_than

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

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

other than %{count}"_.
supplied value. The default error message for this option is _"must be
* :other_than - Specifies the value must not be equal to the
this option is _"must be less than or equal to %{count}"_.
than or equal to the supplied value. The default error message for
* :less_than_or_equal_to - Specifies the value must be less
less than %{count}"_.
supplied value. The default error message for this option is _"must be
* :less_than - Specifies the value must be less than the
%{count}"_.
value. The default error message for this option is _"must be equal to
* :equal_to - Specifies the value must be equal to the supplied
for this option is _"must be greater than or equal to %{count}"_.
greater than or equal to the supplied value. The default error message
* :greater_than_or_equal_to - Specifies the value must be
greater than %{count}"_.
supplied value. The default error message for this option is _"must be
* :greater_than - Specifies the value must be greater than the
* :message - A custom error message (default is: "failed comparison").
Configuration options:

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

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

def validates_comparison_of(*attr_names)
  validates_with ComparisonValidator, _merge_attributes(attr_names)
end

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

non-text columns (+true+ by default).
* :case_sensitive - Looks for an exact match. Ignored by
%{translated_attribute_name}").
* :message - A custom error message (default is: "doesn't match
Configuration options:

validates_presence_of :password_confirmation, if: :password_changed?

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

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

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

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

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

def validates_confirmation_of(*attr_names)
  validates_with ConfirmationValidator, _merge_attributes(attr_names)
end

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

reserved").
* :message - Specifies a custom error message (default is: "is
Range#cover?, otherwise with include?.
* :within - A synonym(or alias) for :in
using a proc or lambda the instance under validation is passed as an argument.
is performed with Range#cover?, otherwise with include?. When
enumerable. If the enumerable is a numerical, time, or datetime range the test
be part of. This can be supplied as a proc, lambda, or symbol which returns an
* :in - An enumerable object of items that the value shouldn't
Configuration options:

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

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

def validates_exclusion_of(*attr_names)
  validates_with ExclusionValidator, _merge_attributes(attr_names)
end

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

beginning or end of the string. These anchors are ^ and $.
anchors that match the beginning or end of lines as opposed to the
* :multiline - Set to true if your regular expression contains
runtime.
a proc or lambda returning regular expression which will be called at
match will result in a successful validation. This can be provided as
* :without - Regular expression that if the attribute does not
lambda returning regular expression which will be called at runtime.
result in a successful validation. This can be provided as a proc or
* :with - Regular expression that if the attribute matches will
* :message - A custom error message (default is: "is invalid").
Configuration options:

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

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

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

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

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

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

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

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

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

def validates_format_of(*attr_names)
  validates_with FormatValidator, _merge_attributes(attr_names)
end

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

not included in the list").
* :message - Specifies a custom error message (default is: "is
* :within - A synonym(or alias) for :in
a proc or lambda the instance under validation is passed as an argument.
with Range#cover?, otherwise with include?. When using
enumerable is a numerical, time, or datetime range the test is performed
supplied as a proc, lambda, or symbol which returns an enumerable. If the
* :in - An enumerable object of available items. This can be
Configuration options:

end
validates_inclusion_of :karma, in: :available_karmas
validates_inclusion_of :states, in: ->(person) { STATES[person.country] }
validates_inclusion_of :format, in: %w( jpg gif png ), message: "extension %{value} is not included in the list"
validates_inclusion_of :age, in: 0..99
validates_inclusion_of :role, in: %w( admin contributor )
class Person < ActiveRecord::Base

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

def validates_inclusion_of(*attr_names)
  validates_with InclusionValidator, _merge_attributes(attr_names)
end

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

too_long/too_short/wrong_length message.
:maximum, or :is violation. An alias of the appropriate
* :message - The error message to use for a :minimum,
length (should be %{count} characters)").
method and the attribute is the wrong size (default is: "is the wrong
* :wrong_length - The error message if using the :is
minimum (default is: "is too short (minimum is %{count} characters)").
* :too_short - The error message if the attribute goes under the
maximum (default is: "is too long (maximum is %{count} characters)").
* :too_long - The error message if the attribute goes over the
* :allow_blank - Attribute may be blank; skip validation.
* :allow_nil - Attribute may be +nil+; skip validation.

Other options:

* :in - A synonym (or alias) for :within.
the attribute.
* :within - A range specifying the minimum and maximum size of
* :is - The exact size of the attribute.
default if not used with +:minimum+.
* :maximum - The maximum size of the attribute. Allows +nil+ by
* :minimum - The minimum size of the attribute.

Constraint options:

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

validates_length_of :words_in_essay, minimum: 100, too_short: 'Your essay must be at least 100 words.'
validates_length_of :smurf_leader, is: 4, message: "papa is spelled with 4 characters... don't play me."
validates_length_of :zip_code, minimum: 5, too_short: 'please enter at least 5 characters'
validates_length_of :user_name, within: 6..20, too_long: 'pick a shorter name', too_short: 'pick a longer name'
validates_length_of :phone, in: 7..32, allow_blank: true
validates_length_of :fax, in: 7..32, allow_nil: true
validates_length_of :last_name, maximum: 30, message: "less than 30 if you don't mind"
validates_length_of :first_name, maximum: 30
class Person < ActiveRecord::Base

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

def validates_length_of(*attr_names)
  validates_with LengthValidator, _merge_attributes(attr_names)
end

end
validates_numericality_of :width, greater_than: :minimum_weight
validates_numericality_of :width, less_than: ->(person) { person.height }
class Person < ActiveRecord::Base

For example:

* :other_than
* :only_integer
* :less_than_or_equal_to
* :less_than
* :equal_to
* :greater_than_or_equal_to
* :greater_than

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

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

error message for this option is _"must be in %{count}"_.
* :in - Check that the value is within a range. The default
default error message for this option is _"must be even"_.
* :even - Specifies the value must be an even number. The
error message for this option is _"must be odd"_.
* :odd - Specifies the value must be an odd number. The default
other than %{count}"_.
supplied value. The default error message for this option is _"must be
* :other_than - Specifies the value must be other than the
option is _"must be less than or equal to %{count}"_.
than or equal the supplied value. The default error message for this
* :less_than_or_equal_to - Specifies the value must be less
less than %{count}"_.
supplied value. The default error message for this option is _"must be
* :less_than - Specifies the value must be less than the
%{count}"_.
value. The default error message for this option is _"must be equal to
* :equal_to - Specifies the value must be equal to the supplied
for this option is _"must be greater than or equal to %{count}"_.
greater than or equal the supplied value. The default error message
* :greater_than_or_equal_to - Specifies the value must be
greater than %{count}"_.
supplied value. The default error message for this option is _"must be
* :greater_than - Specifies the value must be greater than the
converted to +nil+.
+false+). Notice that for Integer and Float columns empty strings are
* :allow_nil - Skip validation if attribute is +nil+ (default is
attempt parsing the value if it is a String.
instance of Numeric (default is +false+). The default behavior is to
* :only_numeric - Specifies whether the value has to be an
integer (default is +false+).
* :only_integer - Specifies whether the value has to be an
* :message - A custom error message (default is: "is not a number").
Configuration options:

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

digits.
+true+). Precision of +Kernel.Float+ values are guaranteed up to 15
expression /\A[\+\-]?\d+\z/ (if only_integer is set to
only_integer is +false+) or applying it to the regular
trying to convert it to a float with +Kernel.Float+ (if
Validates whether the value of the specified attribute is numeric by

def validates_numericality_of(*attr_names)
  validates_with NumericalityValidator, _merge_attributes(attr_names)
end

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

* :message - A custom error message (default is: "can't be blank").
Configuration options:

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

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

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

end
validates_presence_of :first_name
class Person < ActiveRecord::Base

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

def validates_presence_of(*attr_names)
  validates_with PresenceValidator, _merge_attributes(attr_names)
end