actionpack 1.5.0 → 1.5.1

data/lib/action_view/helpers/form_helper.rb

@@ -8,10 +8,10 @@ module ActionView
     # The following is an example of a complete form for a person object that works for both creates and updates built
     # with all the form helpers. The <tt>@person</tt> object was assigned by an action on the controller:
     #   <form action="save_person" method="post">
-    #     Name:           
+    #     Name:
     #     <%= text_field "person", "name", "size" => 20 %>
     #
-    #     Password:       
+    #     Password:
     #     <%= password_field "person", "password", "maxsize" => 20 %>
     #
     #     Single?:
@@ -26,12 +26,12 @@ module ActionView
     # ...is compiled to:
     #
     #   <form action="save_person" method="post">
-    #     Name:           
-    #     <input type="text" id="person_name" name="person[name]" 
+    #     Name:
+    #     <input type="text" id="person_name" name="person[name]"
     #       size="20" value="<%= @person.name %>" />
     #
-    #     Password:       
-    #     <input type="password" id="person_password" name="person[password]" 
+    #     Password:
+    #     <input type="password" id="person_password" name="person[password]"
     #       size="20" maxsize="20" value="<%= @person.password %>" />
     #
     #     Single?:
@@ -43,7 +43,15 @@ module ActionView
     #     </textarea>
     #
     #     <input type="submit" value="Save">
-    #   </form>    
+    #   </form>
+    #
+    # If the object name contains square brackets the id for the object will be inserted. Example:
+    #
+    #   <%= textfield "person[]", "name" %> 
+    # 
+    # ...becomes:
+    #
+    #   <input type="text" id="person_<%= @person.id %>_name" name="person[<%= @person.id %>][name]" value="<%= @person.name %>" />
     #
     # If the helper is being used to generate a repetitive sequence of similar form elements, for example in a partial
     # used by render_collection_of_partials, the "index" option may come in handy. Example:
@@ -51,10 +59,10 @@ module ActionView
     #   <%= text_field "person", "name", "index" => 1 %>
     #
     # becomes
-    # 
+    #
     #   <input type="text" id="person_1_name" name="person[1][name]" value="<%= @person.name %>" />
     #
-    # There's also methods for helping to build form tags in link:classes/ActionView/Helpers/FormOptionsHelper.html, 
+    # There's also methods for helping to build form tags in link:classes/ActionView/Helpers/FormOptionsHelper.html,
     # link:classes/ActionView/Helpers/DateHelper.html, and link:classes/ActionView/Helpers/ActiveRecordHelper.html
     module FormHelper
       # Returns an input tag of the "text" type tailored for accessing a specified attribute (identified by +method+) on an object
@@ -64,7 +72,7 @@ module ActionView
       # Examples (call, result):
       #   text_field("post", "title", "size" => 20)
       #     <input type="text" id="post_title" name="post[title]" size="20" value="#{@post.title}" />
-      def text_field(object, method, options = {}) 
+      def text_field(object, method, options = {})
         InstanceTag.new(object, method, self).to_input_field_tag("text", options)
       end
 
@@ -95,12 +103,12 @@ module ActionView
       def text_area(object, method, options = {})
         InstanceTag.new(object, method, self).to_text_area_tag(options)
       end
-      
+
       # Returns a checkbox tag tailored for accessing a specified attribute (identified by +method+) on an object
       # assigned to the template (identified by +object+). It's intended that +method+ returns an integer and if that
       # integer is above zero, then the checkbox is checked. Additional options on the input tag can be passed as a
       # hash with +options+. The +checked_value+ defaults to 1 while the default +unchecked_value+
-      # is set to 0 which is convenient for boolean values. Usually unchecked checkboxes don't post anything. 
+      # is set to 0 which is convenient for boolean values. Usually unchecked checkboxes don't post anything.
       # We work around this problem by adding a hidden value with the same name as the checkbox.
       #
       # Example (call, result). Imagine that @post.validated? returns 1:
@@ -119,13 +127,13 @@ module ActionView
       # Returns a radio button tag for accessing a specified attribute (identified by +method+) on an object
       # assigned to the template (identified by +object+). If the current value of +method+ is +tag_value+ the
       # radio button will be checked. Additional options on the input tag can be passed as a
-      # hash with +options+. 
+      # hash with +options+.
       # Example (call, result). Imagine that @post.category returns "rails":
       #   radio_button("post", "category", "rails")
       #   radio_button("post", "category", "java")
       #     <input type="radio" id="post_category" name="post[category] value="rails" checked="checked" />
       #     <input type="radio" id="post_category" name="post[category] value="java" />
-      #     
+      #
       def radio_button(object, method, tag_value, options = {})
         InstanceTag.new(object, method, self).to_radio_button_tag(tag_value, options)
       end
@@ -135,9 +143,10 @@ module ActionView
       include Helpers::TagHelper
 
       attr_reader :method_name, :object_name
-      
-      DEFAULT_FIELD_OPTIONS     = { "size" => 30 } unless const_defined?("DEFAULT_FIELD_OPTIONS")
-      DEFAULT_TEXT_AREA_OPTIONS = { "wrap" => "virtual", "cols" => 40, "rows" => 20 } unless const_defined?("DEFAULT_TEXT_AREA_OPTIONS")
+
+      DEFAULT_FIELD_OPTIONS     = { "size" => 30 }.freeze unless const_defined?(:DEFAULT_FIELD_OPTIONS)
+      DEFAULT_TEXT_AREA_OPTIONS = { "wrap" => "virtual", "cols" => 40, "rows" => 20 }.freeze unless const_defined?(:DEFAULT_TEXT_AREA_OPTIONS)
+      DEFAULT_DATE_OPTIONS = { :discard_type => true }.freeze unless const_defined?(:DEFAULT_DATE_OPTIONS)
 
       def initialize(object_name, method_name, template_object, local_binding = nil)
         @object_name, @method_name = object_name, method_name
@@ -146,50 +155,69 @@ module ActionView
           @auto_index = @template_object.instance_variable_get("@#{Regexp.last_match.pre_match}").id
         end
       end
-      
+
       def to_input_field_tag(field_type, options = {})
-        html_options = DEFAULT_FIELD_OPTIONS.merge(options)
-        html_options.merge!({ "size" => options["maxlength"]}) if options["maxlength"] && !options["size"]
-        html_options.delete("size") if field_type == "hidden"
-        html_options.merge!({ "type" =>  field_type})
-        html_options.merge!({ "value" => value_before_type_cast }) if options["value"].nil? && field_type != "file"
-        add_default_name_and_id(html_options)
-        tag("input", html_options)
-      end
-
-      def to_radio_button_tag(tag_value, options={})
-        html_options = DEFAULT_FIELD_OPTIONS.merge(options)
-        html_options.merge!({ "checked" => "checked" }) if value == tag_value
-        html_options.merge!({ "type" => "radio", "value"=> tag_value.to_s })
-                       
-        add_default_name_and_id(html_options)
-        tag("input", html_options)
-      end
-      
+        options = options.stringify_keys
+        if field_type == "hidden"
+          options.delete("size")
+        else
+          options["size"] ||= options["maxlength"] || DEFAULT_FIELD_OPTIONS["size"]
+        end
+        options["type"] = field_type
+        options["value"] ||= value_before_type_cast unless field_type == "file"
+        add_default_name_and_id(options)
+        tag("input", options)
+      end
+
+      def to_radio_button_tag(tag_value, options = {})
+        options = DEFAULT_FIELD_OPTIONS.merge(options.stringify_keys)
+        options["type"]     = "radio"
+        options["value"]    = tag_value
+        options["checked"]  = "checked" if value == tag_value
+        add_default_name_and_id(options)
+        tag("input", options)
+      end
+
       def to_text_area_tag(options = {})
-        options = DEFAULT_TEXT_AREA_OPTIONS.merge(options)
+        options = DEFAULT_TEXT_AREA_OPTIONS.merge(options.stringify_keys)
         add_default_name_and_id(options)
         content_tag("textarea", html_escape(value_before_type_cast), options)
       end
 
       def to_check_box_tag(options = {}, checked_value = "1", unchecked_value = "0")
-        options.merge!({ "checked" => "checked" }) if !value.nil? && ((value.is_a?(TrueClass) || value.is_a?(FalseClass)) ? value : value.to_i > 0)
-        options.merge!({ "type" => "checkbox", "value" => checked_value })
+        options = options.stringify_keys
+        options["type"]     = "checkbox"
+        options["value"]    = checked_value
+        checked = case value
+          when TrueClass, FalseClass
+            value
+          when NilClass
+            false
+          when Integer
+            value != 0
+          else
+            value.to_i != 0
+          end
+        if checked
+          options["checked"] = "checked"
+        else
+          options.delete("checked")
+        end
         add_default_name_and_id(options)
-        tag("input", options) << tag("input", ({ "name" => options['name'], "type" => "hidden", "value" => unchecked_value }))
+        tag("input", options) << tag("input", "name" => options["name"], "type" => "hidden", "value" => unchecked_value)
       end
 
       def to_date_tag()
-        defaults = { "discard_type" => true }
+        defaults = DEFAULT_DATE_OPTIONS.dup
         date     = value || Date.today
-        options  = Proc.new { |position| defaults.update({ :prefix => "#{@object_name}[#{@method_name}(#{position}i)]" }) }
-
+        options  = Proc.new { |position| defaults.merge(:prefix => "#{@object_name}[#{@method_name}(#{position}i)]") }
         html_day_select(date, options.call(3)) +
-        html_month_select(date, options.call(2)) + 
+        html_month_select(date, options.call(2)) +
         html_year_select(date, options.call(1))
       end
 
       def to_boolean_select_tag(options = {})
+        options = options.stringify_keys
         add_default_name_and_id(options)
         tag_text = "<select"
         tag_text << tag_options(options)
@@ -210,7 +238,7 @@ module ActionView
 
       def value_before_type_cast
         unless object.nil?
-          object.respond_to?(@method_name + "_before_type_cast") ? 
+          object.respond_to?(@method_name + "_before_type_cast") ?
             object.send(@method_name + "_before_type_cast") :
             object.send(@method_name)
         end
@@ -218,23 +246,23 @@ module ActionView
 
       private
         def add_default_name_and_id(options)
-          if options.has_key? "index"
-            options['name'] = tag_name_with_index(options["index"]) unless options.has_key? "name"
-            options['id'] = tag_id_with_index(options["index"]) unless options.has_key? "id"
+          if options.has_key?("index")
+            options["name"] ||= tag_name_with_index(options["index"])
+            options["id"]   ||= tag_id_with_index(options["index"])
             options.delete("index")
           elsif @auto_index
-            options['name'] = tag_name_with_index(@auto_index) unless options.has_key? "name"
-            options['id'] = tag_id_with_index(@auto_index) unless options.has_key? "id"
+            options["name"] ||= tag_name_with_index(@auto_index)
+            options["id"]   ||= tag_id_with_index(@auto_index)
           else
-            options['name'] = tag_name unless options.has_key? "name"
-            options['id'] = tag_id unless options.has_key? "id"
+            options["name"] ||= tag_name
+            options["id"]   ||= tag_id
           end
         end
-				
+
         def tag_name
           "#{@object_name}[#{@method_name}]"
         end
-				
+
         def tag_name_with_index(index)
           "#{@object_name}[#{index}][#{@method_name}]"
         end

data/lib/action_view/helpers/form_options_helper.rb

@@ -25,7 +25,7 @@ module ActionView
 
       # 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.
-      # 
+      #
       # 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.
@@ -34,17 +34,17 @@ module ActionView
       def select(object, method, choices, options = {}, html_options = {})
         InstanceTag.new(object, method, self).to_select_tag(choices, options, html_options)
       end
-        
+
       # Return select and option tags for the given object and method using options_from_collection_for_select to generate the list of option tags.
       def collection_select(object, method, collection, value_method, text_method, options = {}, html_options = {})
         InstanceTag.new(object, method, self).to_collection_select_tag(collection, value_method, text_method, options, html_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.
       def country_select(object, method, priority_countries = nil, options = {}, html_options = {})
         InstanceTag.new(object, method, self).to_country_select_tag(priority_countries, options, html_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.
       #
@@ -57,11 +57,11 @@ module ActionView
         InstanceTag.new(object, method, self).to_time_zone_select_tag(priority_zones, options, html_options)
       end
 
-      # Accepts a container (hash, array, enumerable, your type) and returns a string of option tags. Given a container 
+      # 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. 
+      # may also be an array of values to be selected when using a multiple select.
       #
       # Examples (call, result):
       #   options_for_select([["Dollar", "$"], ["Kroner", "DKK"]])
@@ -79,8 +79,8 @@ module ActionView
       # NOTE: Only the option tags are returned, you have to wrap this call in a regular HTML select tag.
       def options_for_select(container, selected = nil)
         container = container.to_a if Hash === container
-      
-        options_for_select = container.inject([]) do |options, element| 
+
+        options_for_select = container.inject([]) do |options, element|
           if element.respond_to?(:first) && element.respond_to?(:last)
             is_selected = ( (selected.respond_to?(:include?) ? selected.include?(element.last) : element.last == selected) )
             if is_selected
@@ -93,11 +93,11 @@ module ActionView
             options << ((is_selected) ? "<option selected=\"selected\">#{html_escape(element.to_s)}</option>" : "<option>#{html_escape(element.to_s)}</option>")
           end
         end
-        
+
         options_for_select.join("\n")
       end
 
-      # Returns a string of option tags that has been compiled by iterating over the +collection+ and assigning the 
+      # Returns a string of option tags that has 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_value+ is specified, the element returning a match on +value_method+ will get the selected option tag.
       #
@@ -108,7 +108,7 @@ module ActionView
       # NOTE: Only the option tags are returned, you have to wrap this call in a regular HTML select tag.
       def options_from_collection_for_select(collection, value_method, text_method, selected_value = nil)
         options_for_select(
-          collection.inject([]) { |options, object| options << [ object.send(text_method), object.send(value_method) ] }, 
+          collection.inject([]) { |options, object| options << [ object.send(text_method), object.send(value_method) ] },
           selected_value
         )
       end
@@ -135,18 +135,18 @@ module ActionView
       #
       # with objects of the following classes:
       # class Continent
-      #	  def initialize(p_name, p_countries)	@continent_name = p_name; @countries = p_countries;	end
-      #	  def continent_name() @continent_name; end
-      #	  def countries() @countries; end
+      #   def initialize(p_name, p_countries) @continent_name = p_name; @countries = p_countries; end
+      #   def continent_name() @continent_name; end
+      #   def countries() @countries; end
       # end
       # class Country
-      #	  def initialize(id, name) @id = id; @name = name end
-      #	  def country_id() @id; end
-      #	  def country_name() @name; end
+      #   def initialize(id, name) @id = id; @name = name end
+      #   def country_id() @id; end
+      #   def country_name() @name; end
       # end
       #
       # NOTE: Only the option tags are returned, you have to wrap this call in a regular HTML select tag.
-      def option_groups_from_collection_for_select(collection, group_method, group_label_method, 
+      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}")
@@ -154,16 +154,16 @@ module ActionView
           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	
-      
-      # Returns a string of option tags for pretty much any country in the world. Supply a country name as +selected+ to 
+      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.
       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>-------------</option>\n"
@@ -264,23 +264,27 @@ module ActionView
       include FormOptionsHelper
 
       def to_select_tag(choices, options, html_options)
+        html_options = html_options.stringify_keys
         add_default_name_and_id(html_options)
         content_tag("select", add_blank_option(options_for_select(choices, value), options[:include_blank]), html_options)
       end
 
       def to_collection_select_tag(collection, value_method, text_method, options, html_options)
+        html_options = html_options.stringify_keys
         add_default_name_and_id(html_options)
         content_tag(
           "select", add_blank_option(options_from_collection_for_select(collection, value_method, text_method, value), options[:include_blank]), html_options
         )
       end
-      
+
       def to_country_select_tag(priority_countries, options, html_options)
+        html_options = html_options.stringify_keys
         add_default_name_and_id(html_options)
         content_tag("select", add_blank_option(country_options_for_select(value, priority_countries), options[:include_blank]), html_options)
       end
 
       def to_time_zone_select_tag(priority_zones, options, html_options)
+        html_options = html_options.stringify_keys
         add_default_name_and_id(html_options)
         content_tag("select",
           add_blank_option(

data/lib/action_view/helpers/form_tag_helper.rb

@@ -6,21 +6,20 @@ module ActionView
     # Provides a number of methods for creating form tags that doesn't rely on conventions with an object assigned to the template like
     # FormHelper does. With the FormTagHelper, you provide the names and values yourself.
     module FormTagHelper
-      # Starts a form tag that points the action to an url configured with <tt>url_for_options</tt> just like 
+      # Starts a form tag that points the action to an url configured with <tt>url_for_options</tt> just like
       # ActionController::Base#url_for. The method for the form defaults to POST.
       #
       # Options:
       # * <tt>:multipart</tt> - If set to true, the enctype is set to "multipart/form-data".
       def form_tag(url_for_options = {}, options = {}, *parameters_for_url)
-        html_options = { "method" => "post" }.merge(options)
-        
+        html_options = { "method" => "post" }.merge(options.stringify_keys)
+
         if html_options[:multipart]
           html_options["enctype"] = "multipart/form-data"
           html_options.delete(:multipart)
         end
-        
+
         html_options["action"] = url_for(url_for_options, *parameters_for_url)
-        
         tag("form", html_options, true)
       end
 
@@ -32,48 +31,49 @@ module ActionView
       end
 
       def select_tag(name, option_tags = nil, options = {})
-        content_tag("select", option_tags, { "name" => name, "id" => name }.update(options))
+        content_tag("select", option_tags, { "name" => name, "id" => name }.update(options.stringify_keys))
       end
 
       def text_field_tag(name, value = nil, options = {})
-        tag("input", {"type" => "text", "name" => name, "id" => name, "value" => value}.update(options))
+        tag("input", { "type" => "text", "name" => name, "id" => name, "value" => value }.update(options.stringify_keys))
       end
 
       def hidden_field_tag(name, value = nil, options = {})
-        text_field_tag(name, value, options.update("type" => "hidden"))
+        text_field_tag(name, value, options.stringify_keys.update("type" => "hidden"))
       end
 
       def file_field_tag(name, options = {})
-        text_field_tag(name, nil, options.update("type" => "file"))
+        text_field_tag(name, nil, options.stringify_keys.update("type" => "file"))
       end
 
       def password_field_tag(name = "password", value = nil, options = {})
-        text_field_tag(name, value, options.update("type" => "password"))
+        text_field_tag(name, value, options.stringify_keys.update("type" => "password"))
       end
 
       def text_area_tag(name, content = nil, options = {})
-        if options[:size]
-          options["cols"], options["rows"] = options[:size].split("x")
-          options.delete(:size)
+        options = options.stringify_keys
+        if options["size"]
+          options["cols"], options["rows"] = options["size"].split("x")
+          options.delete("size")
         end
-        
-        content_tag("textarea", content, { "name" => name, "id" => name }.update(options))
+
+        content_tag("textarea", content, { "name" => name, "id" => name }.update(options.stringify_keys))
       end
 
       def check_box_tag(name, value = "1", checked = false, options = {})
-        html_options = {"type" => "checkbox", "name" => name, "id" => name, "value" => value}.update(options)
+        html_options = { "type" => "checkbox", "name" => name, "id" => name, "value" => value }.update(options.stringify_keys)
         html_options["checked"] = "checked" if checked
         tag("input", html_options)
       end
 
       def radio_button_tag(name, value, checked = false, options = {})
-        html_options = {"type" => "radio", "name" => name, "id" => name, "value" => value}.update(options)
+        html_options = { "type" => "radio", "name" => name, "id" => name, "value" => value }.update(options.stringify_keys)
         html_options["checked"] = "checked" if checked
         tag("input", html_options)
       end
 
       def submit_tag(value = "Save changes", options = {})
-        tag("input", {"type" => "submit", "name" => "submit", "value" => value}.update(options))
+        tag("input", { "type" => "submit", "name" => "submit", "value" => value }.update(options.stringify_keys))
       end
     end
   end