module ActionView::Helpers::FormOptionsHelper

def collection_check_boxes(object, method, collection, value_method, text_method, options = {}, html_options = {}, &block)

include_hidden: false option to the helper method.
In the rare case you don't want this hidden field, you can pass the

blank value.
This hidden field is given the same field name as the checkboxes with a
for every collection of checkboxes.
This is possible thanks to a hidden field generated by the helper method

will not be updated.
If no +category_ids+ are selected then we can safely assume this field

@user.update(params[:user])

have the following code in our update action:
For example, if we have a +User+ model with +category_ids+ field and we

web browsers will not send any value.
When no selection is made for a collection of checkboxes most

==== Gotcha

end
b.label(:"data-value" => b.value) { b.check_box + b.text }
collection_check_boxes(:post, :author_ids, Author.all, :id, :name_with_initial) do |b|
respectively. You can use them like this:
value, which are the current item being rendered, its text and value methods,
There are also three special methods available: object, text and

end
b.label(class: "check_box") { b.check_box(class: "check_box") }
collection_check_boxes(:post, :author_ids, Author.all, :id, :name_with_initial) do |b|
extra HTML options:
The builder methods label and check_box also accept

use the label as wrapper, as in the example above.
Using it, you can change the label and check box display order or even
for the current item in the collection, with proper text and value.
collection, which has the ability to generate the label and check box
The argument passed to the block is a special kind of builder for this

end
b.label { b.check_box }
collection_check_boxes(:post, :author_ids, Author.all, :id, :name_with_initial) do |b|
giving a block to the method:
It is also possible to customize the way the elements will be shown by








If @post.author_ids is already [1], this would return:

collection_check_boxes(:post, :author_ids, Author.all, :id, :name_with_initial)
Sample usage (selecting the associated Author for an instance of Post, @post):

end
end
"#{first_name.first}. #{last_name}"
def name_with_initial
has_and_belongs_to_many :posts
class Author < ActiveRecord::Base
end
has_and_belongs_to_many :authors
class Post < ActiveRecord::Base
Example object structure for use with this method:

retrieve the value/text.
as a +proc+, that will be called for each member of the +collection+ to
respectively. They can also be any object that responds to +call+, such
are used as the +value+ attribute and contents of each check box tag,
methods to be called on each member of +collection+. The return values
The :value_method and :text_method parameters are

+nil+, no selection is made.
on the instance +object+ will be selected. If calling +method+ returns
+method+ for +object+'s class. The value returned from calling +method+
Returns check box tags for the collection of existing return values of
def collection_check_boxes(object, method, collection, value_method, text_method, options = {}, html_options = {}, &block)
  Tags::CollectionCheckBoxes.new(object, method, self, collection, value_method, text_method, options, html_options).render(&block)
end

def collection_radio_buttons(object, method, collection, value_method, text_method, options = {}, html_options = {}, &block)

include_hidden: false option.
In case if you don't want the helper to generate this hidden field you can specify

every collection of radio buttons. The hidden field has the same name as collection radio button and blank value.
To prevent this the helper generates an auxiliary hidden field before

will raise an error since no {user: ...} will be present.

params.require(:user).permit(...)

any strong parameters idiom like:
if a +User+ model has a +category_id+ field and in the form no category is selected, no +category_id+ parameter is sent. So,
Unfortunately this introduces a gotcha:
web browsers do not send any value to server.
The HTML specification says when nothing is selected on a collection of radio buttons

==== Gotcha

end
b.label(:"data-value" => b.value) { b.radio_button + b.text }
collection_radio_buttons(:post, :author_id, Author.all, :id, :name_with_initial) do |b|
respectively. You can use them like this:
value, which are the current item being rendered, its text and value methods,
There are also three special methods available: object, text and

end
b.label(class: "radio_button") { b.radio_button(class: "radio_button") }
collection_radio_buttons(:post, :author_id, Author.all, :id, :name_with_initial) do |b|
extra HTML options:
The builder methods label and radio_button also accept

even use the label as wrapper, as in the example above.
Using it, you can change the label and radio button display order or
for the current item in the collection, with proper text and value.
collection, which has the ability to generate the label and radio button
The argument passed to the block is a special kind of builder for this

end
b.label { b.radio_button }
collection_radio_buttons(:post, :author_id, Author.all, :id, :name_with_initial) do |b|
giving a block to the method:
It is also possible to customize the way the elements will be shown by







If @post.author_id is already 1, this would return:

collection_radio_buttons(:post, :author_id, Author.all, :id, :name_with_initial)
Sample usage (selecting the associated Author for an instance of Post, @post):

end
end
"#{first_name.first}. #{last_name}"
def name_with_initial
has_many :posts
class Author < ActiveRecord::Base
end
belongs_to :author
class Post < ActiveRecord::Base
Example object structure for use with this method:

retrieve the value/text.
as a +proc+, that will be called for each member of the +collection+ to
respectively. They can also be any object that responds to +call+, such
are used as the +value+ attribute and contents of each radio button tag,
methods to be called on each member of +collection+. The return values
The :value_method and :text_method parameters are

returns +nil+, no selection is made.
+method+ on the instance +object+ will be selected. If calling +method+
of +method+ for +object+'s class. The value returned from calling
Returns radio button tags for the collection of existing return values
def collection_radio_buttons(object, method, collection, value_method, text_method, options = {}, html_options = {}, &block)
  Tags::CollectionRadioButtons.new(object, method, self, collection, value_method, text_method, options, html_options).render(&block)
end

def collection_select(object, method, collection, value_method, text_method, options = {}, html_options = {})






and tags for the collection of existing return values of
def collection_select(object, method, collection, value_method, text_method, options = {}, html_options = {})
  Tags::CollectionSelect.new(object, method, self, collection, value_method, text_method, options, html_options).render
end

def extract_selected_and_disabled(selected)

def extract_selected_and_disabled(selected)
  if selected.is_a?(Proc)
    [selected, nil]
  else
    selected = Array.wrap(selected)
    options = selected.extract_options!.symbolize_keys
    selected_items = options.fetch(:selected, selected)
    [selected_items, options[:disabled]]
  end
end

def extract_values_from_collection(collection, value_method, selected)

def extract_values_from_collection(collection, value_method, selected)
  if selected.is_a?(Proc)
    collection.map do |element|
      public_or_deprecated_send(element, value_method) if selected.call(element)
    end.compact
  else
    selected
  end
end

def grouped_collection_select(object, method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})











, and tags for the collection of existing return values of
def grouped_collection_select(object, method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
  Tags::GroupedCollectionSelect.new(object, method, self, collection, group_method, group_label_method, option_key_method, option_value_method, options, html_options).render
end

def grouped_options_for_select(grouped_options, selected_key = nil, options = {})

wrap the output in an appropriate tag.
Note: Only the and tags are returned, so you still have to


...





...



Possible output:

option_groups_from_collection_for_select(@continents, :countries, :name, :id, :name, 3)
Sample usage:

end
# attribs: id, name, continent_id
belongs_to :continent
class Country < ActiveRecord::Base

end
# attribs: id, name
has_many :countries
class Continent < ActiveRecord::Base

Example object structure for use with this method:

to be specified.
to +option_key_method+. If +nil+, no selection is made. Can also be a hash if disabled values are
which will have the +selected+ attribute set. Corresponds to the return value of one of the calls
* +selected_key+ - A value equal to the +value+ attribute for one of the tags,
+collection+, returns a value to be used as the contents of its tag.
* +option_value_method+ - The name of a method which, when called on a child object of a member of
+collection+, returns a value to be used as the +value+ attribute for its tag.
* +option_key_method+ - The name of a method which, when called on a child object of a member of
string to be used as the +label+ attribute for its tag.
* +group_label_method+ - The name of a method which, when called on a member of +collection+, returns a
array of child objects representing the tags.
* +group_method+ - The name of a method which, when called on a member of +collection+, returns an
* +collection+ - An array of objects representing the tags.
Parameters:

groups them by tags based on the object relationships of the arguments.
Returns a string of tags, like options_from_collection_for_select, but
def option_groups_from_collection_for_select(collection, group_method, group_label_method, option_key_method, option_value_method, selected_key = nil)
  collection.map do |group|
    option_tags = options_from_collection_for_select(
      value_for_collection(group, group_method), option_key_method, option_value_method, selected_key)
    content_tag("optgroup", option_tags, label: value_for_collection(group, group_label_method))
  end.join.html_safe
end

def option_html_attributes(element)

def option_html_attributes(element)
  if Array === element
    element.select { |e| Hash === e }.reduce({}, :merge!)
  else
    {}
  end
end

def option_text_and_value(option)

def option_text_and_value(option)
  # Options are [text, value] pairs or strings used for both.
  if !option.is_a?(String) && option.respond_to?(:first) && option.respond_to?(:last)
    option = option.reject { |e| Hash === e } if Array === option
    [option.first, option.last]
  else
    [option, option]
  end
end

def option_value_selected?(value, selected)

def option_value_selected?(value, selected)
  Array(selected).include? value
end

def options_for_select(container, selected = nil)

NOTE: Only the option tags are returned, you have to wrap this call in a regular HTML select tag.

# =>
# =>
# =>
# =>
options_for_select(["Free", "Basic", "Advanced", "Super Platinum"], selected: "Free", disabled: "Super Platinum")

# =>
# =>
# =>
# =>
options_for_select(["Free", "Basic", "Advanced", "Super Platinum"], disabled: ["Advanced", "Super Platinum"])

# =>
# =>
# =>
# =>
options_for_select(["Free", "Basic", "Advanced", "Super Platinum"], disabled: "Super Platinum")

or array of values to be disabled. In this case, you can use :selected to specify selected option tags.
If you wish to specify disabled option tags, set +selected+ to be a hash, with :disabled being either a value

# =>
# =>
options_for_select([["Dollar", "$", { class: "bold" }], ["Kroner", "DKK", { onclick: "alert('HI');" }]])

# =>
# =>
# =>
options_for_select([ "Denmark", ["USA", { class: 'bold' }], "Sweden" ], ["USA", "Sweden"])

You can optionally provide HTML attributes as the last element of the array.

# =>
# =>
# =>
options_for_select([ "VISA", "MasterCard", "Discover" ], ["VISA", "Discover"])

# =>
# =>
options_for_select({ "Basic" => "$20", "Plus" => "$40" }, "$40")

# =>
# =>
options_for_select([ "VISA", "MasterCard" ], "MasterCard")

# =>
# =>
options_for_select([["Dollar", "$"], ["Kroner", "DKK"]])

may also be an array of values to be selected when using a multiple select.
become lasts. If +selected+ is specified, the matching "last" or element will get the selected option-tag. +selected+
the "firsts" as option text. Hashes are turned into this form automatically, so the keys become "firsts" and values
where the elements respond to first and last (such as a two-element array), the "lasts" serve as option values and
Accepts a container (hash, array, enumerable, your type) and returns a string of option tags. Given a container
def options_for_select(container, selected = nil)
  return container if String === container
  selected, disabled = extract_selected_and_disabled(selected).map do |r|
    Array(r).map(&:to_s)
  end
  container.map do |element|
    html_attributes = option_html_attributes(element)
    text, value = option_text_and_value(element).map(&:to_s)
    html_attributes[:selected] ||= option_value_selected?(value, selected)
    html_attributes[:disabled] ||= disabled && option_value_selected?(value, disabled)
    html_attributes[:value] = value
    tag_builder.content_tag_string(:option, text, html_attributes)
  end.join("\n").html_safe
end

def options_from_collection_for_select(collection, value_method, text_method, selected = nil)

should produce the desired results.
options_from_collection_for_select(@people, 'id', 'name', 1)
Will not select a person with the id of 1 because 1 (an Integer) is not the same as '1' (a string)
options_from_collection_for_select(@people, 'id', 'name', '1')
Failure to do this will produce undesired results. Example:
Be sure to specify the same class as the +value_method+ when specifying selected or disabled options.

+selected+ can also be a hash, specifying both :selected and/or :disabled values as required.

function are the selected values.
If +selected+ is specified as a Proc, those members of the collection that return true for the anonymous

will be selected option tag(s).
If +selected+ is specified as a value or array of values, the element(s) returning a match on +value_method+

select_tag 'person', options_from_collection_for_select(@people, 'id', 'name')

This is more often than not used inside a #select_tag like this example:

# =>
options_from_collection_for_select(@people, 'id', 'name')

the result of a call to the +value_method+ as the option value and the +text_method+ as the option text.
Returns a string of option tags that have been compiled by iterating over the +collection+ and assigning
def options_from_collection_for_select(collection, value_method, text_method, selected = nil)
  options = collection.map do |element|
    [value_for_collection(element, text_method), value_for_collection(element, value_method), option_html_attributes(element)]
  end
  selected, disabled = extract_selected_and_disabled(selected)
  select_deselect = {
    selected: extract_values_from_collection(collection, value_method, selected),
    disabled: extract_values_from_collection(collection, value_method, disabled)
  }
  options_for_select(options, select_deselect)
end

def prompt_text(prompt)

def prompt_text(prompt)
  prompt.kind_of?(String) ? prompt : I18n.translate("helpers.select.prompt", default: "Please select")
end

def public_or_deprecated_send(item, value)

def public_or_deprecated_send(item, value)
  item.public_send(value)
rescue NoMethodError
  raise unless item.respond_to?(value, true) && !item.respond_to?(value)
  ActiveSupport::Deprecation.warn "Using private methods from view helpers is deprecated (calling private #{item.class}##{value})"
  item.send(value)
end

def select(object, method, choices = nil, options = {}, html_options = {}, &block)


include_hidden: false option.
In case if you don't want the helper to generate this hidden field you can specify

always contains a blank string.
the deselected multiple select box), or both fields. This means that the resulting array
Note: The client either sends only the hidden field (representing

every multiple select. The hidden field has the same name as multiple select and blank value.
To prevent this the helper generates an auxiliary hidden field before

wouldn't update roles.

@user.update(params[:user])

any mass-assignment idiom like
the user deselects all roles from +role_ids+ multiple select box, no +role_ids+ parameter is sent. So,
if an +User+ model has many +roles+ and have +role_ids+ accessor, and in the form that edits roles of the user
web browsers do not send any value to server. Unfortunately this introduces a gotcha:
The HTML specification says when +multiple+ parameter passed to select and all options got deselected

==== Gotcha

end
end
content_tag(:option, c.name, value: c.id, data: { tags: c.tags.to_json })
available_campaigns.each do |c|
select(report, "campaign_ids") do

is useful when the options tag has complex attributes.
A block can be passed to +select+ to customize how the options tags will be rendered. This

tags by specifying the :disabled option. This can either be a single value or an array of values to be disabled.
or selected: nil to leave all options unselected. Similarly, you can specify values to be disabled in the option
By default, post.person_id is the selected option. Specify selected: value to use a different selection

In addition, this allows a single partial to be used to generate form inputs for both edit and create forms.
This allows the user to submit a form page more than once with the expected results of creating multiple records.
to the database. Instead, a second model object is created when the create request is received.
new model instance is assigned the default options and bound to @model_name. Usually this model is not saved
This can be used to provide a default set of options in the standard way: before rendering the create form, a

assuming the associated person has ID 1.