Class: ActiveRecord::Errors

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/active_record/validations.rb

Overview

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.

Constant Summary collapse

@@default_error_messages = 
{
  :inclusion => "is not included in the list",
  :exclusion => "is reserved",
  :invalid => "is invalid",
  :confirmation => "doesn't match confirmation",
  :accepted  => "must be accepted",
  :empty => "can't be empty",
  :blank => "can't be blank",
  :too_long => "is too long (maximum is %d characters)",
  :too_short => "is too short (minimum is %d characters)",
  :wrong_length => "is the wrong length (should be %d characters)",
  :taken => "has already been taken",
  :not_a_number => "is not a number",
  :greater_than => "must be greater than %d",
  :greater_than_or_equal_to => "must be greater than or equal to %d",
  :equal_to => "must be equal to %d",
  :less_than => "must be less than %d",
  :less_than_or_equal_to => "must be less than or equal to %d",
  :odd => "must be odd",
  :even => "must be even"
}

Instance Method Summary collapse

Constructor Details

#initialize(base) ⇒ Errors

:nodoc:



22
23
24
 
# File 'lib/active_record/validations.rb', line 22

def initialize(base) # :nodoc:
  @base, @errors = base, {}
end

Instance Method Details

#add(attribute, msg = @@default_error_messages[:invalid]) ⇒ Object

Adds an error message (msg) 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 msg is supplied, “invalid” is assumed.



64
65
66
67
 
# File 'lib/active_record/validations.rb', line 64

def add(attribute, msg = @@default_error_messages[:invalid])
  @errors[attribute.to_s] = [] if @errors[attribute.to_s].nil?
  @errors[attribute.to_s] << msg
end

#add_on_blank(attributes, msg = ) ⇒ Object

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



79
80
81
82
83
84
 
# File 'lib/active_record/validations.rb', line 79

def add_on_blank(attributes, msg = @@default_error_messages[:blank])
  for attr in [attributes].flatten
    value = @base.respond_to?(attr.to_s) ? @base.send(attr.to_s) : @base[attr.to_s]
    add(attr, msg) if value.blank?
  end
end

#add_on_empty(attributes, msg = ) ⇒ Object

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



70
71
72
73
74
75
76
 
# File 'lib/active_record/validations.rb', line 70

def add_on_empty(attributes, msg = @@default_error_messages[:empty])
  for attr in [attributes].flatten
    value = @base.respond_to?(attr.to_s) ? @base.send(attr.to_s) : @base[attr.to_s]
    is_empty = value.respond_to?("empty?") ? value.empty? : false
    add(attr, msg) unless !value.nil? && !is_empty
  end
end

#add_to_base(msg) ⇒ Object

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.



56
57
58
 
# File 'lib/active_record/validations.rb', line 56

def add_to_base(msg)
  add(:base, msg)
end

#clear ⇒ Object

Removes all errors that have been added.



192
193
194
 
# File 'lib/active_record/validations.rb', line 192

def clear
  @errors = {}
end

#each ⇒ Object

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



138
139
140
 
# File 'lib/active_record/validations.rb', line 138

def each
  @errors.each_key { |attr| @errors[attr].each { |msg| yield attr, msg } }
end

#each_full ⇒ Object

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



155
156
157
 
# File 'lib/active_record/validations.rb', line 155

def each_full
  full_messages.each { |msg| yield msg }
end

#empty? ⇒ Boolean

Returns true if no errors have been added.

Returns:

  • (Boolean) 


187
188
189
 
# File 'lib/active_record/validations.rb', line 187

def empty?
  @errors.empty?
end

#full_messages ⇒ Object

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"]



169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'lib/active_record/validations.rb', line 169

def full_messages
  full_messages = []

  @errors.each_key do |attr|
    @errors[attr].each do |msg|
      next if msg.nil?

      if attr == "base"
        full_messages << msg
      else
        full_messages << @base.class.human_attribute_name(attr) + " " + msg
      end
    end
  end
  full_messages
end

#invalid?(attribute) ⇒ Boolean

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

Returns:

  • (Boolean) 


96
97
98
 
# File 'lib/active_record/validations.rb', line 96

def invalid?(attribute)
  !@errors[attribute.to_s].nil?
end

#on(attribute) ⇒ Object Also known as: []

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



113
114
115
116
117
 
# File 'lib/active_record/validations.rb', line 113

def on(attribute)
  errors = @errors[attribute.to_s]
  return nil if errors.nil?
  errors.size == 1 ? errors.first : errors
end

#on_base ⇒ Object

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



122
123
124
 
# File 'lib/active_record/validations.rb', line 122

def on_base
  on(:base)
end

#size ⇒ Object Also known as: count, length

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



197
198
199
 
# File 'lib/active_record/validations.rb', line 197

def size
  @errors.values.inject(0) { |error_count, attribute| error_count + attribute.size }
end

#to_xml(options = {}) ⇒ Object

Return 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>



219
220
221
222
223
224
225
226
227
228
 
# File 'lib/active_record/validations.rb', line 219

def to_xml(options={})
  options[:root] ||= "errors"
  options[:indent] ||= 2
  options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])

  options[:builder].instruct! unless options.delete(:skip_instruct)
  options[:builder].errors do |e|
    full_messages.each { |msg| e.error(msg) }
  end
end