class ActionView::Helpers::FormBuilder - actionview-4.2.3 Documentation

# class ActionView::Helpers::FormBuilder

A `FormBuilder` object is associated with a particular model object and allows you to generate fields associated with the model object. The `FormBuilder` object is yielded when using `form_for` or `fields_for`. For example:

    <%= form_for @person do |person_form| %>
      Name: <%= person_form.text_field :name %>
      Admin: <%= person_form.check_box :admin %>
    <% end %>

In the above block, a `FormBuilder` object is yielded as the `person_form` variable. This allows you to generate the `text_field` and `check_box` fields by specifying their eponymous methods, which modify the underlying template and associates the +@person+ model object with the form.

The `FormBuilder` object can be thought of as serving as a proxy for the methods in the `FormHelper` module. This class, however, allows you to call methods with the model object you are building the form for.

You can create your own custom FormBuilder templates by subclassing this class. For example:

    class MyFormBuilder < ActionView::Helpers::FormBuilder
      def div_radio_button(method, tag_value, options = {})
        @template.content_tag(:div,
          @template.radio_button(
            @object_name, method, tag_value, objectify_options(options)
          )
        )
      end
    end

The above code creates a new method `div_radio_button` which wraps a div around the new radio button. Note that when options are passed in, you must call `objectify_options` in order for the model object to get correctly passed to the method. If `objectify_options` is not called, then the newly created helper will not be linked back to the model.

The `div_radio_button` code from above can now be used as follows:

    <%= form_for @person, :builder => MyFormBuilder do |f| %>
      I am a child: <%= f.div_radio_button(:admin, "child") %>
      I am an adult: <%= f.div_radio_button(:admin, "adult") %>
    <% end -%>

The standard set of helper methods for form building are located in the `field_helpers` class attribute.

### Attributes

index[R]
multipart[R]
multipart?[R]
object[RW]
object_name[RW]
options[RW]

### Public Class Methods

_to_partial_path() click to toggle source

    # File lib/action_view/helpers/form_helper.rb, line 1293
    def self._to_partial_path
      @_to_partial_path ||= name.demodulize.underscore.sub!(/_builder$/, '')
    end

new(object_name, object, template, options) click to toggle source

    # File lib/action_view/helpers/form_helper.rb, line 1305
    def initialize(object_name, object, template, options)
      @nested_child_index = {}
      @object_name, @object, @template, @options = object_name, object, template, options
      @default_options = @options ? @options.slice(:index, :namespace) : {}
      if @object_name.to_s.match(/\[\]$/)
        if object ||= @template.instance_variable_get("@#{Regexp.last_match.pre_match}") and object.respond_to?(:to_param)
          @auto_index = object.to_param
        else
          raise ArgumentError, "object[] naming but object param and @object var don't exist or don't respond to to_param: #{object.inspect}"
        end
      end
      @multipart = nil
      @index = options[:index] || options[:child_index]
    end

### Public Instance Methods

button(value = nil, options = {}, &block) click to toggle source

Add the submit button for the given form. When no value is given, it checks if the object is a new resource or not to create the proper label:

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

In the example above, if @post is a new record, it will use “Create Post” as button label, otherwise, it uses “Update Post”.

Those labels can be customized using I18n, under the helpers.submit key (the same as submit helper) and accept the %{model} as translation interpolation:

    en:
      helpers:
        submit:
          create: "Create a %{model}"
          update: "Confirm changes to %{model}"

It also searches for a key specific for the given object:

    en:
      helpers:
        submit:
          post:
            create: "Add %{model}"

#### Examples¶ ↑

    button("Create a post")
    # => <button name='button' type='submit'>Create post</button>

    button do
      content_tag(:strong, 'Ask me!')
    end
    # => <button name='button' type='submit'>
    #      <strong>Ask me!</strong>
    #    </button>

    # File lib/action_view/helpers/form_helper.rb, line 1858
    def button(value = nil, options = {}, &block)
      value, options = nil, value if value.is_a?(Hash)
      value ||= submit_default_value
      @template.button_tag(value, options, &block)
    end

check_box(method, options = {}, checked_value = "1", unchecked_value = "0") click to toggle source

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(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.

    # Let's say that @post.validated? is 1:
    check_box("post", "validated")
    # => <input name="post[validated]" type="hidden" value="0" />
    #    <input checked="checked" 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 lib/action_view/helpers/form_helper.rb, line 1709
    def check_box(method, options = {}, checked_value = "1", unchecked_value = "0")
      @template.check_box(@object_name, method, objectify_options(options), checked_value, unchecked_value)
    end

collection_check_boxes(method, collection, value_method, text_method, options = {}, html_options = {}, &block) click to toggle source

Wraps ActionView::Helpers::FormOptionsHelper#collection_check_boxes for form builders:

    <%= form_for @post do |f| %>
      <%= f.collection_check_boxes :author_ids, Author.all, :id, :name_with_initial %>
      <%= f.submit %>
    <% end %>

Please refer to the documentation of the base helper for details.

    # File lib/action_view/helpers/form_options_helper.rb, line 824
    def collection_check_boxes(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
      @template.collection_check_boxes(@object_name, method, collection, value_method, text_method, objectify_options(options), @default_options.merge(html_options), &block)
    end

collection_radio_buttons(method, collection, value_method, text_method, options = {}, html_options = {}, &block) click to toggle source

Wraps ActionView::Helpers::FormOptionsHelper#collection_radio_buttons for form builders:

    <%= form_for @post do |f| %>
      <%= f.collection_radio_buttons :author_id, Author.all, :id, :name_with_initial %>
      <%= f.submit %>
    <% end %>

Please refer to the documentation of the base helper for details.

    # File lib/action_view/helpers/form_options_helper.rb, line 836
    def collection_radio_buttons(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
      @template.collection_radio_buttons(@object_name, method, collection, value_method, text_method, objectify_options(options), @default_options.merge(html_options), &block)
    end

collection_select(method, collection, value_method, text_method, options = {}, html_options = {}) click to toggle source

Wraps ActionView::Helpers::FormOptionsHelper#collection_select for form builders:

    <%= form_for @post do |f| %>
      <%= f.collection_select :person_id, Author.all, :id, :name_with_initial, prompt: true %>
      <%= f.submit %>
    <% end %>

Please refer to the documentation of the base helper for details.

    # File lib/action_view/helpers/form_options_helper.rb, line 788
    def collection_select(method, collection, value_method, text_method, options = {}, html_options = {})
      @template.collection_select(@object_name, method, collection, value_method, text_method, objectify_options(options), @default_options.merge(html_options))
    end

date_select(method, options = {}, html_options = {}) click to toggle source

Wraps ActionView::Helpers::DateHelper#date_select for form builders:

    <%= form_for @person do |f| %>
      <%= f.date_select :birth_date %>
      <%= f.submit %>
    <% end %>

Please refer to the documentation of the base helper for details.

    # File lib/action_view/helpers/date_helper.rb, line 1069
    def date_select(method, options = {}, html_options = {})
      @template.date_select(@object_name, method, objectify_options(options), html_options)
    end

datetime_select(method, options = {}, html_options = {}) click to toggle source

Wraps ActionView::Helpers::DateHelper#datetime_select for form builders:

    <%= form_for @person do |f| %>
      <%= f.datetime_select :last_request_at %>
      <%= f.submit %>
    <% end %>

Please refer to the documentation of the base helper for details.

    # File lib/action_view/helpers/date_helper.rb, line 1093
    def datetime_select(method, options = {}, html_options = {})
      @template.datetime_select(@object_name, method, objectify_options(options), html_options)
    end

emitted_hidden_id?() click to toggle source

    # File lib/action_view/helpers/form_helper.rb, line 1864
    def emitted_hidden_id?
      @emitted_hidden_id ||= nil
    end

fields_for(record_name, record_object = nil, fields_options = {}, &block) click to toggle source

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.

Although the usage and purpose of `fields_for` is similar to `form_for`'s, its method signature is slightly different. Like `form_for`, it yields a FormBuilder object associated with a particular model object to a block, and within the block allows methods to be called on the builder to generate fields associated with the model object. Fields may reflect a model object in two ways - how they are named (hence how submitted values appear within the `params` hash in the controller) and what default values are shown when the form the fields appear in is first displayed. In order for both of these features to be specified independently, both an object name (represented by either a symbol or string) and the object itself can be passed to the method separately -

    <%= form_for @person do |person_form| %>
      First name: <%= person_form.text_field :first_name %>
      Last name : <%= person_form.text_field :last_name %>

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

      <%= person_form.submit %>
    <% end %>

In this case, the checkbox field will be represented by an HTML `input` tag with the `name` attribute `permission[admin]`, and the submitted value will appear in the controller as `params[:permission][:admin]`. If `@person.permission` is an existing record with an attribute `admin`, the initial state of the checkbox when first displayed will reflect the value of `@person.permission.admin`.

Often this can be simplified by passing just the name of the model object to `fields_for` -

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

…in which case, if `:permission` also happens to be the name of an instance variable `@permission`, the initial state of the input field will reflect the value of that variable's attribute `@permission.admin`.

Alternatively, you can pass just the model object itself (if the first argument isn't a string or symbol `fields_for` will realize that the name has been omitted) -

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

and `fields_for` will derive the required name of the field from the class of the model object, e.g. if `@person.permission`, is of class `Permission`, the field will still be named `permission[admin]`.

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

Note that the `projects_attributes=` writer method is in fact required for #fields_for to correctly identify `:projects` as a collection, and the correct indices to be set in the form markup.

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

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

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

When a collection is used you might want to know the index of each object into the array. For this purpose, the `index` method is available in the FormBuilder object.

    <%= form_for @person do |person_form| %>
      ...
      <%= person_form.fields_for :projects do |project_fields| %>
        Project #<%= project_fields.index %>
        ...
      <% end %>
      ...
    <% end %>

Note that #fields_for will automatically generate a hidden field to store the ID of the record. There are circumstances where this hidden field is not needed and you can pass `include_id: false` to prevent #fields_for from rendering it automatically.

    # File lib/action_view/helpers/form_helper.rb, line 1573
    def fields_for(record_name, record_object = nil, fields_options = {}, &block)
      fields_options, record_object = record_object, nil if record_object.is_a?(Hash) && record_object.extractable_options?
      fields_options[:builder] ||= options[:builder]
      fields_options[:namespace] = options[:namespace]
      fields_options[:parent_builder] = self

      case record_name
      when String, Symbol
        if nested_attributes_association?(record_name)
          return fields_for_with_nested_attributes(record_name, record_object, fields_options, block)
        end
      else
        record_object = record_name.is_a?(Array) ? record_name.last : record_name
        record_name   = model_name_from_record_or_class(record_object).param_key
      end

      index = if options.has_key?(:index)
        options[:index]
      elsif defined?(@auto_index)
        self.object_name = @object_name.to_s.sub(/\[\]$/,"")
        @auto_index
      end

      record_name = index ? "#{object_name}[#{index}][#{record_name}]" : "#{object_name}[#{record_name}]"
      fields_options[:child_index] = index

      @template.fields_for(record_name, record_object, fields_options, &block)
    end

file_field(method, options = {}) click to toggle source

Returns a 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.

Using this method inside a `form_for` block will set the enclosing form's encoding to `multipart/form-data`.

#### Options¶ ↑

- Creates standard HTML attributes for the tag.

- `:disabled` - If set to true, the user will not be able to use this input.

- `:multiple` - If set to true, *in most updated browsers* the user will be allowed to select multiple files.

- `:accept` - If set to one or multiple mime-types, the user will be suggested a filter when choosing a file. You still need to set up model validations.

#### Examples¶ ↑

    file_field(:user, :avatar)
    # => <input type="file" id="user_avatar" name="user[avatar]" />

    file_field(:post, :image, :multiple => true)
    # => <input type="file" id="post_image" name="post[image]" multiple="true" />

    file_field(:post, :attached, accept: 'text/html')
    # => <input accept="text/html" type="file" id="post_attached" name="post[attached]" />

    file_field(:post, :image, accept: 'image/png,image/gif,image/jpeg')
    # => <input type="file" id="post_image" name="post[image]" accept="image/png,image/gif,image/jpeg" />

    file_field(:attachment, :file, class: 'file_input')
    # => <input type="file" id="attachment_file" name="attachment[file]" class="file_input" />

    # File lib/action_view/helpers/form_helper.rb, line 1782
    def file_field(method, options = {})
      self.multipart = true
      @template.file_field(@object_name, method, objectify_options(options))
    end

grouped_collection_select(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {}) click to toggle source

Wraps ActionView::Helpers::FormOptionsHelper#grouped_collection_select for form builders:

    <%= form_for @city do |f| %>
      <%= f.grouped_collection_select :country_id, @continents, :countries, :name, :id, :name %>
      <%= f.submit %>
    <% end %>

Please refer to the documentation of the base helper for details.

    # File lib/action_view/helpers/form_options_helper.rb, line 800
    def grouped_collection_select(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
      @template.grouped_collection_select(@object_name, method, collection, group_method, group_label_method, option_key_method, option_value_method, objectify_options(options), @default_options.merge(html_options))
    end

hidden_field(method, options = {}) click to toggle source

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 lib/action_view/helpers/form_helper.rb, line 1749
    def hidden_field(method, options = {})
      @emitted_hidden_id = true if method == :id
      @template.hidden_field(@object_name, method, objectify_options(options))
    end

label(method, text = nil, options = {}, &block) click to toggle source

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.<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 `: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)
    # => <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)

    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 (if you are using ActiveRecord):

    activerecord:
      attributes:
        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>.'.html_safe
    end

    # File lib/action_view/helpers/form_helper.rb, line 1649
    def label(method, text = nil, options = {}, &block)
      @template.label(@object_name, method, text, objectify_options(options), &block)
    end

multipart=(multipart) click to toggle source

    # File lib/action_view/helpers/form_helper.rb, line 1285
    def multipart=(multipart)
      @multipart = multipart

      if parent_builder = @options[:parent_builder]
        parent_builder.multipart = multipart
      end
    end

radio_button(method, tag_value, options = {}) click to toggle source

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.

    # 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 lib/action_view/helpers/form_helper.rb, line 1730
    def radio_button(method, tag_value, options = {})
      @template.radio_button(@object_name, method, tag_value, objectify_options(options))
    end

select(method, choices = nil, options = {}, html_options = {}, &block) click to toggle source

Wraps ActionView::Helpers::FormOptionsHelper#select for form builders:

    <%= form_for @post do |f| %>
      <%= f.select :person_id, Person.all.collect { |p| [ p.name, p.id ] }, include_blank: true %>
      <%= f.submit %>
    <% end %>

Please refer to the documentation of the base helper for details.

    # File lib/action_view/helpers/form_options_helper.rb, line 776
    def select(method, choices = nil, options = {}, html_options = {}, &block)
      @template.select(@object_name, method, choices, objectify_options(options), @default_options.merge(html_options), &block)
    end

submit(value=nil, options={}) click to toggle source

Add the submit button for the given form. When no value is given, it checks if the object is a new resource or not to create the proper label:

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

In the example above, if @post is a new record, it will use “Create Post” as submit button label, otherwise, it uses “Update Post”.

Those labels can be customized using I18n, under the helpers.submit key and accept the %{model} as translation interpolation:

    en:
      helpers:
        submit:
          create: "Create a %{model}"
          update: "Confirm changes to %{model}"

It also searches for a key specific for the given object:

    en:
      helpers:
        submit:
          post:
            create: "Add %{model}"

    # File lib/action_view/helpers/form_helper.rb, line 1814
    def submit(value=nil, options={})
      value, options = nil, value if value.is_a?(Hash)
      value ||= submit_default_value
      @template.submit_tag(value, options)
    end

time_select(method, options = {}, html_options = {}) click to toggle source

Wraps ActionView::Helpers::DateHelper#time_select for form builders:

    <%= form_for @race do |f| %>
      <%= f.time_select :average_lap %>
      <%= f.submit %>
    <% end %>

Please refer to the documentation of the base helper for details.

    # File lib/action_view/helpers/date_helper.rb, line 1081
    def time_select(method, options = {}, html_options = {})
      @template.time_select(@object_name, method, objectify_options(options), html_options)
    end

time_zone_select(method, priority_zones = nil, options = {}, html_options = {}) click to toggle source

Wraps ActionView::Helpers::FormOptionsHelper#time_zone_select for form builders:

    <%= form_for @user do |f| %>
      <%= f.time_zone_select :time_zone, nil, include_blank: true %>
      <%= f.submit %>
    <% end %>

Please refer to the documentation of the base helper for details.

    # File lib/action_view/helpers/form_options_helper.rb, line 812
    def time_zone_select(method, priority_zones = nil, options = {}, html_options = {})
      @template.time_zone_select(@object_name, method, priority_zones, objectify_options(options), @default_options.merge(html_options))
    end

to_model() click to toggle source

    # File lib/action_view/helpers/form_helper.rb, line 1301
    def to_model
      self
    end

to_partial_path() click to toggle source

    # File lib/action_view/helpers/form_helper.rb, line 1297
    def to_partial_path
      self.class._to_partial_path
    end

### Private Instance Methods

fields_for_nested_model(name, object, fields_options, block) click to toggle source

    # File lib/action_view/helpers/form_helper.rb, line 1918
    def fields_for_nested_model(name, object, fields_options, block)
      object = convert_to_model(object)
      emit_hidden_id = object.persisted? && fields_options.fetch(:include_id) {
        options.fetch(:include_id, true)
      }

      @template.fields_for(name, object, fields_options) do |f|
        output = @template.capture(f, &block)
        output.concat f.hidden_field(:id) if output && emit_hidden_id && !f.emitted_hidden_id?
        output
      end
    end

fields_for_with_nested_attributes(association_name, association, options, block) click to toggle source

    # File lib/action_view/helpers/form_helper.rb, line 1895
    def fields_for_with_nested_attributes(association_name, association, options, block)
      name = "#{object_name}[#{association_name}_attributes]"
      association = convert_to_model(association)

      if association.respond_to?(:persisted?)
        association = [association] if @object.send(association_name).respond_to?(:to_ary)
      elsif !association.respond_to?(:to_ary)
        association = @object.send(association_name)
      end

      if association.respond_to?(:to_ary)
        explicit_child_index = options[:child_index]
        output = ActiveSupport::SafeBuffer.new
        association.each do |child|
          options[:child_index] = nested_child_index(name) unless explicit_child_index
          output << fields_for_nested_model("#{name}[#{options[:child_index]}]", child, options, block)
        end
        output
      elsif association
        fields_for_nested_model(name, association, options, block)
      end
    end

nested_attributes_association?(association_name) click to toggle source

    # File lib/action_view/helpers/form_helper.rb, line 1891
    def nested_attributes_association?(association_name)
      @object.respond_to?("#{association_name}_attributes=")
    end

nested_child_index(name) click to toggle source

    # File lib/action_view/helpers/form_helper.rb, line 1931
    def nested_child_index(name)
      @nested_child_index[name] ||= -1
      @nested_child_index[name] += 1
    end

objectify_options(options) click to toggle source

    # File lib/action_view/helpers/form_helper.rb, line 1869
    def objectify_options(options)
      @default_options.merge(options.merge(object: @object))
    end

submit_default_value() click to toggle source

    # File lib/action_view/helpers/form_helper.rb, line 1873
    def submit_default_value
      object = convert_to_model(@object)
      key    = object ? (object.persisted? ? :update : :create) : :submit

      model = if object.respond_to?(:model_name)
        object.model_name.human
      else
        @object_name.to_s.humanize
      end

      defaults = []
      defaults << :"helpers.submit.#{object_name}.#{key}"
      defaults << :"helpers.submit.#{key}"
      defaults << "#{key.to_s.humanize} #{model}"

      I18n.t(defaults.shift, model: model, default: defaults)
    end