Form helpers are designed to make working with models much easier compared to using just standard HTML elements by providing a set of methods for creating forms based on your models. This helper generates the HTML for forms, providing a method for each sort of input (e.g., text, password, select, and so on). When the form is submitted (i.e., when the user hits the submit button or form.submitis called via JavaScript), the form inputs will be bundled into the paramsobject and passed back to the controller.

There are two types of form helpers: those that specifically work with model attributes and those that don't. This helper deals with those that work with model attributes; to see an example of form helpers that don't work with model attributes, check the ActionView::Helpers::FormTagHelper documentation.

The core method of this helper, #form_for, gives you the ability to create a form for a model instance; for example, let's say that you have a model Personand want to create a new instance of it:

# Note: a @person variable will have been created in the controller.
# For example: @person = Person.new
<% form_for :person, @person, :url => { :action => "create" } do |f| %>
  <%= f.text_field :first_name %>
  <%= f.text_field :last_name %>
  <%= submit_tag 'Create' %>
<% end %>

The HTML generated for this would be:

<form action="/persons/create" method="post">
  <input id="person_first_name" name="person[first_name]" size="30" type="text" />
  <input id="person_last_name" name="person[last_name]" size="30" type="text" />
  <input name="commit" type="submit" value="Create" />
</form>

If you are using a partial for your form fields, you can use this shortcut:

<% form_for :person, @person, :url => { :action => "create" } do |f| %>
  <%= render :partial => f %>
  <%= submit_tag 'Create' %>
<% end %>

This example will render the people/_formpartial, setting a local variable called formwhich references the yielded FormBuilder. The paramsobject created when this form is submitted would look like:

{"action"=>"create", "controller"=>"persons", "person"=>{"first_name"=>"William", "last_name"=>"Smith"}}

The params hash has a nested personvalue, which can therefore be accessed with params[:person]in the controller. If were editing/updating an instance (e.g., Person.find(1)rather than Person.newin the controller), the objects attribute values are filled into the form (e.g., the person_first_namefield would have that person's first name in it).

If the object name contains square brackets the id for the object will be inserted. For example:

<%= text_field "person[]", "name" %>

…will generate the following ERb.

<input type="text" id="person_<%= @person.id %>_name" name="person[<%= @person.id %>][name]" value="<%= @person.name %>" />

If the helper is being used to generate a repetitive sequence of similar form elements, for example in a partial used by render_collection_of_partials, the indexoption may come in handy. Example:

<%= text_field "person", "name", "index" => 1 %>

…becomes…

<input type="text" id="person_1_name" name="person[1][name]" value="<%= @person.name %>" />

An indexoption may also be passed to form_for and fields_for. This automatically applies the indexto all the nested fields.

There are also methods for helping to build form tags in classes/ActionView/Helpers/FormOptionsHelper.html, classes/ActionView/Helpers/DateHelper.html, and classes/ActionView/Helpers/ActiveRecordHelper.html

Methods
C
F
H
L
P
R
T
Instance Public methods
check_box(object_name, method, options = {}, checked_value = "1", unchecked_value = "0")

Returns a checkbox tag tailored for accessing a specified attribute (identified by method) on an object assigned to the template (identified by object). This object must be an instance object (@object) and not a local object. It's intended that methodreturns an integer and if that integer is above zero, then the checkbox is checked. Additional options on the input tag can be passed as a hash with options. The checked_value defaults to 1 while the default unchecked_valueis set to 0 which is convenient for boolean values.

Gotcha

The HTML specification says unchecked check boxes are not successful, and thus web browsers do not send them. Unfortunately this introduces a gotcha: if an Invoicemodel has a paidflag, and in the form that edits a paid invoice the user unchecks its check box, no paidparameter is sent. So, any mass-assignment idiom like

@invoice.update_attributes(params[:invoice])

wouldn't update the flag.

To prevent this the helper generates an auxiliary hidden field before the very check box. The hidden field has the same name and its attributes mimick an unchecked check box.

This way, the client either sends only the hidden field (representing the check box is unchecked), or both fields. Since the HTML specification says key/value pairs have to be sent in the same order they appear in the form, and parameters extraction gets the last occurrence of any repeated key in the query string, that works for ordinary forms.

Unfortunately that workaround does not work when the check box goes within an array-like parameter, as in

<% fields_for "project[invoice_attributes][]", invoice, :index => nil do |form| %>
  <%= form.check_box :paid %>
  ...
<% end %>

because parameter name repetition is precisely what Rails seeks to distinguish the elements of the array. For each item with a checked check box you get an extra ghost item with only that attribute, assigned to “0”.

In that case it is preferable to either use check_box_tagor to use hashes instead of arrays.

Examples

# Let's say that @post.validated? is 1:
check_box("post", "validated")
# => <input name="post[validated]" type="hidden" value="0" />
#    <input type="checkbox" id="post_validated" name="post[validated]" value="1" />
# Let's say that @puppy.gooddog is "no":
check_box("puppy", "gooddog", {}, "yes", "no")
# => <input name="puppy[gooddog]" type="hidden" value="no" />
#    <input type="checkbox" id="puppy_gooddog" name="puppy[gooddog]" value="yes" />
check_box("eula", "accepted", { :class => 'eula_check' }, "yes", "no")
# => <input name="eula[accepted]" type="hidden" value="no" />
#    <input type="checkbox" class="eula_check" id="eula_accepted" name="eula[accepted]" value="yes" />
# File actionpack/lib/action_view/helpers/form_helper.rb, line 716
def check_box(object_name, method, options = {}, checked_value = "1", unchecked_value = "0")
  InstanceTag.new(object_name, method, self, options.delete(:object)).to_check_box_tag(options, checked_value, unchecked_value)
end
fields_for(record_or_name_or_array, *args, &block)

Creates a scope around a specific model object like #form_for, but doesn't create the form tags themselves. This makes #fields_for suitable for specifying additional model objects in the same form.

Generic Examples

<% form_for @person, :url => { :action => "update" } do |person_form| %>
  First name: <%= person_form.text_field :first_name %>
  Last name : <%= person_form.text_field :last_name %>
  <% fields_for @person.permission do |permission_fields| %>
    Admin?  : <%= permission_fields.check_box :admin %>
  <% end %>
<% end %>

…or if you have an object that needs to be represented as a different parameter, like a Client that acts as a Person:

<% fields_for :person, @client do |permission_fields| %>
  Admin?: <%= permission_fields.check_box :admin %>
<% end %>

…or if you don't have an object, just a name of the parameter:

<% fields_for :person do |permission_fields| %>
  Admin?: <%= permission_fields.check_box :admin %>
<% end %>

Note: This also works for the methods in FormOptionHelper and DateHelper that are designed to work with an object as base, like FormOptionHelper#collection_select and ActionView::Helpers::DateHelper#datetime_select.

Nested Attributes Examples

When the object belonging to the current scope has a nested attribute writer for a certain attribute, #fields_for will yield a new scope for that attribute. This allows you to create forms that set or change the attributes of a parent object and its associations in one go.

Nested attribute writers are normal setter methods named after an association. The most common way of defining these writers is either with accepts_nested_attributes_forin a model definition or by defining a method with the proper name. For example: the attribute writer for the association :addressis called address_attributes=.

Whether a one-to-one or one-to-many style form builder will be yielded depends on whether the normal reader method returns a single object or an arrayof objects.

One-to-one

Consider a Person class which returns a singleAddress from the addressreader method and responds to the address_attributes=writer method:

class Person
  def address
    @address
  end
  def address_attributes=(attributes)
    # Process the attributes hash
  end
end

This model can now be used with a nested #fields_for, like so:

<% form_for @person, :url => { :action => "update" } do |person_form| %>
  ...
  <% person_form.fields_for :address do |address_fields| %>
    Street  : <%= address_fields.text_field :street %>
    Zip code: <%= address_fields.text_field :zip_code %>
  <% end %>
<% end %>

When address is already an association on a Person you can use accepts_nested_attributes_forto define the writer method for you:

class Person < ActiveRecord::Base
  has_one :address
  accepts_nested_attributes_for :address
end

If you want to destroy the associated model through the form, you have to enable it first using the :allow_destroyoption for accepts_nested_attributes_for:

class Person < ActiveRecord::Base
  has_one :address
  accepts_nested_attributes_for :address, :allow_destroy => true
end

Now, when you use a form element with the _destroyparameter, with a value that evaluates to true, you will destroy the associated model (eg. 1, '1', true, or 'true'):

<% form_for @person, :url => { :action => "update" } do |person_form| %>
  ...
  <% person_form.fields_for :address do |address_fields| %>
    ...
    Delete: <%= address_fields.check_box :_destroy %>
  <% end %>
<% end %>

One-to-many

Consider a Person class which returns an arrayof Project instances from the projectsreader method and responds to the projects_attributes=writer method:

class Person
  def projects
    [@project1, @project2]
  end
  def projects_attributes=(attributes)
    # Process the attributes hash
  end
end

This model can now be used with a nested fields_for. The block given to the nested #fields_for call will be repeated for each instance in the collection:

<% form_for @person, :url => { :action => "update" } do |person_form| %>
  ...
  <% person_form.fields_for :projects do |project_fields| %>
    <% if project_fields.object.active? %>
      Name: <%= project_fields.text_field :name %>
    <% end %>
  <% end %>
<% end %>

It's also possible to specify the instance to be used:

<% form_for @person, :url => { :action => "update" } do |person_form| %>
  ...
  <% @person.projects.each do |project| %>
    <% if project.active? %>
      <% person_form.fields_for :projects, project do |project_fields| %>
        Name: <%= project_fields.text_field :name %>
      <% end %>
    <% end %>
  <% end %>
<% end %>

Or a collection to be used:

<% form_for @person, :url => { :action => "update" } do |person_form| %>
  ...
  <% person_form.fields_for :projects, @active_projects do |project_fields| %>
    Name: <%= project_fields.text_field :name %>
  <% end %>
<% end %>

When projects is already an association on Person you can use accepts_nested_attributes_forto define the writer method for you:

class Person < ActiveRecord::Base
  has_many :projects
  accepts_nested_attributes_for :projects
end

If you want to destroy any of the associated models through the form, you have to enable it first using the :allow_destroyoption for accepts_nested_attributes_for:

class Person < ActiveRecord::Base
  has_many :projects
  accepts_nested_attributes_for :projects, :allow_destroy => true
end

This will allow you to specify which models to destroy in the attributes hash by adding a form element for the _destroyparameter with a value that evaluates to true(eg. 1, '1', true, or 'true'):

<% form_for @person, :url => { :action => "update" } do |person_form| %>
  ...
  <% person_form.fields_for :projects do |project_fields| %>
    Delete: <%= project_fields.check_box :_destroy %>
  <% end %>
<% end %>
# File actionpack/lib/action_view/helpers/form_helper.rb, line 485
def fields_for(record_or_name_or_array, *args, &block)
  raise ArgumentError, "Missing block" unless block_given?
  options = args.extract_options!
  case record_or_name_or_array
  when String, Symbol
    object_name = record_or_name_or_array
    object = args.first
  else
    object = record_or_name_or_array
    object_name = ActionController::RecordIdentifier.singular_class_name(object)
  end
  builder = options[:builder] || ActionView::Base.default_form_builder
  yield builder.new(object_name, object, self, options, block)
end
file_field(object_name, method, options = {})

Returns an file upload input tag tailored for accessing a specified attribute (identified by method) on an object assigned to the template (identified by object). Additional options on the input tag can be passed as a hash with options. These options will be tagged onto the HTML as an HTML element attribute as in the example shown.

Examples

file_field(:user, :avatar)
# => <input type="file" id="user_avatar" name="user[avatar]" />
file_field(:post, :attached, :accept => 'text/html')
# => <input type="file" id="post_attached" name="post[attached]" />
file_field(:attachment, :file, :class => 'file_input')
# => <input type="file" id="attachment_file" name="attachment[file]" class="file_input" />
# File actionpack/lib/action_view/helpers/form_helper.rb, line 626
def file_field(object_name, method, options = {})
  InstanceTag.new(object_name, method, self, options.delete(:object)).to_input_field_tag("file", options)
end
form_for(record_or_name_or_array, *args, &proc)

Creates a form and a scope around a specific model object that is used as a base for questioning about values for the fields.

Rails provides succinct resource-oriented form generation with form_forlike this:

<% form_for @offer do |f| %>
  <%= f.label :version, 'Version' %>:
  <%= f.text_field :version %><br />
  <%= f.label :author, 'Author' %>:
  <%= f.text_field :author %><br />
<% end %>

There, form_foris able to generate the rest of RESTful form parameters based on introspection on the record, but to understand what it does we need to dig first into the alternative generic usage it is based upon.

Generic #form_for

The generic way to call form_foryields a form builder around a model:

<% form_for :person, :url => { :action => "update" } do |f| %>
  <%= f.error_messages %>
  First name: <%= f.text_field :first_name %><br />
  Last name : <%= f.text_field :last_name %><br />
  Biography : <%= f.text_area :biography %><br />
  Admin?    : <%= f.check_box :admin %><br />
<% end %>

There, the first argument is a symbol or string with the name of the object the form is about, and also the name of the instance variable the object is stored in.

The form builder acts as a regular form helper that somehow carries the model. Thus, the idea is that

<%= f.text_field :first_name %>

gets expanded to

<%= text_field :person, :first_name %>

If the instance variable is not @personyou can pass the actual record as the second argument:

<% form_for :person, person, :url => { :action => "update" } do |f| %>
  ...
<% end %>

In that case you can think

<%= f.text_field :first_name %>

gets expanded to

<%= text_field :person, :first_name, :object => person %>

You can even display error messages of the wrapped model this way:

<%= f.error_messages %>

In any of its variants, the rightmost argument to form_foris an optional hash of options:

  • :url- The URL the form is submitted to. It takes the same fields you pass to url_foror link_to. In particular you may pass here a named route directly as well. Defaults to the current action.

  • :html- Optional HTML attributes for the form tag.

Worth noting is that the form_fortag is called in a ERb evaluation block, not an ERb output block. So that's <% %> , not <%= %>.

Also note that form_fordoesn't create an exclusive scope. It's still possible to use both the stand-alone FormHelper methods and methods from FormTagHelper. For example:

<% form_for :person, @person, :url => { :action => "update" } do |f| %>
  First name: <%= f.text_field :first_name %>
  Last name : <%= f.text_field :last_name %>
  Biography : <%= text_area :person, :biography %>
  Admin?    : <%= check_box_tag "person[admin]", @person.company.admin? %>
<% end %>

This also works for the methods in FormOptionHelper and DateHelper that are designed to work with an object as base, like FormOptionHelper#collection_select and ActionView::Helpers::DateHelper#datetime_select.

Resource-oriented style

As we said above, in addition to manually configuring the form_forcall, you can rely on automated resource identification, which will use the conventions and named routes of that approach. This is the preferred way to use form_fornowadays.

For example, if @postis an existing record you want to edit

<% form_for @post do |f| %>
  ...
<% end %>

is equivalent to something like:

<% form_for :post, @post, :url => post_path(@post), :html => { :method => :put, :class => "edit_post", :id => "edit_post_45" } do |f| %>
  ...
<% end %>

And for new records

<% form_for(Post.new) do |f| %>
  ...
<% end %>

expands to

<% form_for :post, Post.new, :url => posts_path, :html => { :class => "new_post", :id => "new_post" } do |f| %>
  ...
<% end %>

You can also overwrite the individual conventions, like this:

<% form_for(@post, :url => super_post_path(@post)) do |f| %>
  ...
<% end %>

And for namespaced routes, like admin_post_url:

<% form_for([:admin, @post]) do |f| %>
 ...
<% end %>

Customized form builders

You can also build forms using a customized FormBuilder class. Subclass FormBuilder and override or define some more helpers, then use your custom builder. For example, let's say you made a helper to automatically add labels to form inputs.

<% form_for :person, @person, :url => { :action => "update" }, :builder => LabellingFormBuilder do |f| %>
  <%= f.text_field :first_name %>
  <%= f.text_field :last_name %>
  <%= text_area :person, :biography %>
  <%= check_box_tag "person[admin]", @person.company.admin? %>
<% end %>

In this case, if you use this:

<%= render :partial => f %>

The rendered template is people/_labelling_formand the local variable referencing the form builder is called labelling_form.

The custom FormBuilder class is automatically merged with the options of a nested #fields_for call, unless it's explicitely set.

In many cases you will want to wrap the above in another helper, so you could do something like the following:

def labelled_form_for(record_or_name_or_array, *args, &proc)
  options = args.extract_options!
  form_for(record_or_name_or_array, *(args << options.merge(:builder => LabellingFormBuilder)), &proc)
end

If you don't need to attach a form to a model instance, then check out ActionView::Helpers::FormTagHelper#form_tag.

# File actionpack/lib/action_view/helpers/form_helper.rb, line 261
def form_for(record_or_name_or_array, *args, &proc)
  raise ArgumentError, "Missing block" unless block_given?
  options = args.extract_options!
  case record_or_name_or_array
  when String, Symbol
    object_name = record_or_name_or_array
  when Array
    object = record_or_name_or_array.last
    object_name = ActionController::RecordIdentifier.singular_class_name(object)
    apply_form_for_options!(record_or_name_or_array, options)
    args.unshift object
  else
    object = record_or_name_or_array
    object_name = ActionController::RecordIdentifier.singular_class_name(object)
    apply_form_for_options!([object], options)
    args.unshift object
  end
  concat(form_tag(options.delete(:url) || {}, options.delete(:html) || {}))
  fields_for(object_name, *(args << options), &proc)
  concat('</form>'.html_safe)
end
hidden_field(object_name, method, options = {})

Returns a hidden input tag tailored for accessing a specified attribute (identified by method) on an object assigned to the template (identified by object). Additional options on the input tag can be passed as a hash with options. These options will be tagged onto the HTML as an HTML element attribute as in the example shown.

Examples

hidden_field(:signup, :pass_confirm)
# => <input type="hidden" id="signup_pass_confirm" name="signup[pass_confirm]" value="#{@signup.pass_confirm}" />
hidden_field(:post, :tag_list)
# => <input type="hidden" id="post_tag_list" name="post[tag_list]" value="#{@post.tag_list}" />
hidden_field(:user, :token)
# => <input type="hidden" id="user_token" name="user[token]" value="#{@user.token}" />
# File actionpack/lib/action_view/helpers/form_helper.rb, line 607
def hidden_field(object_name, method, options = {})
  InstanceTag.new(object_name, method, self, options.delete(:object)).to_input_field_tag("hidden", options)
end
label(object_name, method, text = nil, options = {})

Returns a label tag tailored for labelling an input field for a specified attribute (identified by method) on an object assigned to the template (identified by object). The text of label will default to the attribute name unless a translation is found in the current I18n locale (through views.labels.<modelname>.<attribute>) or you specify it explicitly. Additional options on the label tag can be passed as a hash with options. These options will be tagged onto the HTML as an HTML element attribute as in the example shown, except for the :valueoption, which is designed to target labels for #radio_button tags (where the value is used in the ID of the input tag).

Examples

label(:post, :title)
# => <label for="post_title">Title</label>
You can localize your labels based on model and attribute names.
For example you can define the following in your locale (e.g. en.yml)
views:
  labels:
    post:
      body: "Write your entire text here"
Which then will result in
label(:post, :body)
# => <label for="post_body">Write your entire text here</label>
Localization can also be based purely on the translation of the attribute-name like this:
activerecord:
  attribute:
    post:
      cost: "Total cost"
label(:post, :cost)
# => <label for="post_cost">Total cost</label>
label(:post, :title, "A short title")
# => <label for="post_title">A short title</label>
label(:post, :title, "A short title", :class => "title_label")
# => <label for="post_title" class="title_label">A short title</label>
label(:post, :privacy, "Public Post", :value => "public")
# => <label for="post_privacy_public">Public Post</label>
# File actionpack/lib/action_view/helpers/form_helper.rb, line 545
def label(object_name, method, text = nil, options = {})
  InstanceTag.new(object_name, method, self, options.delete(:object)).to_label_tag(text, options)
end
password_field(object_name, method, options = {})

Returns an input tag of the “password” type tailored for accessing a specified attribute (identified by method) on an object assigned to the template (identified by object). Additional options on the input tag can be passed as a hash with options. These options will be tagged onto the HTML as an HTML element attribute as in the example shown.

Examples

password_field(:login, :pass, :size => 20)
# => <input type="text" id="login_pass" name="login[pass]" size="20" value="#{@login.pass}" />
password_field(:account, :secret, :class => "form_input")
# => <input type="text" id="account_secret" name="account[secret]" value="#{@account.secret}" class="form_input" />
password_field(:user, :password, :onchange => "if $('user[password]').length > 30 { alert('Your password needs to be shorter!'); }")
# => <input type="text" id="user_password" name="user[password]" value="#{@user.password}" onchange = "if $('user[password]').length > 30 { alert('Your password needs to be shorter!'); }"/>
password_field(:account, :pin, :size => 20, :class => 'form_input')
# => <input type="text" id="account_pin" name="account[pin]" size="20" value="#{@account.pin}" class="form_input" />
# File actionpack/lib/action_view/helpers/form_helper.rb, line 589
def password_field(object_name, method, options = {})
  InstanceTag.new(object_name, method, self, options.delete(:object)).to_input_field_tag("password", options)
end
radio_button(object_name, method, tag_value, options = {})

Returns a radio button tag for accessing a specified attribute (identified by method) on an object assigned to the template (identified by object). If the current value of methodis tag_valuethe radio button will be checked.

To force the radio button to be checked pass :checked => true in the optionshash. You may pass HTML options there as well.

Examples

# Let's say that @post.category returns "rails":
radio_button("post", "category", "rails")
radio_button("post", "category", "java")
# => <input type="radio" id="post_category_rails" name="post[category]" value="rails" checked="checked" />
#    <input type="radio" id="post_category_java" name="post[category]" value="java" />
radio_button("user", "receive_newsletter", "yes")
radio_button("user", "receive_newsletter", "no")
# => <input type="radio" id="user_receive_newsletter_yes" name="user[receive_newsletter]" value="yes" />
#    <input type="radio" id="user_receive_newsletter_no" name="user[receive_newsletter]" value="no" checked="checked" />
# File actionpack/lib/action_view/helpers/form_helper.rb, line 738
def radio_button(object_name, method, tag_value, options = {})
  InstanceTag.new(object_name, method, self, options.delete(:object)).to_radio_button_tag(tag_value, options)
end
text_area(object_name, method, options = {})

Returns a textarea opening and closing tag set tailored for accessing a specified attribute (identified by method) on an object assigned to the template (identified by object). Additional options on the input tag can be passed as a hash with options.

Examples

text_area(:post, :body, :cols => 20, :rows => 40)
# => <textarea cols="20" rows="40" id="post_body" name="post[body]">
#      #{@post.body}
#    </textarea>
text_area(:comment, :text, :size => "20x30")
# => <textarea cols="20" rows="30" id="comment_text" name="comment[text]">
#      #{@comment.text}
#    </textarea>
text_area(:application, :notes, :cols => 40, :rows => 15, :class => 'app_input')
# => <textarea cols="40" rows="15" id="application_notes" name="application[notes]" class="app_input">
#      #{@application.notes}
#    </textarea>
text_area(:entry, :body, :size => "20x20", :disabled => 'disabled')
# => <textarea cols="20" rows="20" id="entry_body" name="entry[body]" disabled="disabled">
#      #{@entry.body}
#    </textarea>
# File actionpack/lib/action_view/helpers/form_helper.rb, line 654
def text_area(object_name, method, options = {})
  InstanceTag.new(object_name, method, self, options.delete(:object)).to_text_area_tag(options)
end
text_field(object_name, method, options = {})

Returns an input tag of the “text” type tailored for accessing a specified attribute (identified by method) on an object assigned to the template (identified by object). Additional options on the input tag can be passed as a hash with options. These options will be tagged onto the HTML as an HTML element attribute as in the example shown.

Examples

text_field(:post, :title, :size => 20)
# => <input type="text" id="post_title" name="post[title]" size="20" value="#{@post.title}" />
text_field(:post, :title, :class => "create_input")
# => <input type="text" id="post_title" name="post[title]" value="#{@post.title}" class="create_input" />
text_field(:session, :user, :onchange => "if $('session[user]').value == 'admin' { alert('Your login can not be admin!'); }")
# => <input type="text" id="session_user" name="session[user]" value="#{@session.user}" onchange = "if $('session[user]').value == 'admin' { alert('Your login can not be admin!'); }"/>
text_field(:snippet, :code, :size => 20, :class => 'code_input')
# => <input type="text" id="snippet_code" name="snippet[code]" size="20" value="#{@snippet.code}" class="code_input" />
# File actionpack/lib/action_view/helpers/form_helper.rb, line 567
def text_field(object_name, method, options = {})
  InstanceTag.new(object_name, method, self, options.delete(:object)).to_input_field_tag("text", options)
end