The Active Record Helper makes it easier to create forms for records kept in instance variables. The most far-reaching is the form method that creates a complete form for all the basic content types of the record (not associations or aggregations, though). This is a great way of making the record quickly available for editing, but likely to prove lackluster for a complicated real-world form. In that case, it's better to use the inputmethod and the specialized form methods in classes/ActionView/Helpers/FormHelper.html

Instance Public methods
error_message_on(object, method, *args)

Returns a string containing the error message attached to the methodon the objectif one exists. This error message is wrapped in a DIVtag, which can be extended to include a :prepend_textand/or :append_text(to properly explain the error), and a :css_classto style it accordingly. objectshould either be the name of an instance variable or the actual object. The method can be passed in either as a string or a symbol. As an example, let's say you have a model @postthat 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",
    :prepend_text => "Title simply ",
    :append_text => " (or it won't work).",
    :css_class => "inputError" %>
# File actionpack/lib/action_view/helpers/active_record_helper.rb, line 109
def error_message_on(object, method, *args)
  options = args.extract_options!
  unless args.empty?
    ActiveSupport::Deprecation.warn('error_message_on takes an option hash instead of separate ' +
      'prepend_text, append_text, and css_class arguments', caller)
    options[:prepend_text] = args[0] || ''
    options[:append_text] = args[1] || ''
    options[:css_class] = args[2] || 'formError'
  options.reverse_merge!(:prepend_text => '', :append_text => '', :css_class => 'formError')
  if (obj = (object.respond_to?(:errors) ? object : instance_variable_get("@#{object}"))) &&
    (errors = obj.errors.on(method))
      "#{options[:prepend_text]}#{ERB::Util.html_escape(errors.is_a?(Array) ? errors.first : errors)}#{options[:append_text]}".html_safe,
      :class => options[:css_class]

Returns a string with a DIVcontaining 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 DIVcan 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_nameis not set, the name of the first object will be used.

  • :header_message- The message in the header of the error div. Pass nilor 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 nilor 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 @usermodel:

error_messages_for 'user'

To specify more than one object, you simply list them; optionally, you can add an extra :object_nameparameter, 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 :objectparameter 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.errorsinstance yourself and set it up. View the source of this method to see how easy it is.

# File actionpack/lib/action_view/helpers/active_record_helper.rb, line 170
def error_messages_for(*params)
  options = params.extract_options!.symbolize_keys
  if object = options.delete(:object)
    objects = Array.wrap(object)
    objects = params.collect {|object_name| instance_variable_get("@#{object_name}") }.compact
  count  = objects.inject(0) {|sum, object| sum + object.errors.count }
    html = {}
    [:id, :class].each do |key|
      if options.include?(key)
        value = options[key]
        html[key] = value unless value.blank?
        html[key] = 'errorExplanation'
    options[:object_name] ||= params.first
    I18n.with_options :locale => options[:locale], :scope => [:activerecord, :errors, :template] do |locale|
      header_message = if options.include?(:header_message)
        object_name = options[:object_name].to_s
        object_name = I18n.t(object_name, :default => object_name.gsub('_', ' '), :scope => [:activerecord, :models], :count => 1)
        locale.t :header, :count => count, :model => object_name
      message = options.include?(:message) ? options[:message] : locale.t(:body)
      error_messages = objects.sum {|object| {|msg| content_tag(:li, ERB::Util.html_escape(msg)) } }.join.html_safe
      contents = ''
      contents << content_tag(options[:header_tag] || :h2, header_message) unless header_message.blank?
      contents << content_tag(:p, message) unless message.blank?
      contents << content_tag(:ul, error_messages)
      content_tag(:div, contents.html_safe, html)
form(record_name, options = {})

Returns an entire form with all needed input tags for a specified Active Record object. For example, if @posthas attributes named titleof type VARCHARand bodyof type TEXTthen


would yield a form like the following (modulus formatting):

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

It's possible to specialize the form builder by using a different action name and by supplying another block renderer. For example, if @entryhas an attribute messageof type VARCHARthen

  :action => "sign",
  :input_block => { |record, column|
    "#{column.human_name}: #{input(record,}<br />"

would yield a form like the following (modulus formatting):

<form action="/entries/sign" method="post">
  <input id="entry_message" name="entry[message]" size="30" type="text" /><br />
  <input name="commit" type="submit" value="Sign" />

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

The following options are available:

  • :action- The action used when submitting the form (default: createif a new record, otherwise update).

  • :input_block- Specialize the output using a different block, see above.

  • :method- The method used when submitting the form (default: post).

  • :multipart- Whether to change the enctype of the form to “multipart/form-data”, used when uploading a file (default: false).

  • :submit_value- The text of the submit button (default: “Create” if a new record, otherwise “Update”).

# File actionpack/lib/action_view/helpers/active_record_helper.rb, line 75
def form(record_name, options = {})
  record = instance_variable_get("@#{record_name}")
  options = options.symbolize_keys
  options[:action] ||= record.new_record? ? "create" : "update"
  action = url_for(:action => options[:action], :id => record)
  submit_value = options[:submit_value] || options[:action].gsub(/[^\w]/, '').capitalize
  contents = form_tag({:action => action}, :method =>(options[:method] || 'post'), :enctype => options[:multipart] ? 'multipart/form-data': nil)
  contents.safe_concat hidden_field(record_name, :id) unless record.new_record?
  contents.safe_concat all_input_tags(record, record_name, options)
  yield contents if block_given?
  contents.safe_concat submit_tag(submit_value)
  contents.safe_concat '</form>'
input(record_name, method, options = {})

Returns a default input tag for the type of object returned by the method. For example, if @posthas an attribute title mapped to a VARCHARcolumn that holds “Hello World”:

input("post", "title")
# => <input id="post_title" name="post[title]" size="30" type="text" value="Hello World" />
# File actionpack/lib/action_view/helpers/active_record_helper.rb, line 21
def input(record_name, method, options = {}), method, self).to_tag(options)