Class | ActiveRecord::Errors
In: | lib/active_record/validations.rb
Parent: | Object

Active Record validation is reported to and from this object, which is used by Base#save to determine whether the object is in a valid state to be saved. See usage example in Validations.

### Methods

[] add add_on_blank add_on_empty add_to_base clear count default_error_messages each each_error each_full empty? full_messages generate_message invalid? length on on_base size to_xml

### Included Modules

Enumerable

### Public Class methods

default_error_messages()

### Public Instance methods

[](attribute)

Alias for on

add(error_or_attr, message = nil, options = {})

Adds an error message (`messsage`) to the `attribute`, which will be returned on a call to `on(attribute)` for the same attribute and ensure that this error object returns false when asked if `empty?`. More than one error can be added to the same `attribute` in which case an array will be returned on a call to `on(attribute)`. If no `messsage` is supplied, :invalid is assumed. If `message` is a Symbol, it will be translated, using the appropriate scope (see translate_error). def add(attribute, message = nil, options = {})

      message ||= :invalid
      message = generate_message(attribute, message, options)) if message.is_a?(Symbol)
      @errors[attribute.to_s] ||= []
      @errors[attribute.to_s] << message

end

add_on_blank(attributes, custom_message = nil)

Will add an error message to each of the attributes in `attributes` that is blank (using Object#blank?).

add_on_empty(attributes, custom_message = nil)

Will add an error message to each of the attributes in `attributes` that is empty.

add_to_base(msg)

Adds an error to the base object instead of any particular attribute. This is used to report errors that don‘t tie to any specific attribute, but rather to the object as a whole. These error messages don‘t get prepended with any field name when iterating with `each_full`, so they should be complete sentences.

clear()

Removes all errors that have been added.

count()

Alias for size

each() {|attr, error.message| ...}

Yields each attribute and associated message per error added.

      class Company < ActiveRecord::Base
        validates_presence_of :name, :address, :email
        validates_length_of :name, :in => 5..30
      end

      company = Company.create(:address => '123 First St.')
      company.errors.each{|attr,msg| puts "#{attr} - #{msg}" }
      # => name - is too short (minimum is 5 characters)
      #    name - can't be blank
      #    address - can't be blank

each_error() {|attr, error| ...}
each_full() {|msg| ...}

Yields each full error message added. So `Person.errors.add("first_name", "can‘t be empty")` will be returned through iteration as "First name can‘t be empty".

      class Company < ActiveRecord::Base
        validates_presence_of :name, :address, :email
        validates_length_of :name, :in => 5..30
      end

      company = Company.create(:address => '123 First St.')
      company.errors.each_full{|msg| puts msg }
      # => Name is too short (minimum is 5 characters)
      #    Name can't be blank
      #    Address can't be blank

empty?()

Returns true if no errors have been added.

full_messages(options = {})

Returns all the full error messages in an array.

      class Company < ActiveRecord::Base
        validates_presence_of :name, :address, :email
        validates_length_of :name, :in => 5..30
      end

      company = Company.create(:address => '123 First St.')
      company.errors.full_messages # =>
        ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Address can't be blank"]

generate_message(attribute, message = :invalid, options = {})
invalid?(attribute)

Returns true if the specified `attribute` has errors associated with it.

      class Company < ActiveRecord::Base
        validates_presence_of :name, :address, :email
        validates_length_of :name, :in => 5..30
      end

      company = Company.create(:address => '123 First St.')
      company.errors.invalid?(:name)      # => true
      company.errors.invalid?(:address)   # => false

length()

Alias for size

on(attribute)

Returns `nil`, if no errors are associated with the specified `attribute`. Returns the error message, if one error is associated with the specified `attribute`. Returns an array of error messages, if more than one error is associated with the specified `attribute`.

      class Company < ActiveRecord::Base
        validates_presence_of :name, :address, :email
        validates_length_of :name, :in => 5..30
      end

      company = Company.create(:address => '123 First St.')
      company.errors.on(:name)      # => ["is too short (minimum is 5 characters)", "can't be blank"]
      company.errors.on(:email)     # => "can't be blank"
      company.errors.on(:address)   # => nil

on_base()

Returns errors assigned to the base object through `add_to_base` according to the normal rules of `on(attribute)`.

size()

Returns the total number of errors added. Two errors added to the same attribute will be counted as such.

to_xml(options={})

Returns an XML representation of this error object.

      class Company < ActiveRecord::Base
        validates_presence_of :name, :address, :email
        validates_length_of :name, :in => 5..30
      end

      company = Company.create(:address => '123 First St.')
      company.errors.to_xml
      # =>  <?xml version="1.0" encoding="UTF-8"?>
      #     <errors>
      #       <error>Name is too short (minimum is 5 characters)</error>
      #       <error>Name can't be blank</error>
      #       <error>Address can't be blank</error>
      #     </errors>

[Validate]