validates

This method is a shortcut to all default validators and any custom validator classes ending in ‘Validator’. Note that Rails default validators can be overridden inside specific classes by creating custom validator classes in their place such as PresenceValidator.

Examples of using the default rails validators:

validates :terms, acceptance: true
validates :password, confirmation: true
validates :username, exclusion: { in: %w(admin superuser) }
validates :email, format: { with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i, on: :create }
validates :age, inclusion: { in: 0..9 }
validates :first_name, length: { maximum: 30 }
validates :age, numericality: true
validates :username, presence: true
validates :username, uniqueness: true

The power of the validates method comes when using custom validators and default validators in one call for a given attribute.

class EmailValidator < ActiveModel::EachValidator
  def validate_each(record, attribute, value)
    record.errors.add attribute, (options[:message] || "is not an email") unless
      value =~ /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i
  end
end

class Person
  include ActiveModel::Validations
  attr_accessor :name, :email

  validates :name, presence: true, uniqueness: true, length: { maximum: 100 }
  validates :email, presence: true, email: true
end

Validator classes may also exist within the class being validated allowing custom modules of validators to be included as needed.

class Film
  include ActiveModel::Validations

  class TitleValidator < ActiveModel::EachValidator
    def validate_each(record, attribute, value)
      record.errors.add attribute, "must start with 'the'" unless value =~ /\Athe/i
    end
  end

  validates :name, title: true
end

Additionally validator classes may be in another namespace and still used within any class.

validates :name, :'film/title' => true

The validators hash can also handle regular expressions, ranges, arrays and strings in shortcut form.

validates :email, format: /@/
validates :gender, inclusion: %w(male female)
validates :password, length: 6..20

When using shortcut form, ranges and arrays are passed to your validator’s initializer as options[:in] while other types including regular expressions and strings are passed as options[:with].

There is also a list of options that could be used along with validators:

• :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 - if the :strict option is set to true will raise ActiveModel::StrictValidationFailed instead of adding the error. :strict option can also be set to any other exception.

Example:

validates :password, presence: true, confirmation: true, if: :password_required?
validates :token, uniqueness: true, strict: TokenGenerationException

Finally, the options :if, :unless, :on, :allow_blank, :allow_nil, :strict and :message can be given to one specific validator, as a hash:

validates :password, presence: { if: :password_required?, message: 'is forgotten.' }, confirmation: true

# File activemodel/lib/active_model/validations/validates.rb, line 100
      def validates(*attributes)
        defaults = attributes.extract_options!.dup
        validations = defaults.slice!(*_validates_default_keys)

        raise ArgumentError, "You need to supply at least one attribute" if attributes.empty?
        raise ArgumentError, "You need to supply at least one validation" if validations.empty?

        defaults[:attributes] = attributes

        validations.each do |key, options|
          next unless options
          key = "#{key.to_s.camelize}Validator"

          begin
            validator = key.include?('::') ? key.constantize : const_get(key)
          rescue NameError
            raise ArgumentError, "Unknown validator: '#{key}'"
          end

          validates_with(validator, defaults.merge(_parse_validates_options(options)))
        end
      end

validates :title, :body, :presence => true

validates [:title, :body], :presence => true
#=> ArgumentError: Attribute names must be symbols

validate :username, :uniqueness => {:case_sensitive => false}

validates :user_name, :presence => true, :uniqueness => {:scope => :account_id}


# the old way  
validates_uniqueness_of :user_name, :scope => :account_id

class EmailValidator < ActiveModel::EachValidator
def validate_each(record, attribute, value)
  record.errors.add(attribute, options[:message] || :email) unless
    value =~ /\\A([^@\\s]+)@((?:[-a-z0-9]+\\.)+[a-z]{2,})\\z/i
end
end

en:
activerecord:
  errors:
    messages:
      email: "is not an email"

validates :invoice_number, :presence => {:message => 'The invoice number must be informed.'}

validates :terms,
acceptance: {
  allow_nil: false,
  accept: true
}

def self.quota_file?
quota_file?
end

class Working

include ActiveModel::Validations

attr_accessor :format

validates :format, :presence => true, :format => { :with => /\\AWorking/ }

end

class NotWorking < ActiveRecord::Base

validates :format, :presence => true, :format => { :with => /\\ANot Working/ }

end

class WorkingAgain < ActiveRecord::Base

validates :format, :presence => true, :format => { :with => /\\AWorking again/ }

def format
  read_attribute(:format)
end

end