Parent

Included Modules

Class Index [+]

Quicksearch

ActiveModel::Errors

Active Model Errors

Provides a modified OrderedHash that you can include in your object for handling error messages and interacting with Action Pack helpers.

A minimal implementation could be:

  class Person

    # Required dependency for ActiveModel::Errors
    extend ActiveModel::Naming

    def initialize
      @errors = ActiveModel::Errors.new(self)
    end

    attr_accessor :name
    attr_reader   :errors

    def validate!
      errors.add(:name, "can not be nil") if name == nil
    end

    # The following methods are needed to be minimally implemented

    def read_attribute_for_validation(attr)
      send(attr)
    end

    def Person.human_attribute_name(attr, options = {})
      attr
    end

    def Person.lookup_ancestors
      [self]
    end

  end

The last three methods are required in your object for Errors to be able to generate error messages correctly and also handle multiple languages. Of course, if you extend your object with ActiveModel::Translation you will not need to implement the last two. Likewise, using ActiveModel::Validations will handle the validation related methods for you.

The above allows you to do:

  p = Person.new
  p.validate!             # => ["can not be nil"]
  p.errors.full_messages  # => ["name can not be nil"]
  # etc..

Constants

CALLBACKS_OPTIONS

Attributes

messages[R]

Public Class Methods

new(base) click to toggle source

Pass in the instance of the object that is using the errors object.

  class Person
    def initialize
      @errors = ActiveModel::Errors.new(self)
    end
  end
    # File lib/active_model/errors.rb, line 77
77:     def initialize(base)
78:       @base     = base
79:       @messages = ActiveSupport::OrderedHash.new
80:     end

Public Instance Methods

[](attribute) click to toggle source

When passed a symbol or a name of a method, returns an array of errors for the method.

  p.errors[:name]   # => ["can not be nil"]
  p.errors['name']  # => ["can not be nil"]
     # File lib/active_model/errors.rb, line 126
126:     def [](attribute)
127:       get(attribute.to_sym) || set(attribute.to_sym, [])
128:     end
[]=(attribute, error) click to toggle source

Adds to the supplied attribute the supplied error message.

  p.errors[:name] = "must be set"
  p.errors[:name] # => ['must be set']
     # File lib/active_model/errors.rb, line 134
134:     def []=(attribute, error)
135:       self[attribute] << error
136:     end
add(attribute, message = nil, options = {}) click to toggle source

Adds message to the error messages on attribute. More than one error can be added to the same attribute. If no message is supplied, :invalid is assumed.

If message is a symbol, it will be translated using the appropriate scope (see translate_error). If message is a proc, it will be called, allowing for things like Time.now to be used within an error.

     # File lib/active_model/errors.rb, line 233
233:     def add(attribute, message = nil, options = {})
234:       message = normalize_message(attribute, message, options)
235:       if options[:strict]
236:         raise ActiveModel::StrictValidationFailed, full_message(attribute, message)
237:       end
238: 
239:       self[attribute] << message
240:     end
add_on_blank(attributes, options = {}) click to toggle source

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

     # File lib/active_model/errors.rb, line 252
252:     def add_on_blank(attributes, options = {})
253:       [attributes].flatten.each do |attribute|
254:         value = @base.send(:read_attribute_for_validation, attribute)
255:         add(attribute, :blank, options) if value.blank?
256:       end
257:     end
add_on_empty(attributes, options = {}) click to toggle source

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

     # File lib/active_model/errors.rb, line 243
243:     def add_on_empty(attributes, options = {})
244:       [attributes].flatten.each do |attribute|
245:         value = @base.send(:read_attribute_for_validation, attribute)
246:         is_empty = value.respond_to?(:empty?) ? value.empty? : false
247:         add(attribute, :empty, options) if value.nil? || is_empty
248:       end
249:     end
added?(attribute, message = nil, options = {}) click to toggle source

Returns true if an error on the attribute with the given message is present, false otherwise. message is treated the same as for add.

  p.errors.add :name, :blank
  p.errors.added? :name, :blank # => true
     # File lib/active_model/errors.rb, line 263
263:     def added?(attribute, message = nil, options = {})
264:       message = normalize_message(attribute, message, options)
265:       self[attribute].include? message
266:     end
as_json(options=nil) click to toggle source

Returns an ActiveSupport::OrderedHash that can be used as the JSON representation for this object.

     # File lib/active_model/errors.rb, line 219
219:     def as_json(options=nil)
220:       to_hash
221:     end
blank?() click to toggle source
Alias for: empty?
clear() click to toggle source

Clear the messages

    # File lib/active_model/errors.rb, line 96
96:     def clear
97:       messages.clear
98:     end
count() click to toggle source

Returns the number of error messages.

  p.errors.add(:name, "can't be blank")
  p.errors.count # => 1
  p.errors.add(:name, "must be specified")
  p.errors.count # => 2
     # File lib/active_model/errors.rb, line 192
192:     def count
193:       to_a.size
194:     end
delete(key) click to toggle source

Delete messages for key

     # File lib/active_model/errors.rb, line 117
117:     def delete(key)
118:       messages.delete(key)
119:     end
each() click to toggle source

Iterates through each error key, value pair in the error messages hash. Yields the attribute and the error for that attribute. If the attribute has more than one error message, yields once for each error message.

  p.errors.add(:name, "can't be blank")
  p.errors.each do |attribute, errors_array|
    # Will yield :name and "can't be blank"
  end

  p.errors.add(:name, "must be specified")
  p.errors.each do |attribute, errors_array|
    # Will yield :name and "can't be blank"
    # then yield :name and "must be specified"
  end
     # File lib/active_model/errors.rb, line 152
152:     def each
153:       messages.each_key do |attribute|
154:         self[attribute].each { |error| yield attribute, error }
155:       end
156:     end
empty?() click to toggle source

Returns true if no errors are found, false otherwise. If the error message is a string it can be empty.

     # File lib/active_model/errors.rb, line 198
198:     def empty?
199:       all? { |k, v| v && v.empty? && !v.is_a?(String) }
200:     end
Also aliased as: blank?
full_message(attribute, message) click to toggle source

Returns a full message for a given attribute.

  company.errors.full_message(:name, "is invalid")  # =>
    "Name is invalid"
     # File lib/active_model/errors.rb, line 286
286:     def full_message(attribute, message)
287:       return message if attribute == :base
288:       attr_name = attribute.to_s.gsub('.', '_').humanize
289:       attr_name = @base.class.human_attribute_name(attribute, :default => attr_name)
290:       I18n.t(:"errors.format", {
291:         :default   => "%{attribute} %{message}",
292:         :attribute => attr_name,
293:         :message   => message
294:       })
295:     end
full_messages() click to toggle source

Returns all the full error messages in an array.

  class Company
    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", "Email can't be blank"]
     # File lib/active_model/errors.rb, line 278
278:     def full_messages
279:       map { |attribute, message| full_message(attribute, message) }
280:     end
generate_message(attribute, type = :invalid, options = {}) click to toggle source

Translates an error message in its default scope (activemodel.errors.messages).

Error messages are first looked up in models.MODEL.attributes.ATTRIBUTE.MESSAGE, if it’s not there, it’s looked up in models.MODEL.MESSAGE and if that is not there also, it returns the translation of the default message (e.g. activemodel.errors.messages.MESSAGE). The translated model name, translated attribute name and the value are available for interpolation.

When using inheritance in your models, it will check all the inherited models too, but only if the model itself hasn’t been found. Say you have class Admin < User; end and you wanted the translation for the :blank error message for the title attribute, it looks for these translations:

  • activemodel.errors.models.admin.attributes.title.blank

  • activemodel.errors.models.admin.blank

  • activemodel.errors.models.user.attributes.title.blank

  • activemodel.errors.models.user.blank

  • any default you provided through the options hash (in the activemodel.errors scope)

  • activemodel.errors.messages.blank

  • errors.attributes.title.blank

  • errors.messages.blank

     # File lib/active_model/errors.rb, line 321
321:     def generate_message(attribute, type = :invalid, options = {})
322:       type = options.delete(:message) if options[:message].is_a?(Symbol)
323: 
324:       if @base.class.respond_to?(:i18n_scope)
325:         defaults = @base.class.lookup_ancestors.map do |klass|
326:           [ :"#{@base.class.i18n_scope}.errors.models.#{klass.model_name.i18n_key}.attributes.#{attribute}.#{type}",
327:             :"#{@base.class.i18n_scope}.errors.models.#{klass.model_name.i18n_key}.#{type}" ]
328:         end
329:       else
330:         defaults = []
331:       end
332: 
333:       defaults << options.delete(:message)
334:       defaults << :"#{@base.class.i18n_scope}.errors.messages.#{type}" if @base.class.respond_to?(:i18n_scope)
335:       defaults << :"errors.attributes.#{attribute}.#{type}"
336:       defaults << :"errors.messages.#{type}"
337: 
338:       defaults.compact!
339:       defaults.flatten!
340: 
341:       key = defaults.shift
342:       value = (attribute != :base ? @base.send(:read_attribute_for_validation, attribute) : nil)
343: 
344:       options = {
345:         :default => defaults,
346:         :model => @base.class.model_name.human,
347:         :attribute => @base.class.human_attribute_name(attribute),
348:         :value => value
349:       }.merge(options)
350: 
351:       I18n.translate(key, options)
352:     end
get(key) click to toggle source

Get messages for key

     # File lib/active_model/errors.rb, line 107
107:     def get(key)
108:       messages[key]
109:     end
has_key?(error) click to toggle source
Alias for: include?
include?(error) click to toggle source

Do the error messages include an error with key error?

     # File lib/active_model/errors.rb, line 101
101:     def include?(error)
102:       (v = messages[error]) && v.any?
103:     end
Also aliased as: has_key?
initialize_dup(other) click to toggle source
    # File lib/active_model/errors.rb, line 82
82:     def initialize_dup(other)
83:       @messages = other.messages.dup
84:     end
keys() click to toggle source

Returns all message keys

     # File lib/active_model/errors.rb, line 174
174:     def keys
175:       messages.keys
176:     end
set(key, value) click to toggle source

Set messages for key to value

     # File lib/active_model/errors.rb, line 112
112:     def set(key, value)
113:       messages[key] = value
114:     end
size() click to toggle source

Returns the number of error messages.

  p.errors.add(:name, "can't be blank")
  p.errors.size # => 1
  p.errors.add(:name, "must be specified")
  p.errors.size # => 2
     # File lib/active_model/errors.rb, line 164
164:     def size
165:       values.flatten.size
166:     end
to_a() click to toggle source

Returns an array of error messages, with the attribute name included

  p.errors.add(:name, "can't be blank")
  p.errors.add(:name, "must be specified")
  p.errors.to_a # => ["name can't be blank", "name must be specified"]
     # File lib/active_model/errors.rb, line 183
183:     def to_a
184:       full_messages
185:     end
to_hash() click to toggle source
     # File lib/active_model/errors.rb, line 223
223:     def to_hash
224:       messages.dup
225:     end
to_xml(options={}) click to toggle source

Returns an xml formatted representation of the Errors hash.

  p.errors.add(:name, "can't be blank")
  p.errors.add(:name, "must be specified")
  p.errors.to_xml
  # =>
  #  <?xml version=\"1.0\" encoding=\"UTF-8\"?>
  #  <errors>
  #    <error>name can't be blank</error>
  #    <error>name must be specified</error>
  #  </errors>
     # File lib/active_model/errors.rb, line 214
214:     def to_xml(options={})
215:       to_a.to_xml options.reverse_merge(:root => "errors", :skip_types => true)
216:     end
values() click to toggle source

Returns all message values

     # File lib/active_model/errors.rb, line 169
169:     def values
170:       messages.values
171:     end

Private Instance Methods

normalize_message(attribute, message, options) click to toggle source
     # File lib/active_model/errors.rb, line 355
355:     def normalize_message(attribute, message, options)
356:       message ||= :invalid
357: 
358:       if message.is_a?(Symbol)
359:         generate_message(attribute, message, options.except(*CALLBACKS_OPTIONS))
360:       elsif message.is_a?(Proc)
361:         message.call
362:       else
363:         message
364:       end
365:     end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.