Module | ActionView::Helpers::FormHelper |
In: |
vendor/rails/actionpack/lib/action_view/helpers/form_helper.rb
|
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>
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 %>" />
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
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.
# Let's say that @post.validated? is 1: check_box("post", "validated") # => <input type="checkbox" id="post_validate" name="post[validated]" value="1" checked="checked" /> # <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", {}, "yes", "no", :class => 'eula_check') # => <input type="checkbox" id="eula_accepted" name="eula[accepted]" value="no" /> # <input name="eula[accepted]" type="hidden" value="no" />
# File vendor/rails/actionpack/lib/action_view/helpers/form_helper.rb, line 401 401: def check_box(object_name, method, options = {}, checked_value = "1", unchecked_value = "0") 402: InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_check_box_tag(options, checked_value, unchecked_value) 403: end
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:
<% 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.
# File vendor/rails/actionpack/lib/action_view/helpers/form_helper.rb, line 230 230: def fields_for(record_or_name_or_array, *args, &block) 231: raise ArgumentError, "Missing block" unless block_given? 232: options = args.extract_options! 233: 234: case record_or_name_or_array 235: when String, Symbol 236: object_name = record_or_name_or_array 237: object = args.first 238: when Array 239: object = record_or_name_or_array.last 240: object_name = ActionController::RecordIdentifier.singular_class_name(object) 241: apply_form_for_options!(record_or_name_or_array, options) 242: else 243: object = record_or_name_or_array 244: object_name = ActionController::RecordIdentifier.singular_class_name(object) 245: end 246: 247: builder = options[:builder] || ActionView::Base.default_form_builder 248: yield builder.new(object_name, object, self, options, block) 249: end
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.
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 vendor/rails/actionpack/lib/action_view/helpers/form_helper.rb, line 347 347: def file_field(object_name, method, options = {}) 348: InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_input_field_tag("file", options) 349: end
Creates a form and a scope around a specific model object that is used as a base for questioning about values for the fields.
<% form_for :person, @person, :url => { :action => "update" } do |f| %> First name: <%= f.text_field :first_name %> Last name : <%= f.text_field :last_name %> Biography : <%= f.text_area :biography %> Admin? : <%= f.check_box :admin %> <% end %>
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 worth noting is that form_for yields a form_builder object, in this example as f, which emulates the API for the stand-alone FormHelper methods, but without the object name. So instead of text_field :person, :name, you get away with f.text_field :name.
Even further, the form_for method allows you to more easily escape the instance variable convention. So while the stand-alone approach would require text_field :person, :name, :object => person to work with local variables instead of instance ones, the form_for calls remain the same. You simply declare once with :person, person and all subsequent field calls save :person and :object => person.
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 %>
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.
HTML attributes for the form tag can be given as :html => {…}. For example:
<% form_for :person, @person, :html => {:id => 'person_form'} do |f| %> ... <% end %>
The above form will then have the id attribute with the value </tt>person_form</tt>, which you can then style with CSS or manipulate with JavaScript.
In addition to manually configuring the form_for call, you can also rely on record identification, which will use the conventions and named routes of that approach. Examples:
<% form_for(@post) do |f| %> ... <% end %>
This will expand to be the same as:
<% 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 %>
This will expand to be the same as:
<% form_for :post, @post, :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 %>
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 many cases you will want to wrap the above in another helper, so you could do something like the following:
def labelled_form_for(name, object, options, &proc) form_for(name, object, options.merge(:builder => LabellingFormBuiler), &proc) end
If you don‘t need to attach a form to a model instance, then check out FormTagHelper#form_tag.
# File vendor/rails/actionpack/lib/action_view/helpers/form_helper.rb, line 163 163: def form_for(record_or_name_or_array, *args, &proc) 164: raise ArgumentError, "Missing block" unless block_given? 165: 166: options = args.extract_options! 167: 168: case record_or_name_or_array 169: when String, Symbol 170: object_name = record_or_name_or_array 171: when Array 172: object = record_or_name_or_array.last 173: object_name = ActionController::RecordIdentifier.singular_class_name(object) 174: apply_form_for_options!(record_or_name_or_array, options) 175: args.unshift object 176: else 177: object = record_or_name_or_array 178: object_name = ActionController::RecordIdentifier.singular_class_name(object) 179: apply_form_for_options!([object], options) 180: args.unshift object 181: end 182: 183: concat(form_tag(options.delete(:url) || {}, options.delete(:html) || {}), proc.binding) 184: fields_for(object_name, *(args << options), &proc) 185: concat('</form>', proc.binding) 186: end
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.
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 vendor/rails/actionpack/lib/action_view/helpers/form_helper.rb, line 328 328: def hidden_field(object_name, method, options = {}) 329: InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_input_field_tag("hidden", options) 330: end
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.
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>
# File vendor/rails/actionpack/lib/action_view/helpers/form_helper.rb, line 266 266: def label(object_name, method, text = nil, options = {}) 267: InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_label_tag(text, options) 268: end
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.
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 vendor/rails/actionpack/lib/action_view/helpers/form_helper.rb, line 310 310: def password_field(object_name, method, options = {}) 311: InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_input_field_tag("password", options) 312: end
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.
# Let's say that @post.category returns "rails": radio_button("post", "category", "rails") radio_button("post", "category", "java") # => <input type="radio" id="post_category" name="post[category]" value="rails" checked="checked" /> # <input type="radio" id="post_category" name="post[category]" value="java" /> radio_button("user", "receive_newsletter", "yes") radio_button("user", "receive_newsletter", "no") # => <input type="radio" id="user_receive_newsletter" name="user[receive_newsletter]" value="yes" /> # <input type="radio" id="user_receive_newsletter" name="user[receive_newsletter]" value="no" checked="checked" />
# File vendor/rails/actionpack/lib/action_view/helpers/form_helper.rb, line 421 421: def radio_button(object_name, method, tag_value, options = {}) 422: InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_radio_button_tag(tag_value, options) 423: end
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.
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 vendor/rails/actionpack/lib/action_view/helpers/form_helper.rb, line 375 375: def text_area(object_name, method, options = {}) 376: InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_text_area_tag(options) 377: end
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.
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 vendor/rails/actionpack/lib/action_view/helpers/form_helper.rb, line 288 288: def text_field(object_name, method, options = {}) 289: InstanceTag.new(object_name, method, self, nil, options.delete(:object)).to_input_field_tag("text", options) 290: end