actionpack 3.0.20 → 3.1.0.beta1

data/lib/action_view/helpers/number_helper.rb

@@ -1,6 +1,7 @@
 require 'active_support/core_ext/big_decimal/conversions'
 require 'active_support/core_ext/float/rounding'
 require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/output_safety'
 
 module ActionView
   # = Action View Number Helpers
@@ -47,36 +48,33 @@ module ActionView
       #  number_to_phone(1235551234, :country_code => 1, :extension => 1343, :delimiter => ".")
       #  => +1.123.555.1234 x 1343
       def number_to_phone(number, options = {})
-        return nil if number.nil?
+        return unless number
 
         begin
           Float(number)
-          is_number_html_safe = true
         rescue ArgumentError, TypeError
-          if options[:raise]
-            raise InvalidNumberError, number
-          else
-            is_number_html_safe = number.to_s.html_safe?
-          end
-        end
+          raise InvalidNumberError, number
+        end if options[:raise]
 
         number       = number.to_s.strip
         options      = options.symbolize_keys
-        area_code    = options[:area_code] || nil
+        area_code    = options[:area_code]
         delimiter    = options[:delimiter] || "-"
-        extension    = options[:extension].to_s.strip || nil
-        country_code = options[:country_code] || nil
+        extension    = options[:extension]
+        country_code = options[:country_code]
 
-        str = ""
-        str << "+#{country_code}#{delimiter}" unless country_code.blank?
-        str << if area_code
-          number.gsub!(/([0-9]{1,3})([0-9]{3})([0-9]{4}$)/,"(\\1) \\2#{delimiter}\\3")
+        if area_code
+          number.gsub!(/(\d{1,3})(\d{3})(\d{4}$)/,"(\\1) \\2#{delimiter}\\3")
         else
-          number.gsub!(/([0-9]{0,3})([0-9]{3})([0-9]{4})$/,"\\1#{delimiter}\\2#{delimiter}\\3")
-          number.starts_with?('-') ? number.slice!(1..-1) : number
+          number.gsub!(/(\d{0,3})(\d{3})(\d{4})$/,"\\1#{delimiter}\\2#{delimiter}\\3")
+          number.slice!(0, 1) if number.starts_with?('-')
         end
+
+        str = []
+        str << "+#{country_code}#{delimiter}" unless country_code.blank?
+        str << number
         str << " x #{extension}" unless extension.blank?
-        is_number_html_safe ? str.html_safe : str
+        ERB::Util.html_escape(str.join)
       end
 
       # Formats a +number+ into a currency string (e.g., $13.65). You can customize the format
@@ -102,14 +100,14 @@ module ActionView
       #  number_to_currency(1234567890.506, :precision => 3)  # => $1,234,567,890.506
       #  number_to_currency(1234567890.506, :locale => :fr)   # => 1 234 567 890,506 €
       #
-      #  number_to_currency(1234567890.50, :negative_format => "(%u%n)")
+      #  number_to_currency(-1234567890.50, :negative_format => "(%u%n)")
       #  # => ($1,234,567,890.51)
       #  number_to_currency(1234567890.50, :unit => "&pound;", :separator => ",", :delimiter => "")
       #  # => &pound;1234567890,50
       #  number_to_currency(1234567890.50, :unit => "&pound;", :separator => ",", :delimiter => "", :format => "%n %u")
       #  # => 1234567890,50 &pound;
       def number_to_currency(number, options = {})
-        return nil if number.nil?
+        return unless number
 
         options.symbolize_keys!
 
@@ -160,7 +158,7 @@ module ActionView
       #  number_to_percentage(302.24398923423, :precision => 5)           # => 302.24399%
       #  number_to_percentage(1000, :locale => :fr)                       # => 1 000,000%
       def number_to_percentage(number, options = {})
-        return nil if number.nil?
+        return unless number
 
         options.symbolize_keys!
 
@@ -213,7 +211,7 @@ module ActionView
         defaults = I18n.translate(:'number.format', :locale => options[:locale], :default => {})
         options = options.reverse_merge(defaults)
 
-        parts = number.to_s.to_str.split('.')
+        parts = number.to_s.split('.')
         parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{options[:delimiter]}")
         parts.join(options[:separator]).html_safe
 
@@ -240,7 +238,7 @@ module ActionView
       #  number_with_precision(111.2345, :precision => 1, :significant => true)     # => 100
       #  number_with_precision(13, :precision => 5, :significant => true)           # => 13.000
       #  number_with_precision(111.234, :locale => :fr)                             # => 111,234
-      #  number_with_precision(13, :precision => 5, :significant => true, strip_insignificant_zeros => true)
+      #  number_with_precision(13, :precision => 5, :significant => true, :strip_insignificant_zeros => true)
       #  # => 13
       #  number_with_precision(389.32314, :precision => 4, :significant => true)    # => 389.3
       #  number_with_precision(1111.2345, :precision => 2, :separator => ',', :delimiter => '.')
@@ -275,7 +273,7 @@ module ActionView
             rounded_number = (BigDecimal.new(number.to_s) / BigDecimal.new((10 ** (digits - precision)).to_f.to_s)).round.to_f * 10 ** (digits - precision)
             digits = (Math.log10(rounded_number.abs) + 1).floor # After rounding, the number of digits may have changed
           end
-          precision = precision - digits
+          precision -= digits
           precision = precision > 0 ? precision : 0  #don't let it be negative
         else
           rounded_number = BigDecimal.new(number.to_s).round(precision).to_f
@@ -306,6 +304,7 @@ module ActionView
       # * <tt>:separator</tt>  - Sets the separator between the fractional and integer digits (defaults to ".").
       # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to "").
       # * <tt>:strip_insignificant_zeros</tt>  - If +true+ removes insignificant zeros after the decimal separator (defaults to +true+)
+      # * <tt>:prefix</tt>  - If +:si+ formats the number using the SI prefix (defaults to :binary)
       # ==== Examples
       #  number_to_human_size(123)                                          # => 123 Bytes
       #  number_to_human_size(1234)                                         # => 1.21 KB
@@ -320,7 +319,7 @@ module ActionView
       # Non-significant zeros after the fractional separator are stripped out by default (set
       # <tt>:strip_insignificant_zeros</tt> to +false+ to change that):
       #  number_to_human_size(1234567890123, :precision => 5)        # => "1.1229 TB"
-      #  number_to_human_size(524288000, :precision=>5)              # => "500 MB"
+      #  number_to_human_size(524288000, :precision => 5)            # => "500 MB"
       def number_to_human_size(number, options = {})
         options.symbolize_keys!
 
@@ -343,15 +342,17 @@ module ActionView
         options[:strip_insignificant_zeros] = true if not options.key?(:strip_insignificant_zeros)
 
         storage_units_format = I18n.translate(:'number.human.storage_units.format', :locale => options[:locale], :raise => true)
+        
+        base = options[:prefix] == :si ? 1000 : 1024
 
-        if number.to_i < 1024
+        if number.to_i < base
           unit = I18n.translate(:'number.human.storage_units.units.byte', :locale => options[:locale], :count => number.to_i, :raise => true)
           storage_units_format.gsub(/%n/, number.to_i.to_s).gsub(/%u/, unit).html_safe
         else
           max_exp  = STORAGE_UNITS.size - 1
-          exponent = (Math.log(number) / Math.log(1024)).to_i # Convert to base 1024
+          exponent = (Math.log(number) / Math.log(base)).to_i # Convert to base
           exponent = max_exp if exponent > max_exp # we need this to avoid overflow for the highest unit
-          number  /= 1024 ** exponent
+          number  /= base ** exponent
 
           unit_key = STORAGE_UNITS[exponent]
           unit = I18n.translate(:"number.human.storage_units.units.#{unit_key}", :locale => options[:locale], :count => number, :raise => true)
@@ -371,7 +372,7 @@ module ActionView
       # See <tt>number_to_human_size</tt> if you want to print a file size.
       #
       # You can also define you own unit-quantifier names if you want to use other decimal units
-      # (eg.: 1500 becomes "1.5 kilometers", 0.150 becomes "150 mililiters", etc). You may define
+      # (eg.: 1500 becomes "1.5 kilometers", 0.150 becomes "150 milliliters", etc). You may define
       # a wide range of unit quantifiers, even fractional ones (centi, deci, mili, etc).
       #
       # ==== Options
@@ -409,7 +410,7 @@ module ActionView
       # Unsignificant zeros after the decimal separator are stripped out by default (set
       # <tt>:strip_insignificant_zeros</tt> to +false+ to change that):
       #  number_to_human(12345012345, :significant_digits => 6)       # => "12.345 Billion"
-      #  number_to_human(500000000, :precision=>5)                    # => "500 Million"
+      #  number_to_human(500000000, :precision => 5)                  # => "500 Million"
       #
       # ==== Custom Unit Quantifiers
       #
@@ -427,13 +428,13 @@ module ActionView
       #     thousand:
       #       one: "kilometer"
       #       other: "kilometers"
-      #     billion: "gazilion-distance"
+      #     billion: "gazillion-distance"
       #
       # Then you could do:
       #
       #  number_to_human(543934, :units => :distance)                              # => "544 kilometers"
       #  number_to_human(54393498, :units => :distance)                            # => "54400 kilometers"
-      #  number_to_human(54393498000, :units => :distance)                         # => "54.4 gazilion-distance"
+      #  number_to_human(54393498000, :units => :distance)                         # => "54.4 gazillion-distance"
       #  number_to_human(343, :units => :distance, :precision => 1)                # => "300 meters"
       #  number_to_human(1, :units => :distance)                                   # => "1 meter"
       #  number_to_human(0.34, :units => :distance)                                # => "34 centimeters"
@@ -459,6 +460,8 @@ module ActionView
         #for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
         options[:strip_insignificant_zeros] = true if not options.key?(:strip_insignificant_zeros)
 
+        inverted_du = DECIMAL_UNITS.invert
+
         units = options.delete :units
         unit_exponents = case units
         when Hash
@@ -469,7 +472,7 @@ module ActionView
           I18n.translate(:"number.human.decimal_units.units", :locale => options[:locale], :raise => true)
         else
           raise ArgumentError, ":units must be a Hash or String translation scope."
-        end.keys.map{|e_name| DECIMAL_UNITS.invert[e_name] }.sort_by{|e| -e}
+        end.keys.map{|e_name| inverted_du[e_name] }.sort_by{|e| -e}
 
         number_exponent = number != 0 ? Math.log10(number.abs).floor : 0
         display_exponent = unit_exponents.find{ |e| number_exponent >= e } || 0

data/lib/action_view/helpers/output_safety_helper.rb

@@ -0,0 +1,38 @@
+require 'active_support/core_ext/string/output_safety'
+
+module ActionView #:nodoc:
+  # = Action View Raw Output Helper
+  module Helpers #:nodoc:
+    module OutputSafetyHelper
+      # This method outputs without escaping a string. Since escaping tags is
+      # now default, this can be used when you don't want Rails to automatically
+      # escape tags. This is not recommended if the data is coming from the user's
+      # input.
+      #
+      # For example:
+      #
+      # <%=raw @user.name %>
+      def raw(stringish)
+        stringish.to_s.html_safe
+      end
+
+      # This method returns a html safe string similar to what <tt>Array#join</tt>
+      # would return. All items in the array, including the supplied separator, are
+      # html escaped unless they are html safe, and the returned string is marked
+      # as html safe.
+      #
+      #   safe_join(["<p>foo</p>".html_safe, "<p>bar</p>"], "<br />")
+      #   # => "<p>foo</p>&lt;br /&gt;&lt;p&gt;bar&lt;/p&gt;"
+      #
+      #   safe_join(["<p>foo</p>".html_safe, "<p>bar</p>".html_safe], "<br />".html_safe)
+      #   # => "<p>foo</p><br /><p>bar</p>"
+      #
+      def safe_join(array, sep=$,)
+        sep ||= "".html_safe
+        sep = ERB::Util.html_escape(sep)
+
+        array.map { |i| ERB::Util.html_escape(i) }.join(sep).html_safe
+      end
+    end
+  end
+end

data/lib/action_view/helpers/record_tag_helper.rb

@@ -10,7 +10,7 @@ module ActionView
       # relate to the specified Active Record object. Usage example:
       #
       #    <%= div_for(@person, :class => "foo") do %>
-      #       <%=h @person.name %>
+      #       <%= @person.name %>
       #    <% end %>
       #
       # produces:
@@ -25,8 +25,8 @@ module ActionView
       # that relate to the specified Active Record object. For example:
       #
       #    <%= content_tag_for(:tr, @person) do %>
-      #      <td><%=h @person.first_name %></td>
-      #      <td><%=h @person.last_name %></td>
+      #      <td><%= @person.first_name %></td>
+      #      <td><%= @person.last_name %></td>
       #    <% end %>
       #
       # would produce the following HTML (assuming @person is an instance of
@@ -52,9 +52,9 @@ module ActionView
       #
       #    <li id="person_123" class="person bar">...
       #
-      def content_tag_for(tag_name, record, *args, &block)
-        prefix  = args.first.is_a?(Hash) ? nil : args.shift
-        options = args.extract_options!
+      def content_tag_for(tag_name, record, prefix = nil, options = nil, &block)
+        options, prefix = prefix, nil if prefix.is_a?(Hash)
+        options ||= {}
         options.merge!({ :class => "#{dom_class(record, prefix)} #{options[:class]}".strip, :id => dom_id(record, prefix) })
         content_tag(tag_name, options, &block)
       end

data/lib/action_view/helpers/rendering_helper.rb

@@ -0,0 +1,90 @@
+module ActionView
+  module Helpers
+    # = Action View Rendering
+    #
+    # Implements methods that allow rendering from a view context.
+    # In order to use this module, all you need is to implement
+    # view_renderer that returns an ActionView::Renderer object.
+    module RenderingHelper
+      # Returns the result of a render that's dictated by the options hash. The primary options are:
+      #
+      # * <tt>:partial</tt> - See ActionView::Partials.
+      # * <tt>:file</tt> - Renders an explicit template file (this used to be the old default), add :locals to pass in those.
+      # * <tt>:inline</tt> - Renders an inline template similar to how it's done in the controller.
+      # * <tt>:text</tt> - Renders the text passed in out.
+      #
+      # If no options hash is passed or :update specified, the default is to render a partial and use the second parameter
+      # as the locals hash.
+      def render(options = {}, locals = {}, &block)
+        case options
+        when Hash
+          if block_given?
+            view_renderer.render_partial(self, options.merge(:partial => options[:layout]), &block)
+          else
+            view_renderer.render(self, options)
+          end
+        else
+          view_renderer.render_partial(self, :partial => options, :locals => locals)
+        end
+      end
+
+      # Overwrites _layout_for in the context object so it supports the case a block is
+      # passed to a partial. Returns the contents that are yielded to a layout, given a
+      # name or a block.
+      #
+      # You can think of a layout as a method that is called with a block. If the user calls
+      # <tt>yield :some_name</tt>, the block, by default, returns <tt>content_for(:some_name)</tt>.
+      # If the user calls simply +yield+, the default block returns <tt>content_for(:layout)</tt>.
+      #
+      # The user can override this default by passing a block to the layout:
+      #
+      #   # The template
+      #   <%= render :layout => "my_layout" do %>
+      #     Content
+      #   <% end %>
+      #
+      #   # The layout
+      #   <html>
+      #     <%= yield %>
+      #   </html>
+      #
+      # In this case, instead of the default block, which would return <tt>content_for(:layout)</tt>,
+      # this method returns the block that was passed in to <tt>render :layout</tt>, and the response
+      # would be
+      #
+      #   <html>
+      #     Content
+      #   </html>
+      #
+      # Finally, the block can take block arguments, which can be passed in by +yield+:
+      #
+      #   # The template
+      #   <%= render :layout => "my_layout" do |customer| %>
+      #     Hello <%= customer.name %>
+      #   <% end %>
+      #
+      #   # The layout
+      #   <html>
+      #     <%= yield Struct.new(:name).new("David") %>
+      #   </html>
+      #
+      # In this case, the layout would receive the block passed into <tt>render :layout</tt>,
+      # and the struct specified would be passed into the block as an argument. The result
+      # would be
+      #
+      #   <html>
+      #     Hello David
+      #   </html>
+      #
+      def _layout_for(*args, &block)
+        name = args.first
+
+        if block && !name.is_a?(Symbol)
+          capture(*args, &block)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/action_view/helpers/sanitize_helper.rb

@@ -81,7 +81,7 @@ module ActionView
       #   strip_tags("<div id='top-bar'>Welcome to my website!</div>")
       #   # => Welcome to my website!
       def strip_tags(html)
-        self.class.full_sanitizer.sanitize(html)
+        self.class.full_sanitizer.sanitize(html).try(:html_safe)
       end
 
       # Strips all link tags from +text+ leaving just the link text.
@@ -94,7 +94,7 @@ module ActionView
       #   # => Please e-mail me at me@email.com.
       #
       #   strip_links('Blog: <a href="http://www.myblog.com/" class="nav" target=\"_blank\">Visit</a>.')
-      #   # => Blog: Visit
+      #   # => Blog: Visit.
       def strip_links(html)
         self.class.link_sanitizer.sanitize(html)
       end

data/lib/action_view/helpers/sprockets_helper.rb

@@ -0,0 +1,69 @@
+require 'uri'
+require 'action_view/helpers/asset_paths'
+
+module ActionView
+  module Helpers
+    module SprocketsHelper
+      def asset_path(source, default_ext = nil)
+        sprockets_asset_paths.compute_public_path(source, 'assets', default_ext, true)
+      end
+
+      def sprockets_javascript_include_tag(source, options = {})
+        options = {
+          'type' => "text/javascript",
+          'src'  => asset_path(source, 'js')
+        }.merge(options.stringify_keys)
+
+        content_tag 'script', "", options
+      end
+
+      def sprockets_stylesheet_link_tag(source, options = {})
+        options = {
+          'rel'   => "stylesheet",
+          'type'  => "text/css",
+          'media' => "screen",
+          'href'  => asset_path(source, 'css')
+        }.merge(options.stringify_keys)
+
+        tag 'link', options
+      end
+
+      private
+
+      def sprockets_asset_paths
+        @sprockets_asset_paths ||= begin
+          config     = self.config if respond_to?(:config)
+          controller = self.controller if respond_to?(:controller)
+          SprocketsHelper::AssetPaths.new(config, controller)
+        end
+      end
+
+      class AssetPaths < ActionView::Helpers::AssetPaths #:nodoc:
+        def rewrite_asset_path(source, dir)
+          if source[0] == ?/
+            source
+          else
+            assets.path(source, performing_caching?, dir)
+          end
+        end
+
+        def rewrite_extension(source, dir, ext)
+          if ext && File.extname(source).empty?
+            "#{source}.#{ext}"
+          else
+            source
+          end
+        end
+
+        def assets
+          Rails.application.assets
+        end
+
+        # When included in Sprockets::Context, we need to ask the top-level config as the controller is not available
+        def performing_caching?
+          @config ?  @config.perform_caching : Rails.application.config.action_controller.perform_caching
+        end
+      end
+    end
+  end
+end

data/lib/action_view/helpers/tag_helper.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/output_safety'
 require 'set'
 
 module ActionView
@@ -7,16 +8,14 @@ module ActionView
     # Provides methods to generate HTML tags programmatically when you can't use
     # a Builder. By default, they output XHTML compliant tags.
     module TagHelper
-      include ERB::Util
-
       extend ActiveSupport::Concern
       include CaptureHelper
 
       BOOLEAN_ATTRIBUTES = %w(disabled readonly multiple checked autobuffer
                            autoplay controls loop selected hidden scoped async
                            defer reversed ismap seemless muted required
-                           autofocus novalidate formnovalidate open).to_set
-      BOOLEAN_ATTRIBUTES.merge(BOOLEAN_ATTRIBUTES.map {|attr| attr.to_sym })
+                           autofocus novalidate formnovalidate open pubdate).to_set
+      BOOLEAN_ATTRIBUTES.merge(BOOLEAN_ATTRIBUTES.map {|attribute| attribute.to_sym })
 
       # Returns an empty HTML tag of type +name+ which by default is XHTML
       # compliant. Set +open+ to true to create an open tag compatible
@@ -25,9 +24,21 @@ module ActionView
       # escaping.
       #
       # ==== Options
-      # The +options+ hash is used with attributes with no value like (<tt>disabled</tt> and
-      # <tt>readonly</tt>), which you can give a value of true in the +options+ hash. You can use
-      # symbols or strings for the attribute names.
+      # You can use symbols or strings for the attribute names.
+      #
+      # Use +true+ with boolean attributes that can render with no value, like
+      # +disabled+ and +readonly+.
+      #
+      # HTML5 <tt>data-*</tt> attributes can be set with a single +data+ key
+      # pointing to a hash of sub-attributes.
+      #
+      # To play nicely with JavaScript conventions sub-attributes are dasherized.
+      # For example, a key +user_id+ would render as <tt>data-user-id</tt> and
+      # thus accessed as <tt>dataset.userId</tt>.
+      #
+      # Values are encoded to JSON, with the exception of strings and symbols.
+      # This may come in handy when using jQuery's HTML5-aware <tt>.data()<tt>
+      # from 1.4.3.
       #
       # ==== Examples
       #   tag("br")
@@ -36,14 +47,17 @@ module ActionView
       #   tag("br", nil, true)
       #   # => <br>
       #
-      #   tag("input", { :type => 'text', :disabled => true })
+      #   tag("input", :type => 'text', :disabled => true)
       #   # => <input type="text" disabled="disabled" />
       #
-      #   tag("img", { :src => "open & shut.png" })
+      #   tag("img", :src => "open & shut.png")
       #   # => <img src="open &amp; shut.png" />
       #
-      #   tag("img", { :src => "open &amp; shut.png" }, false, false)
+      #   tag("img", {:src => "open &amp; shut.png"}, false, false)
       #   # => <img src="open &amp; shut.png" />
+      #
+      #   tag("div", :data => {:name => 'Stephen', :city_state => %w(Chicago IL)})
+      #   # => <div data-name="Stephen" data-city-state="[&quot;Chicago&quot;,&quot;IL&quot;]" />
       def tag(name, options = nil, open = false, escape = true)
         "<#{name}#{tag_options(options, escape) if options}#{open ? ">" : " />"}".html_safe
       end
@@ -118,11 +132,19 @@ module ActionView
           unless options.blank?
             attrs = []
             options.each_pair do |key, value|
-              if BOOLEAN_ATTRIBUTES.include?(key)
+              if key.to_s == 'data' && value.is_a?(Hash)
+                value.each do |k, v|
+                  if !v.is_a?(String) && !v.is_a?(Symbol)
+                    v = v.to_json
+                  end
+                  v = ERB::Util.html_escape(v) if escape
+                  attrs << %(data-#{k.to_s.dasherize}="#{v}")
+                end
+              elsif BOOLEAN_ATTRIBUTES.include?(key)
                 attrs << %(#{key}="#{key}") if value
               elsif !value.nil?
                 final_value = value.is_a?(Array) ? value.join(" ") : value
-                final_value = html_escape(final_value) if escape
+                final_value = ERB::Util.html_escape(final_value) if escape
                 attrs << %(#{key}="#{final_value}")
               end
             end