actionpack 1.4.0 → 1.5.0

data/lib/action_view/helpers/active_record_helper.rb

@@ -10,7 +10,7 @@ module ActionView
   module Helpers
     # The Active Record Helper makes it easier to create forms for records kept in instance variables. The most far-reaching is the form
     # method that creates a complete form for all the basic content types of the record (not associations or aggregations, though). This
-    # is a great of making the record quickly available for editing, but likely to prove lacklusters for a complicated real-world form.
+    # is a great of making the record quickly available for editing, but likely to prove lackluster for a complicated real-world form.
     # In that case, it's better to use the input method and the specialized form methods in link:classes/ActionView/Helpers/FormHelper.html
     module ActiveRecordHelper
       # Returns a default input tag for the type of object returned by the method. Example

data/lib/action_view/helpers/asset_tag_helper.rb

@@ -0,0 +1,59 @@
+require 'cgi'
+require File.dirname(__FILE__) + '/url_helper'
+require File.dirname(__FILE__) + '/tag_helper'
+
+module ActionView
+  module Helpers
+    # Provides methods for linking a HTML page together with other assets, such as javascripts, stylesheets, and feeds.
+    module AssetTagHelper
+      # Returns a link tag that browsers and news readers can use to auto-detect a RSS or ATOM feed for this page. The +type+ can
+      # either be <tt>:rss</tt> (default) or <tt>:atom</tt> and the +options+ follow the url_for style of declaring a link target.
+      #
+      # Examples:
+      #   auto_discovery_link_tag # => 
+      #     <link rel="alternate" type="application/rss+xml" title="RSS" href="http://www.curenthost.com/controller/action" />
+      #   auto_discovery_link_tag(:atom) # => 
+      #     <link rel="alternate" type="application/atom+xml" title="ATOM" href="http://www.curenthost.com/controller/action" />
+      #   auto_discovery_link_tag(:rss, :action => "feed") # => 
+      #     <link rel="alternate" type="application/atom+xml" title="ATOM" href="http://www.curenthost.com/controller/feed" />
+      def auto_discovery_link_tag(type = :rss, options = {})
+        tag(
+          "link", "rel" => "alternate", "type" => "application/#{type}+xml", "title" => type.to_s.upcase, 
+          "href" => url_for(options.merge(:only_path => false))
+        )
+      end
+
+      # Returns a script include tag per source given as argument. Examples:
+      #
+      #   javascript_include_tag "xmlhr" # =>
+      #     <script language="JavaScript" type="text/javascript" src="/javascripts/xmlhr.js"></script>
+      #
+      #   javascript_include_tag "common.javascript", "/elsewhere/cools" # =>
+      #     <script language="JavaScript" type="text/javascript" src="/javascripts/common.javascript"></script>
+      #     <script language="JavaScript" type="text/javascript" src="/elsewhere/cools.js"></script>
+      def javascript_include_tag(*sources)
+        sources.collect { |source|
+          source = "/javascripts/#{source}" unless source.include?("/")
+          source = "#{source}.js" unless source.include?(".")
+          content_tag("script", "", "language" => "JavaScript", "type" => "text/javascript", "src" => source)
+        }.join("\n")
+      end
+    
+      # Returns a css link tag per source given as argument. Examples:
+      #
+      #   stylesheet_link_tag "style" # =>
+      #     <link href="/stylesheets/style.css" media="screen" rel="Stylesheet" type="text/css" />
+      #
+      #   stylesheet_link_tag "random.styles", "/css/stylish" # =>
+      #     <link href="/stylesheets/random.styles" media="screen" rel="Stylesheet" type="text/css" />
+      #     <link href="/css/stylish.css" media="screen" rel="Stylesheet" type="text/css" />
+      def stylesheet_link_tag(*sources)
+        sources.collect { |source| 
+          source = "/stylesheets/#{source}" unless source.include?("/")
+          source = "#{source}.css" unless source.include?(".")
+          tag("link", "rel" => "Stylesheet", "type" => "text/css", "media" => "screen", "href" => source)
+        }.join("\n")
+      end
+    end
+  end
+end

data/lib/action_view/helpers/date_helper.rb

@@ -35,19 +35,23 @@ module ActionView
       end
 
       # Returns a set of select tags (one for year, month, and day) pre-selected for accessing a specified date-based attribute (identified by
-      # +method+) on an object assigned to the template (identified by +object+). It's possible to tailor the selects through the +options+ hash, 
-      # which both accepts all the keys that each of the individual select builders does (like :use_month_numbers for select_month) and a range
-      # of discard options. The discard options are <tt>:discard_month</tt> and <tt>:discard_day</tt>. Set to true, they'll drop the respective
-      # select. Discarding the month select will also automatically discard the day select. 
+      # +method+) on an object assigned to the template (identified by +object+). It's possible to tailor the selects through the +options+ hash,
+      # which both accepts all the keys that each of the individual select builders does (like :use_month_numbers for select_month) and a range of
+      # discard options. The discard options are <tt>:discard_year</tt>, <tt>:discard_month</tt> and <tt>:discard_day</tt>. Set to true, they'll
+      # drop the respective select. Discarding the month select will also automatically discard the day select. It's also possible to explicitly
+      # set the order of the tags using the <tt>:order</tt> option with an array of symbols <tt>:year</tt>, <tt>:month</tt> and <tt>:day</tt> in
+      # the desired order. Symbols may be omitted and the respective select is not included.
+      #
+      # NOTE: Discarded selects will default to 1. So if no month select is available, January will be assumed.
       #
-      # NOTE: Discarded selects will default to 1. So if no month select is available, January will be assumed. Additionally, you can get the 
-      # month select before the year by setting :month_before_year to true in the options. This is especially useful for credit card forms. 
       # Examples:
       #
       #   date_select("post", "written_on")
       #   date_select("post", "written_on", :start_year => 1995)
       #   date_select("post", "written_on", :start_year => 1995, :use_month_numbers => true, 
       #                                     :discard_day => true, :include_blank => true)
+      #   date_select("post", "written_on", :order => [:day, :month, :year])
+      #   date_select("user", "birthday",   :order => [:month, :day])
       #
       # The selects are prepared for multi-parameter assignment to an Active Record object.
       def date_select(object, method, options = {})
@@ -219,15 +223,22 @@ module ActionView
 
         date_select = ""
         
-        if options[:month_before_year]
-          date_select << select_month(date, options_with_prefix.call(2)) unless options[:discard_month]
-          date_select << select_year(date, options_with_prefix.call(1))
-        else
-          date_select << select_year(date, options_with_prefix.call(1))
-          date_select << select_month(date, options_with_prefix.call(2)) unless options[:discard_month]
+        if options[:month_before_year] # For backwards compatibility
+          options[:order] = [:month, :year, :day]
         end
 
-        date_select << select_day(date, options_with_prefix.call(3))   unless options[:discard_day] || options[:discard_month]
+        options[:order] ||= [:year, :month, :day]
+
+        position = {:year => 1, :month => 2, :day => 3}
+        
+        discard = {}
+        discard[:year]  = true if options[:discard_year]
+        discard[:month] = true if options[:discard_month]
+        discard[:day]   = true if options[:discard_day] or options[:discard_month]
+        
+        options[:order].each do |param|
+          date_select << self.send("select_#{param}", date, options_with_prefix.call(position[param])) unless discard[param]
+        end
 
         return date_select
       end

data/lib/action_view/helpers/form_helper.rb

@@ -78,6 +78,11 @@ module ActionView
         InstanceTag.new(object, method, self).to_input_field_tag("hidden", options)
       end
 
+      # Works just like text_field, but returns a input tag of the "file" type instead, which won't have any default value.
+      def file_field(object, method, options = {})
+        InstanceTag.new(object, method, self).to_input_field_tag("file", options)
+      end
+
       # Returns a textarea opening and closing tag set tailored for accessing a specified attribute (identified by +method+)
       # on an object assigned to the template (identified by +object+). Additional options on the input tag can be passed as a
       # hash with +options+.
@@ -147,7 +152,7 @@ module ActionView
         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 }) unless options["value"]
+        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

data/lib/action_view/helpers/form_options_helper.rb

@@ -5,11 +5,26 @@ require File.dirname(__FILE__) + '/form_helper'
 module ActionView
   module Helpers
     # Provides a number of methods for turning different kinds of containers into a set of option tags.
+    # == Options
+    # The <tt>collection_select</tt>, <tt>country_select</tt>, <tt>select</tt>,
+    # and <tt>time_zone_select</tt> methods take an <tt>options</tt> parameter,
+    # a hash.
+    #
+    # * <tt>:include_blank</tt> - set to true 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.
+    #   select("post", "category", Post::CATEGORIES, {:include_blank => true})
+    #
+    # Could become:
+    #
+    #   <select name="post[category]">
+    #     <option></option>
+    #     <option>joke</option>
+    #     <option>poem</option>
+    #   </select>
     module FormOptionsHelper
       include ERB::Util
 
       # Create a select tag and a series of contained option tags for the provided object and method.
-      # The option currenlty held by the object will be selected, provided that the object is available.
+      # 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
@@ -30,24 +45,38 @@ module ActionView
         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.
+      #
+      # In addition to the <tt>:include_blank</tt> option documented above,
+      # this method also supports a <tt>:model</tt> 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.)
+      def time_zone_select(object, method, priority_zones = nil, options = {}, html_options = {})
+        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 
       # 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"]])
       #     <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([ "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>
+      #   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.
       def options_for_select(container, selected = nil)
         container = container.to_a if Hash === container
       
@@ -75,6 +104,8 @@ module ActionView
       # Example (call, result). Imagine a loop iterating over each +person+ in <tt>@project.people</tt> to generate a 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.
       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) ] }, 
@@ -87,7 +118,7 @@ module ActionView
       # An array of group objects are passed. Each group should return an array of options when calling group_method
       # Each group should should return its name when calling group_label_method.
       #
-      # html_option_groups_from_collection(@continents, "countries", "contient_name", "country_id", "country_name", @selected_country.id)
+      # html_option_groups_from_collection(@continents, "countries", "continent_name", "country_id", "country_name", @selected_country.id)
       #
       # Could become:
       #  <optgroup label="Africa">
@@ -113,6 +144,8 @@ module ActionView
       #	  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, 
             option_key_method, option_value_method, selected_key = nil)
         collection.inject("") do |options_for_select, group|
@@ -126,6 +159,8 @@ module ActionView
       # 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 = ""
         
@@ -143,10 +178,43 @@ module ActionView
         return country_options
       end
 
+      # Returns a string of option tags for pretty much any time zone in the
+      # world. Supply a TimeZone object 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.
+      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>-------------</option>\n"
+
+          zones = zones.reject { |z| priority_zones.include?( z ) }
+        end
+
+        zone_options += options_for_select(convert_zones[zones], selected)
+        zone_options
+      end
 
       private
         # All the countries included in the country_options output.
-        COUNTRIES = [ "Albania", "Algeria", "American Samoa", "Andorra", "Angola", "Anguilla", 
+        COUNTRIES = [ "Afghanistan", "Albania", "Algeria", "American Samoa", "Andorra", "Angola", "Anguilla", 
             "Antarctica", "Antigua And Barbuda", "Argentina", "Armenia", "Aruba", "Australia", 
             "Austria", "Azerbaijan", "Bahamas", "Bahrain", "Bangladesh", "Barbados", "Belarus", 
             "Belgium", "Belize", "Benin", "Bermuda", "Bhutan", "Bolivia", "Bosnia and Herzegowina", 
@@ -163,7 +231,7 @@ module ActionView
             "Georgia", "Germany", "Ghana", "Gibraltar", "Great Britain", "Greece", "Greenland", 
             "Grenada", "Guadeloupe", "Guam", "Guatemala", "Guinea", "Guinea-Bissau", "Guyana", 
             "Haiti", "Heard and Mc Donald Islands", "Honduras", "Hong Kong", "Hungary", "Iceland", 
-            "India", "Indonesia", "Ireland", "Israel", "Italy", "Jamaica", "Japan", "Jordan", 
+            "India", "Indonesia", "Ireland", "Israel", "Italy", "Iran", "Irak", "Jamaica", "Japan", "Jordan", 
             "Kazakhstan", "Kenya", "Kiribati", "Korea, Republic of", "Korea (South)", "Kuwait", 
             "Kyrgyzstan", "Lao People's Democratic Republic", "Latvia", "Lebanon", "Lesotho", 
             "Liberia", "Liechtenstein", "Lithuania", "Luxembourg", "Macau", "Macedonia", 
@@ -212,6 +280,16 @@ module ActionView
         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)
+        add_default_name_and_id(html_options)
+        content_tag("select",
+          add_blank_option(
+            time_zone_options_for_select(value, priority_zones, options[:model] || TimeZone),
+            options[:include_blank]
+          ), html_options
+        )
+      end
+
       private
         def add_blank_option(option_tags, add_blank)
           add_blank ? "<option></option>\n" + option_tags : option_tags

data/lib/action_view/helpers/form_tag_helper.rb

@@ -0,0 +1,80 @@
+require 'cgi'
+require File.dirname(__FILE__) + '/tag_helper'
+
+module ActionView
+  module Helpers
+    # 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 
+      # 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)
+        
+        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
+
+      alias_method :start_form_tag, :form_tag
+
+      # Outputs "</form>"
+      def end_form_tag
+        "</form>"
+      end
+
+      def select_tag(name, option_tags = nil, options = {})
+        content_tag("select", option_tags, { "name" => name, "id" => name }.update(options))
+      end
+
+      def text_field_tag(name, value = nil, options = {})
+        tag("input", {"type" => "text", "name" => name, "id" => name, "value" => value}.update(options))
+      end
+
+      def hidden_field_tag(name, value = nil, options = {})
+        text_field_tag(name, value, options.update("type" => "hidden"))
+      end
+
+      def file_field_tag(name, options = {})
+        text_field_tag(name, nil, options.update("type" => "file"))
+      end
+
+      def password_field_tag(name = "password", value = nil, options = {})
+        text_field_tag(name, value, options.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)
+        end
+        
+        content_tag("textarea", content, { "name" => name, "id" => name }.update(options))
+      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["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["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))
+      end
+    end
+  end
+end

data/lib/action_view/helpers/tag_helper.rb

@@ -22,29 +22,6 @@ module ActionView
         "<#{name}#{tag_options(options)}>#{content}</#{name}>"
       end
 
-      # Starts a form tag that points the action to an url configured with <tt>url_for_options</tt> just like 
-      # ActionController::Base#url_for.
-      def form_tag(url_for_options = {}, options = {}, *parameters_for_url)
-        html_options = { "method" => "post" }.merge(options)
-        
-        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
-      
-      alias_method :start_form_tag, :form_tag
-
-      # Outputs "</form>"
-      def end_form_tag
-        "</form>"
-      end
-
-
       private
         def tag_options(options)
           unless options.empty?

data/lib/action_view/helpers/text_helper.rb

@@ -69,7 +69,7 @@ module ActionView
         # Returns the text with all the Textile codes turned into HTML-tags. 
         # <i>This method is only available if RedCloth can be required</i>.
         def textilize(text)
-          text.empty? ? "" : RedCloth.new(text).to_html
+          text.empty? ? "" : RedCloth.new(text, [ :hard_breaks ]).to_html
         end
 
         # Returns the text with all the Textile codes turned into HTML-tags, but without the regular bounding <p> tag. 
@@ -96,6 +96,21 @@ module ActionView
         # We can't really help what's not there
       end
 
+      # Turns all urls and email addresses into clickable links. The +link+ parameter can limit what should be linked.
+      # Options are :all (default), :email_addresses, and :urls.
+      #
+      # Example:
+      #   auto_link("Go to http://www.rubyonrails.com and say hello to david@loudthinking.com") =>
+      #     Go to <a href="http://www.rubyonrails.com">http://www.rubyonrails.com</a> and 
+      #     say hello to <a href="mailto:david@loudthinking.com">david@loudthinking.com</a>
+      def auto_link(text, link = :all)
+        case link
+          when :all             then auto_link_urls(auto_link_email_addresses(text))
+          when :email_addresses then auto_link_email_addresses(text)
+          when :urls            then auto_link_urls(text)
+        end
+      end
+
       # Turns all links into words, like "<a href="something">else</a>" to "else".
       def strip_links(text)
         text.gsub(/<a.*>(.*)<\/a>/m, '\1')
@@ -106,6 +121,16 @@ module ActionView
         def escape_regexp(text)
           text.gsub(/([\\|?+*\/\)\(])/) { |m| "\\#{$1}" }
         end
+
+        # Turns all urls into clickable links.
+        def auto_link_urls(text)
+          text.gsub(/([^=><!:'"\/]|^)((http[s]?:\/\/)|(www\.))(\S+\b\/?)([[:punct:]]*)(\s|$)/, '\1<a href="\3\4\5">\3\4\5</a>\6\7')
+        end
+
+        # Turns all email addresses into clickable links.
+        def auto_link_email_addresses(text)
+          text.gsub(/([\w\.!#\$%\-+.]+@[A-Za-z0-9\-]+(\.[A-Za-z0-9\-]+)+)/, '<a href="mailto:\1">\1</a>')
+        end
     end
   end
 end