Method: ActionView::Helpers::FormHelper#form_for

Defined in:
actionpack/lib/action_view/helpers/form_helper.rb

#form_for(record_or_name_or_array, *args, &proc) ⇒ Object

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_for like 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_for is 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_for yields a form builder around a model:

<%= form_for :person do |f| %>
  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 argument is a symbol or string with the name of the object the form is about.

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

The rightmost argument to form_for is an optional hash of options:

  • :url - The URL the form is submitted to. It takes the same fields you pass to url_for or 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.

Also note that form_for doesn'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 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 DateHelper#datetime_select.

Resource-oriented style

As we said above, in addition to manually configuring the form_for call, 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_for nowadays.

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

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

is equivalent to something like:

<%= form_for @post, :as => :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 %>

is equivalent to something like:

<%= form_for @post, :as => :post, :url => post_path(@post), :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 %>

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

<%= form_for(@post, :as => :client do |f| %>
  ...
<% end %>

For namespaced routes, like admin_post_url:

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

If your resource has associations defined, for example, you want to add comments to the post given that the routes are set correctly:

<%= form_for([@document, @comment]) do |f| %>
 ...
<% end %>

Where @document = Document.find(params) and @comment = Comment.new.

Unobtrusive JavaScript

Specifying:

:remote => true

in the options hash creates a form that will allow the unobtrusive JavaScript drivers to modify its behaviour. The expected default behaviour is an XMLHttpRequest in the background instead of the regular POST arrangement, but ultimately the behaviour is the choice of the JavaScript driver implementor. Even though it's using JavaScript to serialize the form elements, the form submission will work just like a regular submission as viewed by the receiving side (all elements available in params).

Example:

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

The HTML generated for this would be:

<form action='http://www.example.com' method='post' data-remote='true'>
  <div style='margin:0;padding:0;display:inline'>
    <input name='_method' type='hidden' value='put' />
  </div>
  ...
</form>

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, :url => { :action => "create" }, :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_form and 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 explicitly 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 FormTagHelper#form_tag.

Raises:

  • (ArgumentError)


290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
# File 'actionpack/lib/action_view/helpers/form_helper.rb', line 290

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
    ActiveSupport::Deprecation.warn("Using form_for(:name, @resource) is deprecated. Please use form_for(@resource, :as => :name) instead.", caller) unless args.empty?
    object_name = record_or_name_or_array
  when Array
    object = record_or_name_or_array.last
    object_name = options[:as] || ActiveModel::Naming.singular(object)
    apply_form_for_options!(record_or_name_or_array, options)
    args.unshift object
  else
    object = record_or_name_or_array
    object_name = options[:as] || ActiveModel::Naming.singular(object)
    apply_form_for_options!([object], options)
    args.unshift object
  end

  (options[:html] ||= {})[:remote] = true if options.delete(:remote)

  output = form_tag(options.delete(:url) || {}, options.delete(:html) || {})
  output << fields_for(object_name, *(args << options), &proc)
  output.safe_concat('</form>')
end

Comments