Provides a number of methods for turning different kinds of containers into a set of option tags.

Options

The collection_select, selectand time_zone_selectmethods take an options parameter, a hash:

  • :include_blank- set to true or a prompt string if the first option element of the select element is a blank. Useful if there is not a default value required for the select element.

For example,

select("post", "category", Post::CATEGORIES, {:include_blank => true})

could become:

<select name="post[category]">
  <option></option>
  <option>joke</option>
  <option>poem</option>
</select>

Another common case is a select tag for an belongs_to-associated object.

Example with @post.person_id => 2:

select("post", "person_id", Person.all.collect {|p| [ p.name, p.id ] }, {:include_blank => 'None'})

could become:

<select name="post[person_id]">
  <option value="">None</option>
  <option value="1">David</option>
  <option value="2" selected="selected">Sam</option>
  <option value="3">Tobias</option>
</select>
  • :prompt- set to true or a prompt string. When the select element doesn't have a value yet, this prepends an option with a generic prompt – “Please select” – or the given prompt string.

Example:

select("post", "person_id", Person.all.collect {|p| [ p.name, p.id ] }, {:prompt => 'Select Person'})

could become:

<select name="post[person_id]">
  <option value="">Select Person</option>
  <option value="1">David</option>
  <option value="2">Sam</option>
  <option value="3">Tobias</option>
</select>

Like the other form helpers, selectcan accept an :indexoption to manually set the ID used in the resulting output. Unlike other helpers, selectexpects this option to be in the html_optionsparameter.

Example:

select("album[]", "genre", %w[rap rock country], {}, { :index => nil })

becomes:

<select name="album[][genre]" id="album__genre">
  <option value="rap">rap</option>
  <option value="rock">rock</option>
  <option value="country">country</option>
</select>
  • :disabled- can be a single value or an array of values that will be disabled options in the final output.

Example:

select("post", "category", Post::CATEGORIES, {:disabled => 'restricted'})

could become:

<select name="post[category]">
  <option></option>
  <option>joke</option>
  <option>poem</option>
  <option disabled="disabled">restricted</option>
</select>

When used with the collection_selecthelper, :disabledcan also be a Proc that identifies those options that should be disabled.

Example:

collection_select(:post, :category_id, Category.all, :id, :name, {:disabled => lambda{|category| category.archived? }})

If the categories “2008 stuff” and “Christmas” return true when the method archived?is called, this would return:

<select name="post[category_id]">
  <option value="1" disabled="disabled">2008 stuff</option>
  <option value="2" disabled="disabled">Christmas</option>
  <option value="3">Jokes</option>
  <option value="4">Poems</option>
</select>
Methods
C
G
O
S
T
Included Modules
Instance Public methods
collection_select(object, method, collection, value_method, text_method, options = {}, html_options = {})

Returns <select>and <option>tags for the collection of existing return values of methodfor object's class. The value returned from calling methodon the instance objectwill be selected. If calling methodreturns nil, no selection is made without including :promptor :include_blank in the optionshash.

The :value_methodand :text_methodparameters are methods to be called on each member of collection. The return values are used as the valueattribute and contents of each <option>tag, respectively.

Example object structure for use with this method:

class Post < ActiveRecord::Base
  belongs_to :author
end
class Author < ActiveRecord::Base
  has_many :posts
  def name_with_initial
    "#{first_name.first}. #{last_name}"
  end
end

Sample usage (selecting the associated Author for an instance of Post, @post):

collection_select(:post, :author_id, Author.all, :id, :name_with_initial, {:prompt => true})

If @post.author_idis already 1, this would return:

<select name="post[author_id]">
  <option value="">Please select</option>
  <option value="1" selected="selected">D. Heinemeier Hansson</option>
  <option value="2">D. Thomas</option>
  <option value="3">M. Clark</option>
</select>
# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 161
def collection_select(object, method, collection, value_method, text_method, options = {}, html_options = {})
  InstanceTag.new(object, method, self, options.delete(:object)).to_collection_select_tag(collection, value_method, text_method, options, html_options)
end
grouped_collection_select(object, method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})

Returns <select>, <optgroup>and <option>tags for the collection of existing return values of methodfor object's class. The value returned from calling methodon the instance objectwill be selected. If calling method returns nil, no selection is made without including :promptor :include_blankin the optionshash.

Parameters:

  • object- The instance of the class to be used for the select tag

  • method- The attribute of objectcorresponding to the select tag

  • collection- An array of objects representing the <optgroup>tags.

  • group_method- The name of a method which, when called on a member of collection, returns an array of child objects representing the <option>tags.

  • group_label_method- The name of a method which, when called on a member of collection, returns a string to be used as the labelattribute for its <optgroup>tag.

  • option_key_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 valueattribute for its <option>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 contents of its <option>tag.

Example object structure for use with this method:

class Continent < ActiveRecord::Base
  has_many :countries
  # attribs: id, name
end
class Country < ActiveRecord::Base
  belongs_to :continent
  # attribs: id, name, continent_id
end
class City < ActiveRecord::Base
  belongs_to :country
  # attribs: id, name, country_id
end

Sample usage:

grouped_collection_select(:city, :country_id, @continents, :countries, :name, :id, :name)

Possible output:

<select name="city[country_id]">
  <optgroup label="Africa">
    <option value="1">South Africa</option>
    <option value="3">Somalia</option>
  </optgroup>
  <optgroup label="Europe">
    <option value="7" selected="selected">Denmark</option>
    <option value="2">Ireland</option>
  </optgroup>
</select>
# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 213
def grouped_collection_select(object, method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
  InstanceTag.new(object, method, self, options.delete(:object)).to_grouped_collection_select_tag(collection, group_method, group_label_method, option_key_method, option_value_method, options, html_options)
end
grouped_options_for_select(grouped_options, selected_key = nil, prompt = nil)

Returns a string of <option>tags, like options_for_select, but wraps them with <optgroup>tags.

Parameters:

  • grouped_options- Accepts a nested array or hash of strings. The first value serves as the <optgroup>label while the second value must be an array of options. The second value can be a nested array of text-value pairs. See options_for_selectfor more info.

    Ex. ["North America",[["United States","US"],["Canada","CA"]]]
  • selected_key- A value equal to the value attribute for one of the <option>tags, which will have the selectedattribute set. Note: It is possible for this value to match multiple options as you might have the same option in multiple groups. Each will then get selected="selected".

  • prompt- set to true or a prompt string. When the select element doesn’t have a value yet, this prepends an option with a generic prompt — “Please select” — or the given prompt string.

Sample usage (Array):

grouped_options = [
 ['North America',
   [['United States','US'],'Canada']],
 ['Europe',
   ['Denmark','Germany','France']]
]
grouped_options_for_select(grouped_options)

Sample usage (Hash):

grouped_options = {
 'North America' => [['United States','US], 'Canada'],
 'Europe' => ['Denmark','Germany','France']
}
grouped_options_for_select(grouped_options)

Possible output:

<optgroup label="Europe">
  <option value="Denmark">Denmark</option>
  <option value="Germany">Germany</option>
  <option value="France">France</option>
</optgroup>
<optgroup label="North America">
  <option value="US">United States</option>
  <option value="Canada">Canada</option>
</optgroup>

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

# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 436
def grouped_options_for_select(grouped_options, selected_key = nil, prompt = nil)
  body = ''
  body << content_tag(:option, prompt, :value => "") if prompt
  grouped_options = grouped_options.sort if grouped_options.is_a?(Hash)
  grouped_options.each do |group|
    body << content_tag(:optgroup, options_for_select(group[1], selected_key), :label => group[0])
  end
  body
end
option_groups_from_collection_for_select(collection, group_method, group_label_method, option_key_method, option_value_method, selected_key = nil)

Returns a string of <option>tags, like options_from_collection_for_select, but groups them by <optgroup>tags based on the object relationships of the arguments.

Parameters:

  • collection- An array of objects representing the <optgroup>tags.

  • group_method- The name of a method which, when called on a member of collection, returns an array of child objects representing the <option>tags.

  • group_label_method+ - The name of a method which, when called on a member of collection, returns a string to be used as the labelattribute for its <optgroup>tag.

  • option_key_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 valueattribute for its <option>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 contents of its <option>tag.

  • selected_key- A value equal to the value attribute for one of the <option>tags, which will have the selectedattribute set. Corresponds to the return value of one of the calls to option_key_method. If nil, no selection is made. Can also be a hash if disabled values are to be specified.

Example object structure for use with this method:

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

Sample usage:

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

Possible output:

<optgroup label="Africa">
  <option value="1">Egypt</option>
  <option value="4">Rwanda</option>
  ...
</optgroup>
<optgroup label="Asia">
  <option value="3" selected="selected">China</option>
  <option value="12">India</option>
  <option value="5">Japan</option>
  ...
</optgroup>

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

# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 384
def option_groups_from_collection_for_select(collection, group_method, group_label_method, option_key_method, option_value_method, selected_key = nil)
  collection.inject("") do |options_for_select, group|
    group_label_string = eval("group.#{group_label_method}")
    options_for_select += "<optgroup label=\"#{html_escape(group_label_string)}\">"
    options_for_select += options_from_collection_for_select(eval("group.#{group_method}"), option_key_method, option_value_method, selected_key)
    options_for_select += '</optgroup>'
  end
end
options_for_select(container, selected = nil)

Accepts a container (hash, array, enumerable, your type) and returns a string of option tags. Given a container where the elements respond to first and last (such as a two-element array), the “lasts” serve as option values and the “firsts” as option text. Hashes are turned into this form automatically, so the keys become “firsts” and values become lasts. If selectedis specified, the matching “last” or element will get the selected option-tag. selectedmay also be an array of values to be selected when using a multiple select.

Examples (call, result):

options_for_select([["Dollar", "$"], ["Kroner", "DKK"]])
  <option value="$">Dollar</option>\n<option value="DKK">Kroner</ption>
options_for_select([ "VISA", "MasterCard" ], "MasterCard")
  <option>VISA</option>\n<option selected="selected">MasterCard</ption>
options_for_select({ "Basic" => "$20", "Plus" => "$40" }, "$40")
  <option value="$20">Basic</option>\n<option value="$40" selected="selected">Plus</ption>
options_for_select([ "VISA", "MasterCard", "Discover" ], ["VISA", "Discover"])
  <option selected="selected">VISA</option>\n<option>MasterCard</ption>\n<option selected="selected">Discover</option>

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

Examples:

options_for_select(["Free", "Basic", "Advanced", "Super Platinum"], :disabled => "Super Platinum")
  <option value="Free">Free</option>\n<option value="Basic">Basic</ption>\n<option value="Advanced">Advanced</option>\n<option value="Super Platinum" disabled="disabled">Super Platinum</ption>
options_for_select(["Free", "Basic", "Advanced", "Super Platinum"], :disabled => ["Advanced", "Super Platinum"])
  <option value="Free">Free</option>\n<option value="Basic">Basic</ption>\n<option value="Advanced" disabled="disabled">Advanced</option>\n<option value="Super Platinum" disabled="disabled">Super Platinum</ption>
options_for_select(["Free", "Basic", "Advanced", "Super Platinum"], :selected => "Free", :disabled => "Super Platinum")
  <option value="Free" selected="selected">Free</option>\n<option value="Basic">Basic</ption>\n<option value="Advanced">Advanced</option>\n<option value="Super Platinum" disabled="disabled">Super Platinum</ption>

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

# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 286
def options_for_select(container, selected = nil)
  return container if String === container
  container = container.to_a if Hash === container
  selected, disabled = extract_selected_and_disabled(selected)
  options_for_select = container.inject([]) do |options, element|
    text, value = option_text_and_value(element)
    selected_attribute = ' selected="selected"' if option_value_selected?(value, selected)
    disabled_attribute = ' disabled="disabled"' if disabled && option_value_selected?(value, disabled)
    options << %Q(<option value="#{html_escape(value.to_s)}"#{selected_attribute}#{disabled_attribute}>#{html_escape(text.to_s)}</option>)
  end
  options_for_select.join("\n").html_safe
end
options_from_collection_for_select(collection, value_method, text_method, selected = nil)

Returns a string of option tags that have been compiled by iterating over the collectionand assigning the the result of a call to the value_methodas the option value and the text_methodas the option text. Example:

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

This will output the same HTML as if you did this:

<option value="#{person.id}">#{person.name}</option>

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

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

If selectedis specified as a value or array of values, the element(s) returning a match on value_methodwill be selected option tag(s).

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

selectedcan also be a hash, specifying both :selectedand/or :disabledvalues as required.

Be sure to specify the same class as the value_methodwhen specifying selected or disabled options. Failure to do this will produce undesired results. Example:

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)

should produce the desired results.

# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 326
def options_from_collection_for_select(collection, value_method, text_method, selected = nil)
  options = collection.map do |element|
    [element.send(text_method), element.send(value_method)]
  end
  selected, disabled = extract_selected_and_disabled(selected)
  select_deselect = {}
  select_deselect[:selected] = extract_values_from_collection(collection, value_method, selected)
  select_deselect[:disabled] = extract_values_from_collection(collection, value_method, disabled)
  options_for_select(options, select_deselect)
end
select(object, method, choices, options = {}, html_options = {})

Create a select tag and a series of contained option tags for the provided object and method. The option currently held by the object will be selected, provided that the object is available. See #options_for_select for the required format of the choices parameter.

Example with @post.person_id => 1:

select("post", "person_id", Person.all.collect {|p| [ p.name, p.id ] }, { :include_blank => true })

could become:

<select name="post[person_id]">
  <option value=""></option>
  <option value="1" selected="selected">David</option>
  <option value="2">Sam</option>
  <option value="3">Tobias</option>
</select>

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

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

# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 127
def select(object, method, choices, options = {}, html_options = {})
  InstanceTag.new(object, method, self, options.delete(:object)).to_select_tag(choices, options, html_options)
end
time_zone_options_for_select(selected = nil, priority_zones = nil, model = ::ActiveSupport::TimeZone)

Returns a string of option tags for pretty much any time zone in the world. Supply a TimeZone name as selectedto have it marked as the selected option tag. You can also supply an array of TimeZone objects as priority_zones, so that they will be listed above the rest of the (long) list. (You can use TimeZone.us_zones as a convenience for obtaining a list of the US time zones, or a Regexp to select the zones of your choice)

The selectedparameter must be either nil, or a string that names a TimeZone.

By default, modelis the TimeZone constant (which can be obtained in Active Record as a value object). The only requirement is that the modelparameter be an object that responds to all, and returns an array of objects that represent time zones.

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

# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 467
def time_zone_options_for_select(selected = nil, priority_zones = nil, model = ::ActiveSupport::TimeZone)
  zone_options = ""
  zones = model.all
  convert_zones = lambda { |list| list.map { |z| [ z.to_s, z.name ] } }
  if priority_zones
          if priority_zones.is_a?(Regexp)
      priority_zones = model.all.find_all {|z| z =~ priority_zones}
          end
    zone_options += options_for_select(convert_zones[priority_zones], selected)
    zone_options += "<option value=\"\" disabled=\"disabled\">-------------</option>\n"
    zones = zones.reject { |z| priority_zones.include?( z ) }
  end
  zone_options += options_for_select(convert_zones[zones], selected)
  zone_options.html_safe
end
time_zone_select(object, method, priority_zones = nil, options = {}, html_options = {})

Return select and option tags for the given object and method, using time_zone_options_for_select to generate the list of option tags.

In addition to the :include_blankoption documented above, this method also supports a :modeloption, which defaults to TimeZone. This may be used by users to specify a different time zone model object. (See time_zone_options_for_selectfor more information.)

You can also supply an array of TimeZone objects as priority_zones, so that they will be listed above the rest of the (long) list. (You can use TimeZone.us_zones as a convenience for obtaining a list of the US time zones, or a Regexp to select the zones of your choice)

Finally, this method supports a :defaultoption, which selects a default TimeZone if the object's time zone is nil.

Examples:

time_zone_select( "user", "time_zone", nil, :include_blank => true)
time_zone_select( "user", "time_zone", nil, :default => "Pacific Time (US & Canada)" )
time_zone_select( "user", 'time_zone', TimeZone.us_zones, :default => "Pacific Time (US & Canada)")
time_zone_select( "user", 'time_zone', [ TimeZone['Alaska'], TimeZone['Hawaii'] ])
time_zone_select( "user", 'time_zone', /Australia/)
time_zone_select( "user", "time_zone", TZInfo::Timezone.all.sort, :model => TZInfo::Timezone)
# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 249
def time_zone_select(object, method, priority_zones = nil, options = {}, html_options = {})
  InstanceTag.new(object, method, self,  options.delete(:object)).to_time_zone_select_tag(priority_zones, options, html_options)
end