Module: ActionView::Helpers::FormHelper
- Defined in:
- lib/action_view/helpers/form_helper.rb
Overview
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.submit
is called via JavaScript), the form inputs will be bundled into the params
object 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 Person
and 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/_form
partial, setting a local variable called form
which references the yielded FormBuilder.
The params
object 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 person
value, 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.new
in the controller), the objects attribute values are filled into the form (e.g., the person_first_name
field 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 index
option 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 index
option may also be passed to form_for
and fields_for
. This automatically applies the index
to 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
Instance Method Summary collapse
-
#apply_form_for_options!(object_or_array, options) ⇒ Object
:nodoc:.
-
#check_box(object_name, method, options = {}, checked_value = "1", unchecked_value = "0") ⇒ Object
Returns a checkbox tag tailored for accessing a specified attribute (identified by
method
) on an object assigned to the template (identified byobject
). -
#fields_for(record_or_name_or_array, *args) {|builder.new(object_name, object, self, options, block)| ... } ⇒ Object
Creates a scope around a specific model object like form_for, but doesn’t create the form tags themselves.
-
#file_field(object_name, method, options = {}) ⇒ Object
Returns an file upload input tag tailored for accessing a specified attribute (identified by
method
) on an object assigned to the template (identified byobject
). -
#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.
-
#hidden_field(object_name, method, options = {}) ⇒ Object
Returns a hidden input tag tailored for accessing a specified attribute (identified by
method
) on an object assigned to the template (identified byobject
). -
#label(object_name, method, text = nil, options = {}) ⇒ Object
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 byobject
). -
#password_field(object_name, method, options = {}) ⇒ Object
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 byobject
). -
#radio_button(object_name, method, tag_value, options = {}) ⇒ Object
Returns a radio button tag for accessing a specified attribute (identified by
method
) on an object assigned to the template (identified byobject
). -
#text_area(object_name, method, options = {}) ⇒ Object
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 byobject
). -
#text_field(object_name, method, options = {}) ⇒ Object
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 byobject
).
Instance Method Details
#apply_form_for_options!(object_or_array, options) ⇒ Object
:nodoc:
257 258 259 260 261 262 263 264 265 266 267 268 269 270 |
# File 'lib/action_view/helpers/form_helper.rb', line 257 def (object_or_array, ) #:nodoc: object = object_or_array.is_a?(Array) ? object_or_array.last : object_or_array = if object.respond_to?(:new_record?) && object.new_record? { :class => dom_class(object, :new), :id => dom_id(object), :method => :post } else { :class => dom_class(object, :edit), :id => dom_id(object, :edit), :method => :put } end [:html] ||= {} [:html].reverse_merge!() [:url] ||= polymorphic_path(object_or_array) end |
#check_box(object_name, method, options = {}, checked_value = "1", unchecked_value = "0") ⇒ Object
Returns a checkbox tag tailored for accessing a specified attribute (identified by method
) on an object assigned to the template (identified by object
). It’s intended that method
returns 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_value
is set to 0 which is convenient for boolean values. Since HTTP standards say that unchecked checkboxes don’t post anything, we add a hidden value with the same name as the checkbox as a work around.
Examples
# Let's say that @post.validated? is 1:
check_box("post", "validated")
# => <input type="checkbox" id="post_validated" name="post[validated]" value="1" />
# <input name="post[validated]" type="hidden" value="0" />
# Let's say that @puppy.gooddog is "no":
check_box("puppy", "gooddog", {}, "yes", "no")
# => <input type="checkbox" id="puppy_gooddog" name="puppy[gooddog]" value="yes" />
# <input name="puppy[gooddog]" type="hidden" value="no" />
check_box("eula", "accepted", { :class => 'eula_check' }, "yes", "no")
# => <input type="checkbox" class="eula_check" id="eula_accepted" name="eula[accepted]" value="yes" />
# <input name="eula[accepted]" type="hidden" value="no" />
470 471 472 |
# File 'lib/action_view/helpers/form_helper.rb', line 470 def check_box(object_name, method, = {}, checked_value = "1", unchecked_value = "0") InstanceTag.new(object_name, method, self, nil, .delete(:object)).to_check_box_tag(, checked_value, unchecked_value) end |
#fields_for(record_or_name_or_array, *args) {|builder.new(object_name, object, self, options, block)| ... } ⇒ Object
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:
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 DateHelper#datetime_select.
299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 |
# File 'lib/action_view/helpers/form_helper.rb', line 299 def fields_for(record_or_name_or_array, *args, &block) raise ArgumentError, "Missing block" unless block_given? = args. case record_or_name_or_array when String, Symbol object_name = record_or_name_or_array object = args.first when Array object = record_or_name_or_array.last object_name = ActionController::RecordIdentifier.singular_class_name(object) (record_or_name_or_array, ) else object = record_or_name_or_array object_name = ActionController::RecordIdentifier.singular_class_name(object) end builder = [:builder] || ActionView::Base.default_form_builder yield builder.new(object_name, object, self, , block) end |
#file_field(object_name, method, options = {}) ⇒ Object
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" />
416 417 418 |
# File 'lib/action_view/helpers/form_helper.rb', line 416 def file_field(object_name, method, = {}) InstanceTag.new(object_name, method, self, nil, .delete(:object)).to_input_field_tag("file", ) end |
#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 succint 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, :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 @person
you 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_for
is an optional hash of options:
-
:url
- The URL the form is submitted to. It takes the same fields you pass tourl_for
orlink_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_for
tag is called in a ERb evaluation block, not an ERb output block. So that’s <% %>
, not <%= %>
.
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, @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 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, @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_form
and the local variable referencing the form builder is called labelling_form
.
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)
= args.
form_for(record_or_name_or_array, *(args << .merge(:builder => LabellingFormBuilder)), &proc)
end
If you don’t need to attach a form to a model instance, then check out FormTagHelper#form_tag.
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 |
# File 'lib/action_view/helpers/form_helper.rb', line 232 def form_for(record_or_name_or_array, *args, &proc) raise ArgumentError, "Missing block" unless block_given? = args. 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) (record_or_name_or_array, ) args.unshift object else object = record_or_name_or_array object_name = ActionController::RecordIdentifier.singular_class_name(object) ([object], ) args.unshift object end concat(form_tag(.delete(:url) || {}, .delete(:html) || {}), proc.binding) fields_for(object_name, *(args << ), &proc) concat('</form>', proc.binding) end |
#hidden_field(object_name, method, options = {}) ⇒ Object
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}" />
397 398 399 |
# File 'lib/action_view/helpers/form_helper.rb', line 397 def hidden_field(object_name, method, = {}) InstanceTag.new(object_name, method, self, nil, .delete(:object)).to_input_field_tag("hidden", ) end |
#label(object_name, method, text = nil, options = {}) ⇒ Object
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 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.
Examples
label(:post, :title)
# => <label for="post_title">Title</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>
335 336 337 |
# File 'lib/action_view/helpers/form_helper.rb', line 335 def label(object_name, method, text = nil, = {}) InstanceTag.new(object_name, method, self, nil, .delete(:object)).to_label_tag(text, ) end |
#password_field(object_name, method, options = {}) ⇒ Object
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" />
379 380 381 |
# File 'lib/action_view/helpers/form_helper.rb', line 379 def password_field(object_name, method, = {}) InstanceTag.new(object_name, method, self, nil, .delete(:object)).to_input_field_tag("password", ) end |
#radio_button(object_name, method, tag_value, options = {}) ⇒ Object
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 method
is tag_value
the radio button will be checked. Additional options on the input tag can be passed as a hash with options
.
Examples
# Let's say that @post.category returns "rails":
("post", "category", "rails")
("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" />
("user", "receive_newsletter", "yes")
("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" />
490 491 492 |
# File 'lib/action_view/helpers/form_helper.rb', line 490 def (object_name, method, tag_value, = {}) InstanceTag.new(object_name, method, self, nil, .delete(:object)).(tag_value, ) end |
#text_area(object_name, method, options = {}) ⇒ Object
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>
444 445 446 |
# File 'lib/action_view/helpers/form_helper.rb', line 444 def text_area(object_name, method, = {}) InstanceTag.new(object_name, method, self, nil, .delete(:object)).to_text_area_tag() end |
#text_field(object_name, method, options = {}) ⇒ Object
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" />
357 358 359 |
# File 'lib/action_view/helpers/form_helper.rb', line 357 def text_field(object_name, method, = {}) InstanceTag.new(object_name, method, self, nil, .delete(:object)).to_input_field_tag("text", ) end |