module ActionView::Helpers::FormOptionsHelper
def collection_check_boxes(object, method, collection, value_method, text_method, options = {}, html_options = {}, &block)
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)
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 = {})
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 = {})
Note: Only the
...
...
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
* +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
Parameters:
groups them by
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)
# =>
# =>
# =>
# =>
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)
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.