2004-11-23 20:04:44 -05:00
require 'cgi'
require 'erb'
2007-01-28 02:16:55 -05:00
require 'action_view/helpers/form_helper'
2010-10-18 11:58:57 -04:00
require 'active_support/core_ext/string/output_safety'
2013-01-31 09:59:18 -05:00
require 'active_support/core_ext/array/extract_options'
2012-12-13 12:48:55 -05:00
require 'active_support/core_ext/array/wrap'
2004-11-23 20:04:44 -05:00
module ActionView
2010-06-16 14:17:49 -04:00
# = Action View Form Option Helpers
2004-11-23 20:04:44 -05:00
module Helpers
2005-01-15 13:57:17 -05:00
# Provides a number of methods for turning different kinds of containers into a set of option tags.
2012-12-01 15:19:34 -05:00
#
2009-02-13 19:47:22 -05:00
# The <tt>collection_select</tt>, <tt>select</tt> and <tt>time_zone_select</tt> methods take an <tt>options</tt> parameter, a hash:
2005-02-17 14:38:02 -05:00
#
2007-05-18 01:29:22 -04:00
# * <tt>:include_blank</tt> - 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.
#
2012-10-29 07:10:53 -04:00
# select("post", "category", Post::CATEGORIES, {include_blank: true})
2005-02-17 14:38:02 -05:00
#
2005-04-19 06:59:55 -04:00
# could become:
2005-02-17 14:38:02 -05:00
#
# <select name="post[category]">
# <option></option>
# <option>joke</option>
# <option>poem</option>
# </select>
2005-04-19 06:59:55 -04:00
#
2012-12-01 15:19:34 -05:00
# Another common case is a select tag for a <tt>belongs_to</tt>-associated object.
2007-05-18 01:29:22 -04:00
#
# Example with @post.person_id => 2:
#
2012-10-29 07:10:53 -04:00
# select("post", "person_id", Person.all.collect {|p| [ p.name, p.id ] }, {include_blank: 'None'})
2007-05-18 01:29:22 -04:00
#
# 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>
#
2005-07-03 08:23:16 -04:00
# * <tt>:prompt</tt> - 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.
#
2012-10-29 07:10:53 -04:00
# select("post", "person_id", Person.all.collect {|p| [ p.name, p.id ] }, {prompt: 'Select Person'})
2005-04-19 06:59:55 -04:00
#
# could become:
#
# <select name="post[person_id]">
2007-05-18 01:29:22 -04:00
# <option value="">Select Person</option>
2005-04-19 06:59:55 -04:00
# <option value="1">David</option>
# <option value="2">Sam</option>
# <option value="3">Tobias</option>
# </select>
2010-08-14 01:13:00 -04:00
#
# Like the other form helpers, +select+ can accept an <tt>:index</tt> option to manually set the ID used in the resulting output. Unlike other helpers, +select+ expects this
2008-03-19 22:15:29 -04:00
# option to be in the +html_options+ parameter.
2010-08-14 01:13:00 -04:00
#
2012-10-29 07:10:53 -04:00
# select("album[]", "genre", %w[rap rock country], {}, { index: nil })
2010-08-14 01:13:00 -04:00
#
2008-03-19 22:15:29 -04:00
# becomes:
2010-08-14 01:13:00 -04:00
#
2008-03-19 22:15:29 -04:00
# <select name="album[][genre]" id="album__genre">
# <option value="rap">rap</option>
# <option value="rock">rock</option>
# <option value="country">country</option>
# </select>
2009-02-13 19:47:22 -05:00
#
# * <tt>:disabled</tt> - can be a single value or an array of values that will be disabled options in the final output.
#
2012-10-29 07:10:53 -04:00
# select("post", "category", Post::CATEGORIES, {disabled: 'restricted'})
2009-02-13 19:47:22 -05:00
#
# could become:
#
# <select name="post[category]">
# <option></option>
# <option>joke</option>
# <option>poem</option>
# <option disabled="disabled">restricted</option>
# </select>
#
# When used with the <tt>collection_select</tt> helper, <tt>:disabled</tt> can also be a Proc that identifies those options that should be disabled.
#
2012-10-29 07:10:53 -04:00
# collection_select(:post, :category_id, Category.all, :id, :name, {disabled: lambda{|category| category.archived? }})
2009-02-13 19:47:22 -05:00
#
# If the categories "2008 stuff" and "Christmas" return true when the method <tt>archived?</tt> 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>
#
2004-11-23 20:04:44 -05:00
module FormOptionsHelper
2010-03-10 02:41:39 -05:00
# ERB::Util can mask some helpers like textilize. Make sure to include them.
include TextHelper
2004-12-15 06:49:23 -05:00
# Create a select tag and a series of contained option tags for the provided object and method.
2005-02-07 09:15:53 -05:00
# The option currently held by the object will be selected, provided that the object is available.
2011-06-14 15:45:22 -04:00
#
2013-08-07 00:09:50 -04:00
# There are two possible formats for the +choices+ parameter, corresponding to other helpers' output:
#
# * A flat collection (see +options_for_select+).
#
# * A nested collection (see +grouped_options_for_select+).
#
# For example:
2005-04-19 06:59:55 -04:00
#
2012-10-29 07:10:53 -04:00
# select("post", "person_id", Person.all.collect {|p| [ p.name, p.id ] }, { include_blank: true })
2005-04-19 06:59:55 -04:00
#
2013-08-07 00:09:50 -04:00
# would become:
2005-04-19 06:59:55 -04:00
#
2005-11-23 16:59:20 -05:00
# <select name="post[person_id]">
2007-05-18 01:29:22 -04:00
# <option value=""></option>
2005-04-19 06:59:55 -04:00
# <option value="1" selected="selected">David</option>
# <option value="2">Sam</option>
# <option value="3">Tobias</option>
# </select>
2005-03-06 06:50:41 -05:00
#
2013-08-07 00:09:50 -04:00
# assuming the associated person has ID 1.
#
2004-12-15 06:49:23 -05:00
# 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.
2005-11-23 16:59:20 -05:00
#
2012-10-29 07:10:53 -04:00
# By default, <tt>post.person_id</tt> is the selected option. Specify <tt>selected: value</tt> to use a different selection
# or <tt>selected: nil</tt> to leave all options unselected. Similarly, you can specify values to be disabled in the option
2009-02-13 19:47:22 -05:00
# tags by specifying the <tt>:disabled</tt> option. This can either be a single value or an array of values to be disabled.
2011-06-08 05:59:54 -04:00
#
2013-09-23 10:19:35 -04:00
# A block can be passed to +select+ to customize how the options tags will be rendered. This
# is useful when the options tag has complex attributes.
#
# select(report, "campaign_ids") do
# available_campaigns.each do |c|
# content_tag(:option, c.name, value: c.id, data: { tags: c.tags.to_json })
# end
# end
#
2011-06-08 05:59:54 -04:00
# ==== Gotcha
#
2012-01-05 15:59:25 -05:00
# The HTML specification says when +multiple+ parameter passed to select and all options got deselected
2011-06-08 05:59:54 -04:00
# web browsers do not send any value to server. Unfortunately this introduces a gotcha:
# if an +User+ model has many +roles+ and have +role_ids+ accessor, and in the form that edits roles of the user
# the user deselects all roles from +role_ids+ multiple select box, no +role_ids+ parameter is sent. So,
# any mass-assignment idiom like
#
2013-01-02 16:16:24 -05:00
# @user.update(params[:user])
2011-06-08 05:59:54 -04:00
#
# wouldn't update roles.
#
# To prevent this the helper generates an auxiliary hidden field before
# every multiple select. The hidden field has the same name as multiple select and blank value.
#
# This way, the client either sends only the hidden field (representing
# the deselected multiple select box), 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.
#
2012-12-01 15:19:34 -05:00
# In case if you don't want the helper to generate this hidden field you can specify
# <tt>include_hidden: false</tt> option.
2012-03-13 12:59:04 -04:00
#
2013-09-23 07:25:42 -04:00
def select ( object , method , choices = nil , options = { } , html_options = { } , & block )
Tags :: Select . new ( object , method , self , choices , options , html_options , & block ) . render
2004-11-23 20:04:44 -05:00
end
2005-03-06 06:50:41 -05:00
2007-08-04 21:13:44 -04:00
# Returns <tt><select></tt> and <tt><option></tt> 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 <tt>:prompt</tt>
# or <tt>:include_blank</tt> in the +options+ hash.
#
# The <tt>:value_method</tt> and <tt>:text_method</tt> parameters are methods to be called on each member
# of +collection+. The return values are used as the +value+ attribute and contents of each
2012-02-01 16:16:58 -05:00
# <tt><option></tt> tag, respectively. They can also be any object that responds to +call+, such
# as a +proc+, that will be called for each member of the +collection+ to
# retrieve the value/text.
2010-08-14 01:13:00 -04:00
#
2007-08-04 21:13:44 -04:00
# Example object structure for use with this method:
2012-12-01 15:19:34 -05:00
#
2007-08-04 21:13:44 -04:00
# class Post < ActiveRecord::Base
# belongs_to :author
# end
2012-12-01 15:19:34 -05:00
#
2007-08-04 21:13:44 -04:00
# class Author < ActiveRecord::Base
# has_many :posts
# def name_with_initial
# "#{first_name.first}. #{last_name}"
# end
# end
#
2008-05-25 07:29:00 -04:00
# Sample usage (selecting the associated Author for an instance of Post, <tt>@post</tt>):
2012-12-01 15:19:34 -05:00
#
2012-10-29 07:10:53 -04:00
# collection_select(:post, :author_id, Author.all, :id, :name_with_initial, prompt: true)
2007-08-04 21:13:44 -04:00
#
# If <tt>@post.author_id</tt> is already <tt>1</tt>, 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>
2004-11-23 20:04:44 -05:00
def collection_select ( object , method , collection , value_method , text_method , options = { } , html_options = { } )
2012-01-17 13:07:05 -05:00
Tags :: CollectionSelect . new ( object , method , self , collection , value_method , text_method , options , html_options ) . render
2004-11-23 20:04:44 -05:00
end
2005-03-06 06:50:41 -05:00
2009-08-09 22:18:01 -04:00
# Returns <tt><select></tt>, <tt><optgroup></tt> and <tt><option></tt> 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 <tt>:prompt</tt>
# or <tt>:include_blank</tt> in the +options+ hash.
#
# Parameters:
# * +object+ - The instance of the class to be used for the select tag
# * +method+ - The attribute of +object+ corresponding to the select tag
# * +collection+ - An array of objects representing the <tt><optgroup></tt> tags.
# * +group_method+ - The name of a method which, when called on a member of +collection+, returns an
# array of child objects representing the <tt><option></tt> 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 +label+ attribute for its <tt><optgroup></tt> 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 +value+ attribute for its <tt><option></tt> 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 <tt><option></tt> tag.
#
# Example object structure for use with this method:
2012-12-01 15:19:34 -05:00
#
2009-08-09 22:18:01 -04:00
# class Continent < ActiveRecord::Base
# has_many :countries
# # attribs: id, name
# end
2012-12-01 15:19:34 -05:00
#
2009-08-09 22:18:01 -04:00
# class Country < ActiveRecord::Base
# belongs_to :continent
# # attribs: id, name, continent_id
# end
2012-12-01 15:19:34 -05:00
#
2009-08-09 22:18:01 -04:00
# class City < ActiveRecord::Base
# belongs_to :country
# # attribs: id, name, country_id
# end
#
# Sample usage:
2012-12-01 15:19:34 -05:00
#
2009-08-09 22:18:01 -04:00
# grouped_collection_select(:city, :country_id, @continents, :countries, :name, :id, :name)
#
# Possible output:
2012-12-01 15:19:34 -05:00
#
2009-08-09 22:18:01 -04:00
# <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>
#
def grouped_collection_select ( object , method , collection , group_method , group_label_method , option_key_method , option_value_method , options = { } , html_options = { } )
2012-01-17 13:07:05 -05:00
Tags :: GroupedCollectionSelect . new ( object , method , self , collection , group_method , group_label_method , option_key_method , option_value_method , options , html_options ) . render
2009-08-09 22:18:01 -04:00
end
2005-02-23 07:54:58 -05:00
# 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 <tt>:include_blank</tt> option documented above,
# this method also supports a <tt>:model</tt> option, which defaults
2009-07-25 11:03:58 -04:00
# to ActiveSupport::TimeZone. This may be used by users to specify a
# different time zone model object. (See +time_zone_options_for_select+
# for more information.)
2008-05-18 11:25:29 -04:00
#
2009-07-25 11:03:58 -04:00
# You can also supply an array of ActiveSupport::TimeZone objects
2008-05-18 11:25:29 -04:00
# as +priority_zones+, so that they will be listed above the rest of the
2009-07-25 11:03:58 -04:00
# (long) list. (You can use ActiveSupport::TimeZone.us_zones as a convenience
# for obtaining a list of the US time zones, or a Regexp to select the zones
2008-06-28 22:27:32 -04:00
# of your choice)
2008-05-18 11:25:29 -04:00
#
2007-12-21 17:18:07 -05:00
# Finally, this method supports a <tt>:default</tt> option, which selects
2009-07-25 11:03:58 -04:00
# a default ActiveSupport::TimeZone if the object's time zone is +nil+.
2007-12-21 17:18:07 -05:00
#
2012-10-29 07:10:53 -04:00
# time_zone_select( "user", "time_zone", nil, include_blank: true)
2007-12-21 17:18:07 -05:00
#
2012-10-29 07:10:53 -04:00
# time_zone_select( "user", "time_zone", nil, default: "Pacific Time (US & Canada)" )
2007-12-21 17:18:07 -05:00
#
2012-10-29 07:10:53 -04:00
# time_zone_select( "user", 'time_zone', ActiveSupport::TimeZone.us_zones, default: "Pacific Time (US & Canada)")
2007-12-21 17:18:07 -05:00
#
2009-07-25 11:03:58 -04:00
# time_zone_select( "user", 'time_zone', [ ActiveSupport::TimeZone['Alaska'], ActiveSupport::TimeZone['Hawaii'] ])
2008-05-18 11:25:29 -04:00
#
2008-06-28 22:27:32 -04:00
# time_zone_select( "user", 'time_zone', /Australia/)
#
2012-10-29 07:10:53 -04:00
# time_zone_select( "user", "time_zone", ActiveSupport::TimeZone.all.sort, model: ActiveSupport::TimeZone)
2005-02-23 07:54:58 -05:00
def time_zone_select ( object , method , priority_zones = nil , options = { } , html_options = { } )
2012-01-17 13:07:05 -05:00
Tags :: TimeZoneSelect . new ( object , method , self , priority_zones , options , html_options ) . render
2005-02-23 07:54:58 -05:00
end
2005-03-06 06:50:41 -05:00
# Accepts a container (hash, array, enumerable, your type) and returns a string of option tags. Given a container
2004-11-23 20:04:44 -05:00
# 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
2011-05-23 19:22:33 -04:00
# become lasts. If +selected+ is specified, the matching "last" or element will get the selected option-tag. +selected+
2005-03-06 06:50:41 -05:00
# may also be an array of values to be selected when using a multiple select.
2004-11-23 20:04:44 -05:00
#
# options_for_select([["Dollar", "$"], ["Kroner", "DKK"]])
2012-12-01 15:19:34 -05:00
# # => <option value="$">Dollar</option>
# # => <option value="DKK">Kroner</option>
2004-11-23 20:04:44 -05:00
#
2005-02-07 09:15:53 -05:00
# options_for_select([ "VISA", "MasterCard" ], "MasterCard")
2012-12-01 15:19:34 -05:00
# # => <option>VISA</option>
# # => <option selected="selected">MasterCard</option>
2004-11-23 20:04:44 -05:00
#
# options_for_select({ "Basic" => "$20", "Plus" => "$40" }, "$40")
2012-12-01 15:19:34 -05:00
# # => <option value="$20">Basic</option>
# # => <option value="$40" selected="selected">Plus</option>
2004-11-23 20:04:44 -05:00
#
2005-02-07 09:15:53 -05:00
# options_for_select([ "VISA", "MasterCard", "Discover" ], ["VISA", "Discover"])
2012-12-01 15:19:34 -05:00
# # => <option selected="selected">VISA</option>
# # => <option>MasterCard</option>
# # => <option selected="selected">Discover</option>
2005-02-19 07:22:13 -05:00
#
2010-05-15 05:53:59 -04:00
# You can optionally provide html attributes as the last element of the array.
#
2012-10-29 07:10:53 -04:00
# options_for_select([ "Denmark", ["USA", {class: 'bold'}], "Sweden" ], ["USA", "Sweden"])
2012-12-01 15:19:34 -05:00
# # => <option value="Denmark">Denmark</option>
# # => <option value="USA" class="bold" selected="selected">USA</option>
# # => <option value="Sweden" selected="selected">Sweden</option>
2010-05-15 05:53:59 -04:00
#
2012-10-29 07:10:53 -04:00
# options_for_select([["Dollar", "$", {class: "bold"}], ["Kroner", "DKK", {onclick: "alert('HI');"}]])
2012-12-01 15:19:34 -05:00
# # => <option value="$" class="bold">Dollar</option>
# # => <option value="DKK" onclick="alert('HI');">Kroner</option>
2010-05-15 05:53:59 -04:00
#
2009-02-13 19:47:22 -05:00
# If you wish to specify disabled option tags, set +selected+ to be a hash, with <tt>:disabled</tt> being either a value
# or array of values to be disabled. In this case, you can use <tt>:selected</tt> to specify selected option tags.
#
2012-10-29 07:10:53 -04:00
# options_for_select(["Free", "Basic", "Advanced", "Super Platinum"], disabled: "Super Platinum")
2012-12-01 15:19:34 -05:00
# # => <option value="Free">Free</option>
# # => <option value="Basic">Basic</option>
# # => <option value="Advanced">Advanced</option>
# # => <option value="Super Platinum" disabled="disabled">Super Platinum</option>
2009-02-13 19:47:22 -05:00
#
2012-10-29 07:10:53 -04:00
# options_for_select(["Free", "Basic", "Advanced", "Super Platinum"], disabled: ["Advanced", "Super Platinum"])
2012-12-01 15:19:34 -05:00
# # => <option value="Free">Free</option>
# # => <option value="Basic">Basic</option>
# # => <option value="Advanced" disabled="disabled">Advanced</option>
# # => <option value="Super Platinum" disabled="disabled">Super Platinum</option>
2009-02-13 19:47:22 -05:00
#
2012-10-29 07:10:53 -04:00
# options_for_select(["Free", "Basic", "Advanced", "Super Platinum"], selected: "Free", disabled: "Super Platinum")
2012-12-01 15:19:34 -05:00
# # => <option value="Free" selected="selected">Free</option>
# # => <option value="Basic">Basic</option>
# # => <option value="Advanced">Advanced</option>
# # => <option value="Super Platinum" disabled="disabled">Super Platinum</option>
2009-02-13 19:47:22 -05:00
#
2005-02-19 07:22:13 -05:00
# NOTE: Only the option tags are returned, you have to wrap this call in a regular HTML select tag.
2004-11-23 20:04:44 -05:00
def options_for_select ( container , selected = nil )
2009-04-01 06:44:56 -04:00
return container if String === container
2012-01-05 15:18:54 -05:00
selected , disabled = extract_selected_and_disabled ( selected ) . map do | r |
Array ( r ) . map { | item | item . to_s }
2010-08-14 10:55:51 -04:00
end
2005-03-06 06:50:41 -05:00
2010-08-14 10:55:51 -04:00
container . map do | element |
2010-05-15 05:53:59 -04:00
html_attributes = option_html_attributes ( element )
2011-07-27 10:12:22 -04:00
text , value = option_text_and_value ( element ) . map { | item | item . to_s }
2012-02-20 14:55:46 -05:00
2013-07-22 13:33:38 -04:00
html_attributes [ :selected ] = option_value_selected? ( value , selected )
2013-11-25 06:32:32 -05:00
html_attributes [ :disabled ] = disabled && option_value_selected? ( value , disabled )
2012-02-20 14:55:46 -05:00
html_attributes [ :value ] = value
2012-07-10 15:03:37 -04:00
content_tag_string ( :option , text , html_attributes )
2010-08-14 10:55:51 -04:00
end . join ( " \n " ) . html_safe
2004-11-23 20:04:44 -05:00
end
2012-01-25 17:12:01 -05:00
# Returns a string of option tags that have been compiled by iterating over the +collection+ and assigning
2004-11-23 20:04:44 -05:00
# the result of a call to the +value_method+ as the option value and the +text_method+ as the option text.
2012-12-01 15:19:34 -05:00
#
2008-12-19 09:27:43 -05:00
# options_from_collection_for_select(@people, 'id', 'name')
2012-12-01 15:19:34 -05:00
# # => <option value="#{person.id}">#{person.name}</option>
2004-11-23 20:04:44 -05:00
#
2008-12-19 09:27:43 -05:00
# This is more often than not used inside a #select_tag like this example:
2012-12-01 15:19:34 -05:00
#
2008-12-19 09:27:43 -05:00
# select_tag 'person', options_from_collection_for_select(@people, 'id', 'name')
2005-02-19 07:22:13 -05:00
#
2009-02-13 19:47:22 -05:00
# If +selected+ is specified as a value or array of values, the element(s) returning a match on +value_method+
# will be selected option tag(s).
#
# If +selected+ is specified as a Proc, those members of the collection that return true for the anonymous
# function are the selected values.
#
# +selected+ can also be a hash, specifying both <tt>:selected</tt> and/or <tt>:disabled</tt> values as required.
#
# Be sure to specify the same class as the +value_method+ when specifying selected or disabled options.
2008-12-19 09:27:43 -05:00
# 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.
2007-03-11 09:14:53 -04:00
def options_from_collection_for_select ( collection , value_method , text_method , selected = nil )
options = collection . map do | element |
2013-04-11 07:15:33 -04:00
[ value_for_collection ( element , text_method ) , value_for_collection ( element , value_method ) , option_html_attributes ( element ) ]
2007-03-11 09:14:53 -04:00
end
2009-02-13 19:37:24 -05:00
selected , disabled = extract_selected_and_disabled ( selected )
2012-01-31 15:58:31 -05:00
select_deselect = {
2013-07-22 13:27:19 -04:00
selected : extract_values_from_collection ( collection , value_method , selected ) ,
disabled : extract_values_from_collection ( collection , value_method , disabled )
2012-01-31 15:58:31 -05:00
}
2009-02-13 19:37:24 -05:00
options_for_select ( options , select_deselect )
2004-11-23 20:04:44 -05:00
end
2008-05-25 07:29:00 -04:00
# Returns a string of <tt><option></tt> tags, like <tt>options_from_collection_for_select</tt>, but
2007-08-04 21:13:44 -04:00
# groups them by <tt><optgroup></tt> tags based on the object relationships of the arguments.
#
# Parameters:
2008-05-25 07:29:00 -04:00
# * +collection+ - An array of objects representing the <tt><optgroup></tt> tags.
# * +group_method+ - The name of a method which, when called on a member of +collection+, returns an
# array of child objects representing the <tt><option></tt> 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 +label+ attribute for its <tt><optgroup></tt> 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 +value+ attribute for its <tt><option></tt> 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 <tt><option></tt> tag.
# * +selected_key+ - A value equal to the +value+ attribute for one of the <tt><option></tt> tags,
# which will have the +selected+ attribute set. Corresponds to the return value of one of the calls
2009-02-13 19:47:22 -05:00
# to +option_key_method+. If +nil+, no selection is made. Can also be a hash if disabled values are
# to be specified.
2007-08-04 21:13:44 -04:00
#
# Example object structure for use with this method:
2012-12-01 15:19:34 -05:00
#
2007-08-04 21:13:44 -04:00
# class Continent < ActiveRecord::Base
# has_many :countries
# # attribs: id, name
# end
2012-12-01 15:19:34 -05:00
#
2007-08-04 21:13:44 -04:00
# 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>
#
# <b>Note:</b> Only the <tt><optgroup></tt> and <tt><option></tt> tags are returned, so you still have to
# wrap the output in an appropriate <tt><select></tt> tag.
def option_groups_from_collection_for_select ( collection , group_method , group_label_method , option_key_method , option_value_method , selected_key = nil )
2010-09-28 14:22:16 -04:00
collection . map do | group |
2012-01-31 15:38:46 -05:00
option_tags = options_from_collection_for_select (
group . send ( group_method ) , option_key_method , option_value_method , selected_key )
2013-07-22 13:27:19 -04:00
content_tag ( :optgroup , option_tags , label : group . send ( group_label_method ) )
2010-09-28 14:22:16 -04:00
end . join . html_safe
2005-03-06 06:50:41 -05:00
end
2009-01-29 12:59:44 -05:00
# Returns a string of <tt><option></tt> tags, like <tt>options_for_select</tt>, but
# wraps them with <tt><optgroup></tt> tags.
#
# Parameters:
2011-05-23 19:22:33 -04:00
# * +grouped_options+ - Accepts a nested array or hash of strings. The first value serves as the
2009-01-29 12:59:44 -05:00
# <tt><optgroup></tt> label while the second value must be an array of options. The second value can be a
# nested array of text-value pairs. See <tt>options_for_select</tt> for more info.
# Ex. ["North America",[["United States","US"],["Canada","CA"]]]
# * +selected_key+ - A value equal to the +value+ attribute for one of the <tt><option></tt> tags,
# which will have the +selected+ attribute set. Note: It is possible for this value to match multiple options
2011-05-23 19:22:33 -04:00
# as you might have the same option in multiple groups. Each will then get <tt>selected="selected"</tt>.
2012-05-16 19:51:33 -04:00
#
# Options:
# * <tt>:prompt</tt> - set to true or a prompt string. When the select element doesn't have a value yet, this
2010-06-11 06:15:34 -04:00
# prepends an option with a generic prompt - "Please select" - or the given prompt string.
2012-05-16 20:04:46 -04:00
# * <tt>:divider</tt> - the divider for the options groups.
2009-01-29 12:59:44 -05:00
#
# grouped_options = [
# ['North America',
# [['United States','US'],'Canada']],
# ['Europe',
# ['Denmark','Germany','France']]
# ]
# grouped_options_for_select(grouped_options)
#
# grouped_options = {
2012-05-19 08:49:01 -04:00
# 'North America' => [['United States','US'], 'Canada'],
# 'Europe' => ['Denmark','Germany','France']
2009-01-29 12:59:44 -05:00
# }
# grouped_options_for_select(grouped_options)
#
# Possible output:
2012-11-27 11:00:31 -05:00
# <optgroup label="North America">
# <option value="US">United States</option>
# <option value="Canada">Canada</option>
# </optgroup>
2009-01-29 12:59:44 -05:00
# <optgroup label="Europe">
# <option value="Denmark">Denmark</option>
# <option value="Germany">Germany</option>
# <option value="France">France</option>
# </optgroup>
#
2012-05-16 20:04:46 -04:00
# grouped_options = [
2012-05-19 08:49:01 -04:00
# [['United States','US'], 'Canada'],
# ['Denmark','Germany','France']
2012-05-16 20:04:46 -04:00
# ]
2012-05-19 08:49:01 -04:00
# grouped_options_for_select(grouped_options, nil, divider: '---------')
2012-05-16 20:04:46 -04:00
#
# Possible output:
# <optgroup label="---------">
2012-08-15 19:52:52 -04:00
# <option value="US">United States</option>
# <option value="Canada">Canada</option>
# </optgroup>
# <optgroup label="---------">
2012-05-16 20:04:46 -04:00
# <option value="Denmark">Denmark</option>
# <option value="Germany">Germany</option>
# <option value="France">France</option>
# </optgroup>
#
2009-01-29 12:59:44 -05:00
# <b>Note:</b> Only the <tt><optgroup></tt> and <tt><option></tt> tags are returned, so you still have to
# wrap the output in an appropriate <tt><select></tt> tag.
2012-05-19 08:49:01 -04:00
def grouped_options_for_select ( grouped_options , selected_key = nil , options = { } )
2013-06-27 13:50:58 -04:00
prompt = options [ :prompt ]
divider = options [ :divider ]
2012-05-15 13:45:12 -04:00
2012-02-20 14:51:05 -05:00
body = " " . html_safe
2012-05-16 19:52:27 -04:00
if prompt
2013-07-22 13:27:19 -04:00
body . safe_concat content_tag ( :option , prompt_text ( prompt ) , value : " " )
2012-05-16 19:52:27 -04:00
end
2009-01-29 12:59:44 -05:00
2012-05-15 13:45:12 -04:00
grouped_options . each do | container |
2013-07-20 08:36:27 -04:00
html_attributes = option_html_attributes ( container )
2012-05-15 13:45:12 -04:00
if divider
2012-05-19 08:49:01 -04:00
label = divider
2012-05-15 13:45:12 -04:00
else
label , container = container
end
2013-07-20 08:36:27 -04:00
2013-07-22 13:27:19 -04:00
html_attributes = { label : label } . merge! ( html_attributes )
2013-07-20 08:36:27 -04:00
body . safe_concat content_tag ( :optgroup , options_for_select ( container , selected_key ) , html_attributes )
2009-01-29 12:59:44 -05:00
end
2012-02-20 14:51:05 -05:00
body
2009-01-29 12:59:44 -05:00
end
2005-02-23 07:54:58 -05:00
# Returns a string of option tags for pretty much any time zone in the
2009-07-25 11:03:58 -04:00
# world. Supply a ActiveSupport::TimeZone name as +selected+ to have it
# marked as the selected option tag. You can also supply an array of
# ActiveSupport::TimeZone objects as +priority_zones+, so that they will
# be listed above the rest of the (long) list. (You can use
# ActiveSupport::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)
2005-02-23 07:54:58 -05:00
#
2005-02-23 18:55:59 -05:00
# The +selected+ parameter must be either +nil+, or a string that names
2009-07-25 11:03:58 -04:00
# a ActiveSupport::TimeZone.
2005-02-23 18:55:59 -05:00
#
2009-07-25 11:03:58 -04:00
# By default, +model+ is the ActiveSupport::TimeZone constant (which can
# be obtained in Active Record 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.
2005-02-23 07:54:58 -05:00
#
# NOTE: Only the option tags are returned, you have to wrap this call in
# a regular HTML select tag.
2008-06-11 00:13:27 -04:00
def time_zone_options_for_select ( selected = nil , priority_zones = nil , model = :: ActiveSupport :: TimeZone )
2012-02-21 11:46:49 -05:00
zone_options = " " . html_safe
2005-02-23 07:54:58 -05:00
2013-02-21 11:17:38 -05:00
zones = model . all
2005-02-23 18:55:59 -05:00
convert_zones = lambda { | list | list . map { | z | [ z . to_s , z . name ] } }
2005-02-23 07:54:58 -05:00
if priority_zones
2012-01-05 15:59:25 -05:00
if priority_zones . is_a? ( Regexp )
2013-03-27 17:03:49 -04:00
priority_zones = zones . select { | z | z =~ priority_zones }
2012-01-05 15:59:25 -05:00
end
2005-02-23 07:54:58 -05:00
2012-02-21 11:46:49 -05:00
zone_options . safe_concat options_for_select ( convert_zones [ priority_zones ] , selected )
2013-07-22 13:33:38 -04:00
zone_options . safe_concat content_tag ( :option , '-------------' , value : '' , disabled : true )
2012-02-21 11:46:49 -05:00
zone_options . safe_concat " \n "
2013-02-21 11:17:38 -05:00
zones = zones - priority_zones
2005-02-23 07:54:58 -05:00
end
2012-02-21 11:46:49 -05:00
zone_options . safe_concat options_for_select ( convert_zones [ zones ] , selected )
2005-02-23 07:54:58 -05:00
end
2004-11-23 20:04:44 -05:00
2012-02-01 16:16:58 -05:00
# Returns radio button 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.
#
# The <tt>:value_method</tt> and <tt>:text_method</tt> parameters are
# methods to be called on each member of +collection+. The return values
# are used as the +value+ attribute and contents of each radio button tag,
# respectively. They can also be any object that responds to +call+, such
# as a +proc+, that will be called for each member of the +collection+ to
# retrieve the value/text.
2012-02-01 14:28:50 -05:00
#
# 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, <tt>@post</tt>):
# collection_radio_buttons(:post, :author_id, Author.all, :id, :name_with_initial)
#
# If <tt>@post.author_id</tt> is already <tt>1</tt>, this would return:
# <input id="post_author_id_1" name="post[author_id]" type="radio" value="1" checked="checked" />
2012-02-01 17:12:52 -05:00
# <label for="post_author_id_1">D. Heinemeier Hansson</label>
2012-02-01 14:28:50 -05:00
# <input id="post_author_id_2" name="post[author_id]" type="radio" value="2" />
2012-02-01 17:12:52 -05:00
# <label for="post_author_id_2">D. Thomas</label>
2012-02-01 14:28:50 -05:00
# <input id="post_author_id_3" name="post[author_id]" type="radio" value="3" />
2012-02-01 17:12:52 -05:00
# <label for="post_author_id_3">M. Clark</label>
2012-02-01 16:16:58 -05:00
#
# It is also possible to customize the way the elements will be shown by
# giving a block to the method:
# collection_radio_buttons(:post, :author_id, Author.all, :id, :name_with_initial) do |b|
# b.label { b.radio_button }
# end
#
# The argument passed to the block is a special kind of builder for this
# collection, which has the ability to generate the label and radio button
# for the current item in the collection, with proper text and value.
# Using it, you can change the label and radio button display order or
# even use the label as wrapper, as in the example above.
#
# The builder methods <tt>label</tt> and <tt>radio_button</tt> also accept
# extra html options:
2012-02-01 17:12:52 -05:00
# collection_radio_buttons(:post, :author_id, Author.all, :id, :name_with_initial) do |b|
2012-10-29 07:10:53 -04:00
# b.label(class: "radio_button") { b.radio_button(class: "radio_button") }
2012-02-01 16:16:58 -05:00
# end
2012-02-01 16:46:48 -05:00
#
2012-02-26 16:59:56 -05:00
# There are also three special methods available: <tt>object</tt>, <tt>text</tt> and
# <tt>value</tt>, which are the current item being rendered, its text and value methods,
# respectively. You can use them like this:
2012-02-01 17:12:52 -05:00
# collection_radio_buttons(:post, :author_id, Author.all, :id, :name_with_initial) do |b|
2012-02-01 16:46:48 -05:00
# b.label(:"data-value" => b.value) { b.radio_button + b.text }
# end
2012-02-01 14:28:50 -05:00
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
2012-02-01 16:16:58 -05:00
# Returns check box 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.
#
# The <tt>:value_method</tt> and <tt>:text_method</tt> parameters are
# methods to be called on each member of +collection+. The return values
# are used as the +value+ attribute and contents of each check box tag,
# respectively. They can also be any object that responds to +call+, such
# as a +proc+, that will be called for each member of the +collection+ to
# retrieve the value/text.
2012-02-01 14:28:50 -05:00
#
# Example object structure for use with this method:
# class Post < ActiveRecord::Base
2013-06-25 18:35:03 -04:00
# has_and_belongs_to_many :authors
2012-02-01 14:28:50 -05:00
# end
# class Author < ActiveRecord::Base
2012-02-01 16:16:58 -05:00
# has_and_belongs_to_many :posts
2012-02-01 14:28:50 -05:00
# def name_with_initial
# "#{first_name.first}. #{last_name}"
# end
# end
#
# Sample usage (selecting the associated Author for an instance of Post, <tt>@post</tt>):
# collection_check_boxes(:post, :author_ids, Author.all, :id, :name_with_initial)
#
# If <tt>@post.author_ids</tt> is already <tt>[1]</tt>, this would return:
# <input id="post_author_ids_1" name="post[author_ids][]" type="checkbox" value="1" checked="checked" />
2012-02-01 17:12:52 -05:00
# <label for="post_author_ids_1">D. Heinemeier Hansson</label>
2012-02-01 16:16:58 -05:00
# <input id="post_author_ids_2" name="post[author_ids][]" type="checkbox" value="2" />
2012-02-01 17:12:52 -05:00
# <label for="post_author_ids_2">D. Thomas</label>
2012-02-01 14:28:50 -05:00
# <input id="post_author_ids_3" name="post[author_ids][]" type="checkbox" value="3" />
2012-02-01 17:12:52 -05:00
# <label for="post_author_ids_3">M. Clark</label>
2012-02-01 14:28:50 -05:00
# <input name="post[author_ids][]" type="hidden" value="" />
2012-02-01 16:16:58 -05:00
#
# It is also possible to customize the way the elements will be shown by
# giving a block to the method:
# collection_check_boxes(:post, :author_ids, Author.all, :id, :name_with_initial) do |b|
# b.label { b.check_box }
# end
#
# The argument passed to the block is a special kind of builder for this
# collection, which has the ability to generate the label and check box
# for the current item in the collection, with proper text and value.
# Using it, you can change the label and check box display order or even
# use the label as wrapper, as in the example above.
#
# The builder methods <tt>label</tt> and <tt>check_box</tt> also accept
# extra html options:
# collection_check_boxes(:post, :author_ids, Author.all, :id, :name_with_initial) do |b|
2012-10-29 07:10:53 -04:00
# b.label(class: "check_box") { b.check_box(class: "check_box") }
2012-02-01 16:16:58 -05:00
# end
2012-02-01 16:46:48 -05:00
#
2012-02-26 16:59:56 -05:00
# There are also three special methods available: <tt>object</tt>, <tt>text</tt> and
# <tt>value</tt>, which are the current item being rendered, its text and value methods,
# respectively. You can use them like this:
2012-02-01 16:46:48 -05:00
# collection_check_boxes(:post, :author_ids, Author.all, :id, :name_with_initial) do |b|
# b.label(:"data-value" => b.value) { b.check_box + b.text }
# end
2012-02-01 14:28:50 -05:00
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
2004-11-23 20:04:44 -05:00
private
2010-05-15 05:53:59 -04:00
def option_html_attributes ( element )
2012-08-11 13:04:21 -04:00
if Array === element
2012-08-11 13:13:54 -04:00
element . select { | e | Hash === e } . reduce ( { } , :merge! )
2012-08-11 13:04:21 -04:00
else
{ }
end
2010-05-15 05:53:59 -04:00
end
2007-03-11 09:14:53 -04:00
def option_text_and_value ( option )
# Options are [text, value] pairs or strings used for both.
2012-02-21 12:32:20 -05:00
if ! option . is_a? ( String ) && option . respond_to? ( :first ) && option . respond_to? ( :last )
option = option . reject { | e | Hash === e } if Array === option
2007-03-11 09:14:53 -04:00
[ option . first , option . last ]
else
[ option , option ]
end
end
def option_value_selected? ( value , selected )
2012-02-21 12:32:20 -05:00
Array ( selected ) . include? value
2007-03-11 09:14:53 -04:00
end
2009-02-13 19:37:24 -05:00
def extract_selected_and_disabled ( selected )
2010-08-14 10:55:51 -04:00
if selected . is_a? ( Proc )
2012-01-31 15:58:31 -05:00
[ selected , nil ]
2009-02-13 19:37:24 -05:00
else
2010-08-14 10:55:51 -04:00
selected = Array . wrap ( selected )
2012-02-01 14:43:44 -05:00
options = selected . extract_options! . symbolize_keys
2012-01-31 15:58:31 -05:00
selected_items = options . fetch ( :selected , selected )
[ selected_items , options [ :disabled ] ]
2009-02-13 19:37:24 -05:00
end
end
def extract_values_from_collection ( collection , value_method , selected )
if selected . is_a? ( Proc )
collection . map do | element |
element . send ( value_method ) if selected . call ( element )
end . compact
else
selected
end
end
2012-02-01 14:43:44 -05:00
def value_for_collection ( item , value )
value . respond_to? ( :call ) ? value . call ( item ) : item . send ( value )
end
2012-05-16 19:52:27 -04:00
def prompt_text ( prompt )
2013-07-22 13:27:19 -04:00
prompt . kind_of? ( String ) ? prompt : I18n . translate ( 'helpers.select.prompt' , default : 'Please select' )
2012-05-16 19:52:27 -04:00
end
2004-11-23 20:04:44 -05:00
end
2005-11-13 06:13:11 -05:00
class FormBuilder
2013-01-26 11:36:38 -05:00
# Wraps ActionView::Helpers::FormOptionsHelper#select for form builders:
2013-01-17 13:45:16 -05:00
#
2013-01-26 11:36:38 -05:00
# <%= form_for @post do |f| %>
2013-07-21 15:18:06 -04:00
# <%= f.select :person_id, Person.all.collect { |p| [ p.name, p.id ] }, include_blank: true %>
2013-01-26 11:36:38 -05:00
# <%= f.submit %>
# <% end %>
2013-01-17 13:45:16 -05:00
#
2013-01-26 11:36:38 -05:00
# Please refer to the documentation of the base helper for details.
2013-09-23 07:25:42 -04:00
def select ( method , choices = nil , options = { } , html_options = { } , & block )
@template . select ( @object_name , method , choices , objectify_options ( options ) , @default_options . merge ( html_options ) , & block )
2005-11-13 06:13:11 -05:00
end
2013-01-26 11:36:38 -05:00
# Wraps ActionView::Helpers::FormOptionsHelper#collection_select for form builders:
2013-01-17 13:45:16 -05:00
#
2013-01-26 11:36:38 -05:00
# <%= form_for @post do |f| %>
# <%= f.collection_select :person_id, Author.all, :id, :name_with_initial, prompt: true %>
# <%= f.submit %>
# <% end %>
2013-01-17 13:45:16 -05:00
#
2013-01-26 11:36:38 -05:00
# Please refer to the documentation of the base helper for details.
2005-11-13 06:13:11 -05:00
def collection_select ( method , collection , value_method , text_method , options = { } , html_options = { } )
2008-07-13 19:55:57 -04:00
@template . collection_select ( @object_name , method , collection , value_method , text_method , objectify_options ( options ) , @default_options . merge ( html_options ) )
2005-11-13 06:13:11 -05:00
end
2013-01-26 11:36:38 -05:00
# Wraps ActionView::Helpers::FormOptionsHelper#grouped_collection_select for form builders:
2013-01-17 13:45:16 -05:00
#
2013-01-26 11:36:38 -05:00
# <%= form_for @city do |f| %>
2013-06-27 11:10:05 -04:00
# <%= f.grouped_collection_select :country_id, @continents, :countries, :name, :id, :name %>
2013-01-26 11:36:38 -05:00
# <%= f.submit %>
# <% end %>
2013-01-17 13:45:16 -05:00
#
2013-01-26 11:36:38 -05:00
# Please refer to the documentation of the base helper for details.
2009-08-09 22:18:01 -04:00
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
2013-01-26 11:36:38 -05:00
# Wraps ActionView::Helpers::FormOptionsHelper#time_zone_select for form builders:
2013-01-17 13:45:16 -05:00
#
2013-01-26 11:36:38 -05:00
# <%= form_for @user do |f| %>
# <%= f.time_zone_select :time_zone, nil, include_blank: true %>
# <%= f.submit %>
# <% end %>
2013-01-17 13:45:16 -05:00
#
2013-01-26 11:36:38 -05:00
# Please refer to the documentation of the base helper for details.
2005-11-13 06:13:11 -05:00
def time_zone_select ( method , priority_zones = nil , options = { } , html_options = { } )
2008-07-13 19:55:57 -04:00
@template . time_zone_select ( @object_name , method , priority_zones , objectify_options ( options ) , @default_options . merge ( html_options ) )
2005-11-13 06:13:11 -05:00
end
2012-02-01 14:28:50 -05:00
2013-01-26 11:36:38 -05:00
# Wraps ActionView::Helpers::FormOptionsHelper#collection_check_boxes for form builders:
2013-01-17 13:45:16 -05:00
#
2013-01-26 11:36:38 -05:00
# <%= form_for @post do |f| %>
# <%= f.collection_check_boxes :author_ids, Author.all, :id, :name_with_initial %>
# <%= f.submit %>
# <% end %>
2013-01-17 13:45:16 -05:00
#
2013-01-26 11:36:38 -05:00
# Please refer to the documentation of the base helper for details.
2013-01-12 11:48:25 -05:00
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 )
2012-02-01 14:28:50 -05:00
end
2013-01-26 11:36:38 -05:00
# Wraps ActionView::Helpers::FormOptionsHelper#collection_radio_buttons for form builders:
2013-01-17 13:45:16 -05:00
#
2013-01-26 11:36:38 -05:00
# <%= form_for @post do |f| %>
# <%= f.collection_radio_buttons :author_id, Author.all, :id, :name_with_initial %>
# <%= f.submit %>
# <% end %>
2013-01-17 13:45:16 -05:00
#
2013-01-26 11:36:38 -05:00
# Please refer to the documentation of the base helper for details.
2013-01-12 11:48:25 -05:00
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 )
2012-02-01 14:28:50 -05:00
end
2005-11-13 06:13:11 -05:00
end
2004-11-23 20:04:44 -05:00
end
2005-02-23 18:55:59 -05:00
end