Module: ActionView::Helpers::FormHelper

Extended by:
ActiveSupport::Concern
Includes:
FormTagHelper, UrlHelper
Included in:
ActionView::Helpers
Defined in:
lib/action_view/helpers/form_helper.rb

Overview

Form helpers are designed to make working with resources much easier compared to using vanilla HTML.

Forms for models are created with form_for. That method yields a form builder that knows the model the form is about. The form builder is thus able to generate default values for input fields that correspond to model attributes, and also convenient names, IDs, endpoints, etc.

Conventions in the generated field names allow controllers to receive form data nicely structured in params with no effort on your side.

For example, to create a new person you typically set up a new instance of Person in the PeopleController#new action, @person, and pass it to form_for:

<%= form_for @person do |f| %>
<%= f.label :first_name %>:
<%= f.text_field :first_name %><br />

<%= f.label :last_name %>:
<%= f.text_field :last_name %><br />

<%= f.submit %>
<% end %>

The HTML generated for this would be (modulus formatting):

: 
<label for="person_last_name">Last name</label>:
<input id="person_last_name" name="person[last_name]" size="30" type="text" /><br />

<input id="person_submit" name="commit" type="submit" value="Create Person" />
</form>

As you see, the HTML reflects knowledge about the resource in several spots, like the path the form should be submitted to, or the names of the input fields.

In particular, thanks to the conventions followed in the generated field names, the controller gets a nested hash params with the person attributes set in the form. That hash is ready to be passed to Person.create:

if @person = Person.create(params[:person])
# success
else
# error handling
end

Interestingly, the exact same view code in the previous example can be used to edit a person. If @person is an existing record with name "John Smith" and ID 256, the code above as is would yield instead:

: 
<label for="person_last_name">Last name</label>:
<input id="person_last_name" name="person[last_name]" size="30" type="text" value="Smith" /><br />

<input id="person_submit" name="commit" type="submit" value="Update Person" />
</form>

Note that the endpoint, default values, and submit button label are tailored for @person. That works that way because the involved helpers know whether the resource is a new record or not, and generate HTML accordingly.

The controller would receive the form data again in params, ready to be passed to Person#update_attributes:

if @person.update_attributes(params[:person])
# success
else
# error handling
end

That's how you typically work with resources.

Constant Summary

Constants included from TagHelper

TagHelper::BOOLEAN_ATTRIBUTES

Instance Method Summary collapse

Methods included from UrlHelper

#button_to, #current_page?, #link_to, #link_to_if, #link_to_unless, #link_to_unless_current, #mail_to, #url_for, #url_options

Methods included from TagHelper

#cdata_section, #content_tag, #escape_once, #tag

Methods included from CaptureHelper

#capture, #content_for, #content_for?, #flush_output_buffer, #with_output_buffer

Methods included from ActionDispatch::Routing::UrlFor

#url_for, #url_options

Methods included from ActionDispatch::Routing::PolymorphicRoutes

#polymorphic_path, #polymorphic_url

Methods included from FormTagHelper

#check_box_tag, #email_field_tag, #field_set_tag, #file_field_tag, #form_tag, #hidden_field_tag, #image_submit_tag, #label_tag, #number_field_tag, #password_field_tag, #radio_button_tag, #range_field_tag, #search_field_tag, #select_tag, #submit_tag, #telephone_field_tag, #text_area_tag, #text_field_tag, #url_field_tag

Methods included from TextHelper

#auto_link, #concat, #current_cycle, #cycle, #excerpt, #highlight, #pluralize, #reset_cycle, #safe_concat, #simple_format, #truncate, #word_wrap

Methods included from SanitizeHelper

#sanitize, #sanitize_css, #strip_links, #strip_tags

Instance Method Details

#apply_form_for_options!(object_or_array, options) ⇒ Object

:nodoc:



324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
 
# File 'lib/action_view/helpers/form_helper.rb', line 324

def apply_form_for_options!(object_or_array, options) #:nodoc:
  object = object_or_array.is_a?(Array) ? object_or_array.last : object_or_array
  object = convert_to_model(object)

  html_options =
    if object.respond_to?(:persisted?) && object.persisted?
      { :class  => options[:as] ? "#{options[:as]}_edit" : dom_class(object, :edit),
        :id => options[:as] ? "#{options[:as]}_edit" : dom_id(object, :edit),
        :method => :put }
    else
      { :class  => options[:as] ? "#{options[:as]}_new" : dom_class(object, :new),
        :id => options[:as] ? "#{options[:as]}_new" : dom_id(object),
        :method => :post }
    end

  options[:html] ||= {}
  options[:html].reverse_merge!(html_options)
  options[:url] ||= options[:format] ? \
    polymorphic_path(object_or_array, :format => options.delete(:format)) : \
    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). This object must be an instance object (@object) and not a local 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.

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 Invoice model has a paid flag, and in the form that edits a paid invoice the user unchecks its check box, no paid parameter 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 mimic 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_tag or 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" />


776
777
778
 
# File 'lib/action_view/helpers/form_helper.rb', line 776

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

#email_field(object_name, method, options = {}) ⇒ Object

Returns a text_field of type "email".



832
833
834
 
# File 'lib/action_view/helpers/form_helper.rb', line 832

def email_field(object_name, method, options = {})
  InstanceTag.new(object_name, method, self, options.delete(:object)).to_input_field_tag("email", options)
end

#fields_for(record_or_name_or_array, *args, &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.

Generic Examples

<%= form_for @person 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.

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_for in a model definition or by defining a method with the proper name. For example: the attribute writer for the association :address is 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 array of objects.

One-to-one

Consider a Person class which returns a single Address from the address reader 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 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_for to 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_destroy option 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 _destroy parameter, with a value that evaluates to true, you will destroy the associated model (eg. 1, '1', true, or 'true'):

<%= form_for @person 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 array of Project instances from the projects reader 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 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 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 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_for to 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_destroy option 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 _destroy parameter with a value that evaluates to true (eg. 1, '1', true, or 'true'):

<%= form_for @person do |person_form| %>
...
<%= person_form.fields_for :projects do |project_fields| %>
  Delete: <%= project_fields.check_box :_destroy %>
<% end %>
<% end %>

Raises:

  • (ArgumentError) 


530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
 
# File 'lib/action_view/helpers/form_helper.rb', line 530

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 = ActiveModel::Naming.singular(object)
  end

  builder = options[:builder] || ActionView::Base.default_form_builder
  builder = builder.new(object_name, object, self, options, block)
  output  = capture(builder, &block)
  output.concat builder.hidden_field(:id) if output && options[:hidden_field_id] && !builder.emitted_hidden_id?
  output
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)

=> 

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


686
687
688
 
# File 'lib/action_view/helpers/form_helper.rb', line 686

def file_field(object_name, method, options = {})
  InstanceTag.new(object_name, method, self, options.delete(:object)).to_input_field_tag("file", options.update({:size => nil}))
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 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 %>

You can also set the answer format, like this:

<%= form_for(@post, :format => :json) 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[:id]) 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:

...

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) 


296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
 
# File 'lib/action_view/helpers/form_helper.rb', line 296

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

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

=> 

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}" />


667
668
669
 
# File 'lib/action_view/helpers/form_helper.rb', line 667

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, content_or_options = nil, options = nil, &block) ⇒ 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 a translation is found in the current I18n locale (through helpers.label..) 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 :value option, 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)

=> 

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)

helpers:
label:
  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:

activemodel:
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>

label(:post, :terms) do
'Accept <a href="/terms">Terms</a>.'
end


596
597
598
599
600
601
602
603
604
605
606
607
 
# File 'lib/action_view/helpers/form_helper.rb', line 596

def label(object_name, method, content_or_options = nil, options = nil, &block)
  content_is_options = content_or_options.is_a?(Hash)
  if content_is_options || block_given?
    options = content_or_options if content_is_options
    text = nil
  else
    text = content_or_options
  end

  options ||= {}
  InstanceTag.new(object_name, method, self, options.delete(:object)).to_label_tag(text, options, &block)
end

#number_field(object_name, method, options = {}) ⇒ Object

Returns an input tag of type "number".

Options

  • Accepts same options as number_field_tag


840
841
842
 
# File 'lib/action_view/helpers/form_helper.rb', line 840

def number_field(object_name, method, options = {})
  InstanceTag.new(object_name, method, self, options.delete(:object)).to_number_field_tag("number", options)
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)

=> 

password_field(:account, :secret, :class => "form_input")
# => <input type="password" 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="password" 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="password" id="account_pin" name="account[pin]" size="20" value="#{@account.pin}" class="form_input" />


649
650
651
 
# File 'lib/action_view/helpers/form_helper.rb', line 649

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 = {}) ⇒ 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.

To force the radio button to be checked pass :checked => true in the options hash. 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" />


798
799
800
 
# File 'lib/action_view/helpers/form_helper.rb', line 798

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

#range_field(object_name, method, options = {}) ⇒ Object

Returns an input tag of type "range".

Options

  • Accepts same options as range_field_tag


848
849
850
 
# File 'lib/action_view/helpers/form_helper.rb', line 848

def range_field(object_name, method, options = {})
  InstanceTag.new(object_name, method, self, options.delete(:object)).to_number_field_tag("range", options)
end

#search_field(object_name, method, options = {}) ⇒ Object

Returns a text_field of type "search".



803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
 
# File 'lib/action_view/helpers/form_helper.rb', line 803

def search_field(object_name, method, options = {})
  options = options.stringify_keys

  if options["autosave"]
    if options["autosave"] == true
      options["autosave"] = request.host.split(".").reverse.join(".")
    end
    options["results"] ||= 10
  end

  if options["onsearch"]
    options["incremental"] = true unless options.has_key?("incremental")
  end

  InstanceTag.new(object_name, method, self, options.delete("object")).to_input_field_tag("search", options)
end

#telephone_field(object_name, method, options = {}) ⇒ Object Also known as: phone_field

Returns a text_field of type "tel".



821
822
823
 
# File 'lib/action_view/helpers/form_helper.rb', line 821

def telephone_field(object_name, method, options = {})
  InstanceTag.new(object_name, method, self, options.delete(:object)).to_input_field_tag("tel", options)
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)

=> 

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>


714
715
716
 
# File 'lib/action_view/helpers/form_helper.rb', line 714

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 = {}) ⇒ 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)

=> 

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


627
628
629
 
# File 'lib/action_view/helpers/form_helper.rb', line 627

def text_field(object_name, method, options = {})
  InstanceTag.new(object_name, method, self, options.delete(:object)).to_input_field_tag("text", options)
end

#url_field(object_name, method, options = {}) ⇒ Object

Returns a text_field of type "url".



827
828
829
 
# File 'lib/action_view/helpers/form_helper.rb', line 827

def url_field(object_name, method, options = {})
  InstanceTag.new(object_name, method, self, options.delete(:object)).to_input_field_tag("url", options)
end