Returns a string containing the error message attached to the method on the object if one exists. This error message is wrapped in a DIV tag, which can be extended to include a prepend_text and/or append_text (to properly explain the error), and a css_class to style it accordingly. object should either be the name of an instance variable or the actual object. As an example, let‘s say you have a model post that has an error message on the title attribute:

  <%= error_message_on "post", "title" %> =>
    <div class="formError">can't be empty</div>

  <%= error_message_on @post, "title" %> =>
    <div class="formError">can't be empty</div>

  <%= error_message_on "post", "title", "Title simply ", " (or it won't work).", "inputError" %> =>
    <div class="inputError">Title simply can't be empty (or it won't work).</div>

[Source]

    # File vendor/rails/actionpack/lib/action_view/helpers/active_record_helper.rb, line 91
91:       def error_message_on(object, method, prepend_text = "", append_text = "", css_class = "formError")
92:         if (obj = (object.respond_to?(:errors) ? object : instance_variable_get("@#{object}"))) &&
93:           (errors = obj.errors.on(method))
94:           content_tag("div", "#{prepend_text}#{errors.is_a?(Array) ? errors.first : errors}#{append_text}", :class => css_class)
95:         else 
96:           ''
97:         end
98:       end

Returns a string with a DIV containing all of the error messages for the objects located as instance variables by the names given. If more than one object is specified, the errors for the objects are displayed in the order that the object names are provided.

This DIV can be tailored by the following options:

• header_tag - Used for the header of the error div (default: h2)
• id - The id of the error div (default: errorExplanation)
• class - The class of the error div (default: errorExplanation)
• object - The object (or array of objects) for which to display errors, if you need to escape the instance variable convention
• object_name - The object name to use in the header, or any text that you prefer. If object_name is not set, the name of the first object will be used.
• header_message - The message in the header of the error div. Pass nil or an empty string to avoid the header message altogether. (default: X errors prohibited this object from being saved)
• message - The explanation message after the header message and before the error list. Pass nil or an empty string to avoid the explanation message altogether. (default: There were problems with the following fields:)

To specify the display for one object, you simply provide its name as a parameter. For example, for the User model:

  error_messages_for 'user'

To specify more than one object, you simply list them; optionally, you can add an extra object_name parameter, which will be the name used in the header message.

  error_messages_for 'user_common', 'user', :object_name => 'user'

If the objects cannot be located as instance variables, you can add an extra object paremeter which gives the actual object (or array of objects to use)

  error_messages_for 'user', :object => @question.user

NOTE: This is a pre-packaged presentation of the errors with embedded strings and a certain HTML structure. If what you need is significantly different from the default presentation, it makes plenty of sense to access the object.errors instance yourself and set it up. View the source of this method to see how easy it is.

[Source]

     # File vendor/rails/actionpack/lib/action_view/helpers/active_record_helper.rb, line 131
131:       def error_messages_for(*params)
132:         options = params.extract_options!.symbolize_keys
133:         if object = options.delete(:object)
134:           objects = [object].flatten
135:         else
136:           objects = params.collect {|object_name| instance_variable_get("@#{object_name}") }.compact
137:         end
138:         count   = objects.inject(0) {|sum, object| sum + object.errors.count }
139:         unless count.zero?
140:           html = {}
141:           [:id, :class].each do |key|
142:             if options.include?(key)
143:               value = options[key]
144:               html[key] = value unless value.blank?
145:             else
146:               html[key] = 'errorExplanation'
147:             end
148:           end
149:           options[:object_name] ||= params.first
150:           options[:header_message] = "#{pluralize(count, 'error')} prohibited this #{options[:object_name].to_s.gsub('_', ' ')} from being saved" unless options.include?(:header_message)
151:           options[:message] ||= 'There were problems with the following fields:' unless options.include?(:message)
152:           error_messages = objects.map {|object| object.errors.full_messages.map {|msg| content_tag(:li, msg) } }
153: 
154:           contents = ''
155:           contents << content_tag(options[:header_tag] || :h2, options[:header_message]) unless options[:header_message].blank?
156:           contents << content_tag(:p, options[:message]) unless options[:message].blank?
157:           contents << content_tag(:ul, error_messages)
158: 
159:           content_tag(:div, contents, html)
160:         else
161:           ''
162:         end
163:       end

Returns an entire form with all needed input tags for a specified Active Record object. For example, let‘s say you have a table model Post with attributes named title of type VARCHAR and body of type TEXT:

  form("post")

That line would yield a form like the following:

    <form action='/post/create' method='post'>
      <p>
        <label for="post_title">Title</label><br />
        <input id="post_title" name="post[title]" size="30" type="text" value="Hello World" />
      </p>
      <p>
        <label for="post_body">Body</label><br />
        <textarea cols="40" id="post_body" name="post[body]" rows="20">
        </textarea>
      </p>
      <input type='submit' value='Create' />
    </form>

It‘s possible to specialize the form builder by using a different action name and by supplying another block renderer. For example, let‘s say you have a model Entry with an attribute message of type VARCHAR:

  form("entry", :action => "sign", :input_block =>
       Proc.new { |record, column| "#{column.human_name}: #{input(record, column.name)}<br />" }) =>

    <form action='/post/sign' method='post'>
      Message:
      <input id="post_title" name="post[title]" size="30" type="text" value="Hello World" /><br />
      <input type='submit' value='Sign' />
    </form>

It‘s also possible to add additional content to the form by giving it a block, such as:

  form("entry", :action => "sign") do |form|
    form << content_tag("b", "Department")
    form << collection_select("department", "id", @departments, "id", "name")
  end

[Source]

    # File vendor/rails/actionpack/lib/action_view/helpers/active_record_helper.rb, line 59
59:       def form(record_name, options = {})
60:         record = instance_variable_get("@#{record_name}")
61: 
62:         options = options.symbolize_keys
63:         options[:action] ||= record.new_record? ? "create" : "update"
64:         action = url_for(:action => options[:action], :id => record)
65: 
66:         submit_value = options[:submit_value] || options[:action].gsub(/[^\w]/, '').capitalize
67: 
68:         contents = ''
69:         contents << hidden_field(record_name, :id) unless record.new_record?
70:         contents << all_input_tags(record, record_name, options)
71:         yield contents if block_given?
72:         contents << submit_tag(submit_value)
73: 
74:         content_tag('form', contents, :action => action, :method => 'post', :enctype => options[:multipart] ? 'multipart/form-data': nil)
75:       end

Returns a default input tag for the type of object returned by the method. For example, let‘s say you have a model that has an attribute title of type VARCHAR column, and this instance holds "Hello World":

  input("post", "title") =>
    <input id="post_title" name="post[title]" size="30" type="text" value="Hello World" />

[Source]

    # File vendor/rails/actionpack/lib/action_view/helpers/active_record_helper.rb, line 20
20:       def input(record_name, method, options = {})
21:         InstanceTag.new(record_name, method, self).to_tag(options)
22:       end