This validation macro solves the problem of making sure that a user has accepted some agreement or terms of service. The typical way of confirming an agreement like this is with a check box in a form. When a controller passes the parameters from such a form to update the attributes of a model, the value of the checkbox is passed in as well. The value of the checkbox doesn't need to be saved to the database, though, so this validation is not performed on a column attribute but rather on an in-memory attribute which is automatically added to the model.

class User < ActiveRecord::Base
  validates_acceptance_of :terms_of_service
end

For this example, the check box could be constructed in its form like this:

<% form_for @user do |user| %>
  ...
  <%= user.check_box :terms_of_service %>
<% end %>

The validates_acceptance_of macro takes all the standard options for validations like :message and :on, plus these:

This macro is a handy way to validate that a user can type in the same thing twice. Most often used for password fields. This is very similar to validates_acceptance_of, in that it validates the value of an automatically generated attribute.

class User < ActiveRecord::Base
  validates_confirmation_of :password
end

In this example, the generated attribute will be called password_confirmation, so you need to give the form field this name.

Validates each named attribute with a given block of code. The block is called with three arguments: the model instance, the symbol of the attribute being validated, and the value of that attribute. The block is responsible for adding errors to the model instance as appropriate. This validator forms the basis of all other validators.

class User < ActiveRecord::Base
  validates_each :first_name, :last_name do |record, attribute, value|
    if ['Kirk', 'Spock', 'Bones'].include?(value)
      record.errors.add(attribute, "must not have served on the Enterprise")
    end
  end
end

Validates that the values of the given attributes are not found in some set of banned values. The blacklist can be represented by any Enumerable object, passed to the macro with the :in option:

class User < ActiveRecord::Base
  validates_exclusion_of :first_name, :last_name,
    :in => ['Kirk', 'Spock', 'Bones'],
    :message => "must not have served on the Enterprise"
end

Checks the given attributes against a regular expression, adding an error if the value does not match.

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

Inverse of validates_exclusion_of, ensuring that the values of the given attributes are included in a set of allowed values.

class User < ActiveRecord::Base
  validates_inclusion_of :date_of_birth,
    :in => (130.years.ago.to_date .. Date.today),
    :message => "must be at least plausibly human"
end

Validates the size of the given attributes' values. This can be used on any values which respond to a size method call, so it will mean different things for strings as opposed to arrays or other enumerables. You can specify a Range of allowed values with the :in option, as in validates_inclusion_of, or you can just specify a :minimum or :maximum value.

class User < ActiveRecord::Base
  validates_length_of :password,
    :in => 6..20
end

In addition to a general :message option, you can specify :too_short and :too_long messages which are used in each case.

Validates that the values of the given attributes are numbers of some kind, or strings which represent numbers. This macro also lets you ensure that the value follows other constraints like being greater than or less than particular limits.

class Product < ActiveRecord::Base
  validates_numericality_of :price,
    :greater_than_or_equal_to => 0.00,
    :message => "must be a non-negative number"
end

Validates that the given attributes are not blank, by calling blank? on their values. This macro is not implicitly included by any other macros, so if you need a particular attribute to be present, you should use the macro in addition to any others you have for that attribute.

class User < ActiveRecord::Base
  validates_presence_of :first_name, :last_name, :email, :password
end