Returns <select> and <option> tags for the collection of existing return values of method for object’s class. The value returned from calling method on the instance object will be selected. If calling method returns nil, no selection is made without including :prompt or :include_blank in the options hash.

The :value_method and :text_method parameters are methods to be called on each member of collection. The return values are used as the value attribute 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.find(:all), :id, :name_with_initial, {:prompt => true})

If @post.author_id is 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>

[Source]

# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 117
      def collection_select(object, method, collection, value_method, text_method, options = {}, html_options = {})
        InstanceTag.new(object, method, self, nil, options.delete(:object)).to_collection_select_tag(collection, value_method, text_method, options, html_options)
      end

Returns a string of option tags for pretty much any country in the world. Supply a country name as selected to have it marked as the selected option tag. You can also supply an array of countries as priority_countries, so that they will be listed above the rest of the (long) list.

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

[Source]

# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 247
      def country_options_for_select(selected = nil, priority_countries = nil)
        country_options = ""

        if priority_countries
          country_options += options_for_select(priority_countries, selected)
          country_options += "<option value=\"\">-------------</option>\n"
        end

        if priority_countries && priority_countries.include?(selected)
          country_options += options_for_select(COUNTRIES - priority_countries, selected)
        else
          country_options += options_for_select(COUNTRIES, selected)
        end

        return country_options
      end

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

[Source]

# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 122
      def country_select(object, method, priority_countries = nil, options = {}, html_options = {})
        InstanceTag.new(object, method, self, nil, options.delete(:object)).to_country_select_tag(priority_countries, options, html_options)
      end

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:

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.

[Source]

# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 233
      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

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 selected is specified, the matching "last" or element will get the selected option-tag. Selected may 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</option>

  options_for_select([ "VISA", "MasterCard" ], "MasterCard")
    <option>VISA</option>\n<option selected="selected">MasterCard</option>

  options_for_select({ "Basic" => "$20", "Plus" => "$40" }, "$40")
    <option value="$20">Basic</option>\n<option value="$40" selected="selected">Plus</option>

  options_for_select([ "VISA", "MasterCard", "Discover" ], ["VISA", "Discover"])
    <option selected="selected">VISA</option>\n<option>MasterCard</option>\n<option selected="selected">Discover</option>

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

[Source]

# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 158
      def options_for_select(container, selected = nil)
        container = container.to_a if Hash === container

        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)
          options << %(<option value="#{html_escape(value.to_s)}"#{selected_attribute}>#{html_escape(text.to_s)}</option>)
        end

        options_for_select.join("\n")
      end

Returns a string of option tags that have been compiled by iterating over the collection and assigning the the result of a call to the value_method as the option value and the text_method as the option text. If selected is specified, the element returning a match on value_method will get the selected option tag.

Example (call, result). Imagine a loop iterating over each person in @project.people to generate an input tag:

  options_from_collection_for_select(@project.people, "id", "name")
    <option value="#{person.id}">#{person.name}</option>

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

[Source]

# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 179
      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
        options_for_select(options, selected)
      end

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.find(: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_id is the selected option. Specify :selected => value to use a different selection or :selected => nil to leave all options unselected.

[Source]

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

Returns a string of option tags for pretty much any time zone in the world. Supply a TimeZone name as selected to 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.)

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

By default, model is the TimeZone constant (which can be obtained in ActiveRecord as a value object). The only requirement is that the model parameter 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.

[Source]

# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 281
      def time_zone_options_for_select(selected = nil, priority_zones = nil, model = TimeZone)
        zone_options = ""

        zones = model.all
        convert_zones = lambda { |list| list.map { |z| [ z.to_s, z.name ] } }

        if priority_zones
          zone_options += options_for_select(convert_zones[priority_zones], selected)
          zone_options += "<option value=\"\">-------------</option>\n"

          zones = zones.reject { |z| priority_zones.include?( z ) }
        end

        zone_options += options_for_select(convert_zones[zones], selected)
        zone_options
      end

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_blank option documented above, this method also supports a :model option, which defaults to TimeZone. This may be used by users to specify a different time zone model object. (See time_zone_options_for_select for more information.)

[Source]

# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 134
      def time_zone_select(object, method, priority_zones = nil, options = {}, html_options = {})
        InstanceTag.new(object, method, self, nil, options.delete(:object)).to_time_zone_select_tag(priority_zones, options, html_options)
      end

[Source]

# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 299
        def option_text_and_value(option)
          # Options are [text, value] pairs or strings used for both.
          if !option.is_a?(String) and option.respond_to?(:first) and option.respond_to?(:last)
            [option.first, option.last]
          else
            [option, option]
          end
        end

[Source]

# File actionpack/lib/action_view/helpers/form_options_helper.rb, line 308
        def option_value_selected?(value, selected)
          if selected.respond_to?(:include?) && !selected.is_a?(String)
            selected.include? value
          else
            value == selected
          end
        end