actionpack 3.0.0.beta → 3.0.0.beta2

data/lib/action_view/helpers/form_tag_helper.rb

@@ -1,6 +1,7 @@
 require 'cgi'
 require 'action_view/helpers/tag_helper'
 require 'active_support/core_ext/object/returning'
+require 'active_support/core_ext/object/blank'
 
 module ActionView
   module Helpers
@@ -10,6 +11,11 @@ module ActionView
     # NOTE: The HTML options <tt>disabled</tt>, <tt>readonly</tt>, and <tt>multiple</tt> can all be treated as booleans. So specifying
     # <tt>:disabled => true</tt> will give <tt>disabled="disabled"</tt>.
     module FormTagHelper
+      extend ActiveSupport::Concern
+
+      include UrlHelper
+      include TextHelper
+
       # 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.
       #
@@ -32,12 +38,12 @@ module ActionView
       #   form_tag('/upload', :multipart => true)
       #   # => <form action="/upload" method="post" enctype="multipart/form-data">
       #
-      #   <% form_tag('/posts')do -%>
+      #   <%= form_tag('/posts')do -%>
       #     <div><%= submit_tag 'Save' %></div>
       #   <% end -%>
       #   # => <form action="/posts" method="post"><div><input type="submit" name="submit" value="Save" /></div></form>
       # 
-      #  <% form_tag('/posts', :remote => true) %>
+      #  <%= form_tag('/posts', :remote => true) %>
       #   # => <form action="/posts" method="post" data-remote="true">
       #   
       def form_tag(url_for_options = {}, options = {}, *parameters_for_url, &block)
@@ -87,12 +93,16 @@ module ActionView
       #   # => <select disabled="disabled" id="destination" name="destination"><option>NYC</option>
       #   #    <option>Paris</option><option>Rome</option></select>
       def select_tag(name, option_tags = nil, options = {})
+        if Array === option_tags
+          ActiveSupport::Deprecation.warn 'Passing an array of option_tags to select_tag implicitly joins them without marking them as HTML-safe. Pass option_tags.join.html_safe instead.', caller
+        end
+
         html_name = (options[:multiple] == true && !name.to_s.ends_with?("[]")) ? "#{name}[]" : name
         if blank = options.delete(:include_blank)
           if blank.kind_of?(String)
-            option_tags = "<option value=\"\">#{blank}</option>" + option_tags
+            option_tags = "<option value=\"\">#{blank}</option>".html_safe + option_tags
           else
-            option_tags = "<option value=\"\"></option>" + option_tags
+            option_tags = "<option value=\"\"></option>".html_safe + option_tags
           end
         end
         content_tag :select, option_tags, { "name" => html_name, "id" => sanitize_to_id(name) }.update(options.stringify_keys)
@@ -279,7 +289,7 @@ module ActionView
         escape = options.key?("escape") ? options.delete("escape") : true
         content = html_escape(content) if escape
 
-        content_tag :textarea, content, { "name" => name, "id" => sanitize_to_id(name) }.update(options)
+        content_tag :textarea, content.html_safe, { "name" => name, "id" => sanitize_to_id(name) }.update(options)
       end
 
       # Creates a check box form input tag.
@@ -425,26 +435,26 @@ module ActionView
       # <tt>options</tt> accept the same values as tag.
       #
       # ==== Examples
-      #   <% field_set_tag do %>
+      #   <%= field_set_tag do %>
       #     <p><%= text_field_tag 'name' %></p>
       #   <% end %>
       #   # => <fieldset><p><input id="name" name="name" type="text" /></p></fieldset>
       #
-      #   <% field_set_tag 'Your details' do %>
+      #   <%= field_set_tag 'Your details' do %>
       #     <p><%= text_field_tag 'name' %></p>
       #   <% end %>
       #   # => <fieldset><legend>Your details</legend><p><input id="name" name="name" type="text" /></p></fieldset>
       #
-      #   <% field_set_tag nil, :class => 'format' do %>
+      #   <%= field_set_tag nil, :class => 'format' do %>
       #     <p><%= text_field_tag 'name' %></p>
       #   <% end %>
       #   # => <fieldset class="format"><p><input id="name" name="name" type="text" /></p></fieldset>
       def field_set_tag(legend = nil, options = nil, &block)
         content = capture(&block)
-        concat(tag(:fieldset, options, true))
-        concat(content_tag(:legend, legend)) unless legend.blank?
-        concat(content)
-        safe_concat("</fieldset>")
+        output = tag(:fieldset, options, true)
+        output.safe_concat(content_tag(:legend, legend)) unless legend.blank?
+        output.concat(content)
+        output.safe_concat("</fieldset>")
       end
 
       private
@@ -477,9 +487,10 @@ module ActionView
 
         def form_tag_in_block(html_options, &block)
           content = capture(&block)
-          concat(form_tag_html(html_options))
-          concat(content)
-          safe_concat("</form>")
+          output = ActiveSupport::SafeBuffer.new
+          output.safe_concat(form_tag_html(html_options))
+          output << content
+          output.safe_concat("</form>")
         end
 
         def token_tag

data/lib/action_view/helpers/javascript_helper.rb

@@ -1,5 +1,4 @@
 require 'action_view/helpers/tag_helper'
-require 'action_view/helpers/prototype_helper'
 
 module ActionView
   module Helpers
@@ -71,7 +70,7 @@ module ActionView
       #
       # Instead of passing the content as an argument, you can also use a block
       # in which case, you pass your +html_options+ as the first parameter.
-      #   <% javascript_tag :defer => 'defer' do -%>
+      #   <%= javascript_tag :defer => 'defer' do -%>
       #     alert('All is good')
       #   <% end -%>
       def javascript_tag(content_or_options_with_block = nil, html_options = {}, &block)
@@ -83,17 +82,98 @@ module ActionView
             content_or_options_with_block
           end
 
-        tag = content_tag(:script, javascript_cdata_section(content), html_options.merge(:type => Mime::JS))
-
-        if block_called_from_erb?(block)
-          concat(tag)
-        else
-          tag
-        end
+        content_tag(:script, javascript_cdata_section(content), html_options.merge(:type => Mime::JS))
       end
 
       def javascript_cdata_section(content) #:nodoc:
-        "\n//#{cdata_section("\n#{content}\n//")}\n"
+        "\n//#{cdata_section("\n#{content}\n//")}\n".html_safe
+      end
+
+      # Returns a button with the given +name+ text that'll trigger a JavaScript +function+ using the
+      # onclick handler.
+      #
+      # The first argument +name+ is used as the button's value or display text.
+      #
+      # The next arguments are optional and may include the javascript function definition and a hash of html_options.
+      #
+      # The +function+ argument can be omitted in favor of an +update_page+
+      # block, which evaluates to a string when the template is rendered
+      # (instead of making an Ajax request first).
+      #
+      # The +html_options+ will accept a hash of html attributes for the link tag. Some examples are :class => "nav_button", :id => "articles_nav_button"
+      #
+      # Note: if you choose to specify the javascript function in a block, but would like to pass html_options, set the +function+ parameter to nil
+      #
+      # Examples:
+      #   button_to_function "Greeting", "alert('Hello world!')"
+      #   button_to_function "Delete", "if (confirm('Really?')) do_delete()"
+      #   button_to_function "Details" do |page|
+      #     page[:details].visual_effect :toggle_slide
+      #   end
+      #   button_to_function "Details", :class => "details_button" do |page|
+      #     page[:details].visual_effect :toggle_slide
+      #   end
+      def button_to_function(name, *args, &block)
+        html_options = args.extract_options!.symbolize_keys
+
+        function = block_given? ? update_page(&block) : args[0] || ''
+        onclick = "#{"#{html_options[:onclick]}; " if html_options[:onclick]}#{function};"
+
+        tag(:input, html_options.merge(:type => 'button', :value => name, :onclick => onclick))
+      end
+
+      # Returns a link of the given +name+ that will trigger a JavaScript +function+ using the
+      # onclick handler and return false after the fact.
+      #
+      # The first argument +name+ is used as the link text.
+      #
+      # The next arguments are optional and may include the javascript function definition and a hash of html_options.
+      #
+      # The +function+ argument can be omitted in favor of an +update_page+
+      # block, which evaluates to a string when the template is rendered
+      # (instead of making an Ajax request first).
+      #
+      # The +html_options+ will accept a hash of html attributes for the link tag. Some examples are :class => "nav_button", :id => "articles_nav_button"
+      #
+      # Note: if you choose to specify the javascript function in a block, but would like to pass html_options, set the +function+ parameter to nil
+      #
+      #
+      # Examples:
+      #   link_to_function "Greeting", "alert('Hello world!')"
+      #     Produces:
+      #       <a onclick="alert('Hello world!'); return false;" href="#">Greeting</a>
+      #
+      #   link_to_function(image_tag("delete"), "if (confirm('Really?')) do_delete()")
+      #     Produces:
+      #       <a onclick="if (confirm('Really?')) do_delete(); return false;" href="#">
+      #         <img src="/images/delete.png?" alt="Delete"/>
+      #       </a>
+      #
+      #   link_to_function("Show me more", nil, :id => "more_link") do |page|
+      #     page[:details].visual_effect  :toggle_blind
+      #     page[:more_link].replace_html "Show me less"
+      #   end
+      #     Produces:
+      #       <a href="#" id="more_link" onclick="try {
+      #         $(&quot;details&quot;).visualEffect(&quot;toggle_blind&quot;);
+      #         $(&quot;more_link&quot;).update(&quot;Show me less&quot;);
+      #       }
+      #       catch (e) {
+      #         alert('RJS error:\n\n' + e.toString());
+      #         alert('$(\&quot;details\&quot;).visualEffect(\&quot;toggle_blind\&quot;);
+      #         \n$(\&quot;more_link\&quot;).update(\&quot;Show me less\&quot;);');
+      #         throw e
+      #       };
+      #       return false;">Show me more</a>
+      #
+      def link_to_function(name, *args, &block)
+        html_options = args.extract_options!.symbolize_keys
+
+        function = block_given? ? update_page(&block) : args[0] || ''
+        onclick = "#{"#{html_options[:onclick]}; " if html_options[:onclick]}#{function}; return false;"
+        href = html_options[:href] || '#'
+
+        content_tag(:a, name, html_options.merge(:href => href, :onclick => onclick))
       end
     end
   end

data/lib/action_view/helpers/number_helper.rb

@@ -1,12 +1,27 @@
 require 'active_support/core_ext/big_decimal/conversions'
 require 'active_support/core_ext/float/rounding'
+require 'active_support/core_ext/object/blank'
 
 module ActionView
   module Helpers #:nodoc:
+
     # Provides methods for converting numbers into formatted strings.
     # Methods are provided for phone numbers, currency, percentage,
-    # precision, positional notation, and file size.
+    # precision, positional notation, file size and pretty printing.
+    #
+    # Most methods expect a +number+ argument, and will return it
+    # unchanged if can't be converted into a valid number.
     module NumberHelper
+
+      # Raised when argument +number+ param given to the helpers is invalid and
+      # the option :raise is set to  +true+.
+      class InvalidNumberError < StandardError
+        attr_accessor :number
+        def initialize(number)
+          @number = number
+        end
+      end
+
       # Formats a +number+ into a US phone number (e.g., (555) 123-9876). You can customize the format
       # in the +options+ hash.
       #
@@ -28,27 +43,36 @@ module ActionView
       #  number_to_phone(1235551234, :country_code => 1, :extension => 1343, :delimiter => ".")
       #  => +1.123.555.1234 x 1343
       def number_to_phone(number, options = {})
-        number       = number.to_s.strip unless number.nil?
+        return nil if number.nil?
+
+        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
+
+        number       = number.to_s.strip
         options      = options.symbolize_keys
         area_code    = options[:area_code] || nil
         delimiter    = options[:delimiter] || "-"
         extension    = options[:extension].to_s.strip || nil
         country_code = options[:country_code] || nil
 
-        begin
-          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")
-          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
-          end
-          str << " x #{extension}" unless extension.blank?
-          str
-        rescue
-          number
+        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")
+        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
         end
+        str << " x #{extension}" unless extension.blank?
+        is_number_html_safe ? str.html_safe : str
       end
 
       # Formats a +number+ into a currency string (e.g., $13.65). You can customize the format
@@ -74,37 +98,42 @@ module ActionView
       #  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?
+
         options.symbolize_keys!
 
-        defaults  = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
-        currency  = I18n.translate(:'number.currency.format', :locale => options[:locale], :raise => true) rescue {}
+        defaults  = I18n.translate(:'number.format', :locale => options[:locale], :default => {})
+        currency  = I18n.translate(:'number.currency.format', :locale => options[:locale], :default => {})
         defaults  = defaults.merge(currency)
 
-        precision = options[:precision] || defaults[:precision]
-        unit      = options[:unit]      || defaults[:unit]
-        separator = options[:separator] || defaults[:separator]
-        delimiter = options[:delimiter] || defaults[:delimiter]
-        format    = options[:format]    || defaults[:format]
-        separator = '' if precision == 0
+        options = options.reverse_merge(defaults)
+
+        unit      = options.delete(:unit)
+        format    = options.delete(:format)
 
         begin
-          format.gsub(/%n/, number_with_precision(number,
-            :precision => precision,
-            :delimiter => delimiter,
-            :separator => separator)
-          ).gsub(/%u/, unit).html_safe
-        rescue
-          number
+          value = number_with_precision(number, options.merge(:raise => true))
+          format.gsub(/%n/, value).gsub(/%u/, unit).html_safe
+        rescue InvalidNumberError => e
+          if options[:raise]
+            raise
+          else
+            formatted_number = format.gsub(/%n/, e.number).gsub(/%u/, unit)
+            e.number.to_s.html_safe? ? formatted_number.html_safe : formatted_number
+          end
         end
+
       end
 
       # Formats a +number+ as a percentage string (e.g., 65%). You can customize the
       # format in the +options+ hash.
       #
       # ==== Options
-      # * <tt>:precision</tt>  - Sets the level of precision (defaults to 3).
-      # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+      # * <tt>:precision</tt>  - Sets the precision of the number (defaults to 3).
+      # * <tt>:significant</tt>  - If +true+, precision will be the # of significant_digits. If +false+, the # of fractional digits (defaults to +false+)
+      # * <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 +false+)
       #
       # ==== Examples
       #  number_to_percentage(100)                                        # => 100.000%
@@ -112,23 +141,24 @@ module ActionView
       #  number_to_percentage(1000, :delimiter => '.', :separator => ',') # => 1.000,000%
       #  number_to_percentage(302.24398923423, :precision => 5)           # => 302.24399%
       def number_to_percentage(number, options = {})
+        return nil if number.nil?
+
         options.symbolize_keys!
 
-        defaults   = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
-        percentage = I18n.translate(:'number.percentage.format', :locale => options[:locale], :raise => true) rescue {}
+        defaults   = I18n.translate(:'number.format', :locale => options[:locale], :default => {})
+        percentage = I18n.translate(:'number.percentage.format', :locale => options[:locale], :default => {})
         defaults  = defaults.merge(percentage)
 
-        precision = options[:precision] || defaults[:precision]
-        separator = options[:separator] || defaults[:separator]
-        delimiter = options[:delimiter] || defaults[:delimiter]
+        options = options.reverse_merge(defaults)
 
         begin
-          number_with_precision(number,
-            :precision => precision,
-            :separator => separator,
-            :delimiter => delimiter) + "%"
-        rescue
-          number
+          "#{number_with_precision(number, options.merge(:raise => true))}%".html_safe
+        rescue InvalidNumberError => e
+          if options[:raise]
+            raise
+          else
+            e.number.to_s.html_safe? ? "#{e.number}%".html_safe : "#{e.number}%"
+          end
         end
       end
 
@@ -137,7 +167,7 @@ module ActionView
       #
       # ==== Options
       # * <tt>:delimiter</tt>  - Sets the thousands delimiter (defaults to ",").
-      # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+      # * <tt>:separator</tt>  - Sets the separator between the fractional and integer digits (defaults to ".").
       #
       # ==== Examples
       #  number_with_delimiter(12345678)                        # => 12,345,678
@@ -150,142 +180,190 @@ module ActionView
       # You can still use <tt>number_with_delimiter</tt> with the old API that accepts the
       # +delimiter+ as its optional second and the +separator+ as its
       # optional third parameter:
-      #  number_with_delimiter(12345678, " ")                     # => 12 345.678
+      #  number_with_delimiter(12345678, " ")                     # => 12 345 678
       #  number_with_delimiter(12345678.05, ".", ",")             # => 12.345.678,05
       def number_with_delimiter(number, *args)
         options = args.extract_options!
         options.symbolize_keys!
 
-        defaults = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
+        begin
+          Float(number)
+        rescue ArgumentError, TypeError
+          if options[:raise]
+            raise InvalidNumberError, number
+          else
+            return number
+          end
+        end
+
+        defaults = I18n.translate(:'number.format', :locale => options[:locale], :default => {})
 
         unless args.empty?
           ActiveSupport::Deprecation.warn('number_with_delimiter takes an option hash ' +
             'instead of separate delimiter and precision arguments.', caller)
-          delimiter = args[0] || defaults[:delimiter]
-          separator = args[1] || defaults[:separator]
+          options[:delimiter] ||= args[0] if args[0]
+          options[:separator] ||= args[1] if args[1]
         end
 
-        delimiter ||= (options[:delimiter] || defaults[:delimiter])
-        separator ||= (options[:separator] || defaults[:separator])
+        options = options.reverse_merge(defaults)
+
+        parts = number.to_s.split('.')
+        parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{options[:delimiter]}")
+        parts.join(options[:separator]).html_safe
 
-        begin
-          parts = number.to_s.split('.')
-          parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
-          parts.join(separator)
-        rescue
-          number
-        end
       end
 
-      # Formats a +number+ with the specified level of <tt>:precision</tt> (e.g., 112.32 has a precision of 2).
+      # Formats a +number+ with the specified level of <tt>:precision</tt> (e.g., 112.32 has a precision
+      # of 2 if +:significant+ is +false+, and 5 if +:significant+ is +true+).
       # You can customize the format in the +options+ hash.
       #
       # ==== Options
-      # * <tt>:precision</tt>  - Sets the level of precision (defaults to 3).
-      # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+      # * <tt>:precision</tt>  - Sets the precision of the number (defaults to 3).
+      # * <tt>:significant</tt>  - If +true+, precision will be the # of significant_digits. If +false+, the # of fractional digits (defaults to +false+)
+      # * <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 +false+)
       #
       # ==== Examples
-      #  number_with_precision(111.2345)                    # => 111.235
-      #  number_with_precision(111.2345, :precision => 2)   # => 111.23
-      #  number_with_precision(13, :precision => 5)         # => 13.00000
-      #  number_with_precision(389.32314, :precision => 0)  # => 389
+      #  number_with_precision(111.2345)                                            # => 111.235
+      #  number_with_precision(111.2345, :precision => 2)                           # => 111.23
+      #  number_with_precision(13, :precision => 5)                                 # => 13.00000
+      #  number_with_precision(389.32314, :precision => 0)                          # => 389
+      #  number_with_precision(111.2345, :significant => true)                      # => 111
+      #  number_with_precision(111.2345, :precision => 1, :significant => true)     # => 100
+      #  number_with_precision(13, :precision => 5, :significant => true)           # => 13.000
+      #  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 => '.')
       #  # => 1.111,23
       #
       # You can still use <tt>number_with_precision</tt> with the old API that accepts the
       # +precision+ as its optional second parameter:
-      #   number_with_precision(number_with_precision(111.2345, 2)   # => 111.23
+      #   number_with_precision(111.2345, 2)   # => 111.23
       def number_with_precision(number, *args)
+
         options = args.extract_options!
         options.symbolize_keys!
 
-        defaults           = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
-        precision_defaults = I18n.translate(:'number.precision.format', :locale => options[:locale],
-                                                                        :raise => true) rescue {}
+        number = begin
+          Float(number)
+        rescue ArgumentError, TypeError
+          if options[:raise]
+            raise InvalidNumberError, number
+          else
+            return number
+          end
+        end
+
+        defaults           = I18n.translate(:'number.format', :locale => options[:locale], :default => {})
+        precision_defaults = I18n.translate(:'number.precision.format', :locale => options[:locale], :default => {})
         defaults           = defaults.merge(precision_defaults)
 
+        #Backwards compatibility
         unless args.empty?
           ActiveSupport::Deprecation.warn('number_with_precision takes an option hash ' +
             'instead of a separate precision argument.', caller)
-          precision = args[0] || defaults[:precision]
+          options[:precision] ||= args[0] if args[0]
         end
 
-        precision ||= (options[:precision] || defaults[:precision])
-        separator ||= (options[:separator] || defaults[:separator])
-        delimiter ||= (options[:delimiter] || defaults[:delimiter])
+        options = options.reverse_merge(defaults)  # Allow the user to unset default values: Eg.: :significant => false
+        precision = options.delete :precision
+        significant = options.delete :significant
+        strip_insignificant_zeros = options.delete :strip_insignificant_zeros
 
-        begin
-          rounded_number = BigDecimal.new((Float(number) * (10 ** precision)).to_s).round.to_f / 10 ** precision
-          number_with_delimiter("%01.#{precision}f" % rounded_number,
-            :separator => separator,
-            :delimiter => delimiter)
-        rescue
-          number
+        if significant and precision > 0
+          if number == 0
+            digits, rounded_number = 1, 0
+          else
+            digits = (Math.log10(number) + 1).floor
+            rounded_number = BigDecimal.new((number / 10 ** (digits - precision)).to_s).round.to_f * 10 ** (digits - precision)
+          end
+          precision = precision - digits
+          precision = precision > 0 ? precision : 0  #don't let it be negative
+        else
+          rounded_number = BigDecimal.new((number * (10 ** precision)).to_s).round.to_f / 10 ** precision
         end
+        formatted_number = number_with_delimiter("%01.#{precision}f" % rounded_number, options)
+        if strip_insignificant_zeros
+          escaped_separator = Regexp.escape(options[:separator])
+          formatted_number.sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '').html_safe
+        else
+          formatted_number
+        end
+
       end
 
       STORAGE_UNITS = [:byte, :kb, :mb, :gb, :tb].freeze
 
-      # Formats the bytes in +size+ into a more understandable representation
+      # Formats the bytes in +number+ into a more understandable representation
       # (e.g., giving it 1500 yields 1.5 KB). This method is useful for
-      # reporting file sizes to users. This method returns nil if
-      # +size+ cannot be converted into a number. You can customize the
+      # reporting file sizes to users. You can customize the
       # format in the +options+ hash.
       #
+      # See <tt>number_to_human</tt> if you want to pretty-print a generic number.
+      #
       # ==== Options
-      # * <tt>:precision</tt>  - Sets the level of precision (defaults to 1).
-      # * <tt>:separator</tt>  - Sets the separator between the units (defaults to ".").
+      # * <tt>:precision</tt>  - Sets the precision of the number (defaults to 3).
+      # * <tt>:significant</tt>  - If +true+, precision will be the # of significant_digits. If +false+, the # of fractional digits (defaults to +true+)
+      # * <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+)
       # ==== Examples
       #  number_to_human_size(123)                                          # => 123 Bytes
-      #  number_to_human_size(1234)                                         # => 1.2 KB
+      #  number_to_human_size(1234)                                         # => 1.21 KB
       #  number_to_human_size(12345)                                        # => 12.1 KB
-      #  number_to_human_size(1234567)                                      # => 1.2 MB
-      #  number_to_human_size(1234567890)                                   # => 1.1 GB
-      #  number_to_human_size(1234567890123)                                # => 1.1 TB
-      #  number_to_human_size(1234567, :precision => 2)                     # => 1.18 MB
-      #  number_to_human_size(483989, :precision => 0)                      # => 473 KB
-      #  number_to_human_size(1234567, :precision => 2, :separator => ',')  # => 1,18 MB
+      #  number_to_human_size(1234567)                                      # => 1.18 MB
+      #  number_to_human_size(1234567890)                                   # => 1.15 GB
+      #  number_to_human_size(1234567890123)                                # => 1.12 TB
+      #  number_to_human_size(1234567, :precision => 2)                     # => 1.2 MB
+      #  number_to_human_size(483989, :precision => 2)                      # => 470 KB
+      #  number_to_human_size(1234567, :precision => 2, :separator => ',')  # => 1,2 MB
       #
-      # Zeros after the decimal point are always stripped out, regardless of the
-      # specified precision:
-      #  helper.number_to_human_size(1234567890123, :precision => 5)        # => "1.12283 TB"
-      #  helper.number_to_human_size(524288000, :precision=>5)              # => "500 MB"
+      # Unsignificant 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"
       #
       # You can still use <tt>number_to_human_size</tt> with the old API that accepts the
       # +precision+ as its optional second parameter:
-      #  number_to_human_size(1234567, 2)    # => 1.18 MB
-      #  number_to_human_size(483989, 0)     # => 473 KB
+      #  number_to_human_size(1234567, 1)    # => 1 MB
+      #  number_to_human_size(483989, 2)     # => 470 KB
       def number_to_human_size(number, *args)
-        return nil if number.nil?
-
         options = args.extract_options!
         options.symbolize_keys!
 
-        defaults = I18n.translate(:'number.format', :locale => options[:locale], :raise => true) rescue {}
-        human    = I18n.translate(:'number.human.format', :locale => options[:locale], :raise => true) rescue {}
+        number = begin
+          Float(number)
+        rescue ArgumentError, TypeError
+          if options[:raise]
+            raise InvalidNumberError, number
+          else
+            return number
+          end
+        end
+
+        defaults = I18n.translate(:'number.format', :locale => options[:locale], :default => {})
+        human    = I18n.translate(:'number.human.format', :locale => options[:locale], :default => {})
         defaults = defaults.merge(human)
 
         unless args.empty?
           ActiveSupport::Deprecation.warn('number_to_human_size takes an option hash ' +
             'instead of a separate precision argument.', caller)
-          precision = args[0] || defaults[:precision]
+          options[:precision] ||= args[0] if args[0]
         end
 
-        precision ||= (options[:precision] || defaults[:precision])
-        separator ||= (options[:separator] || defaults[:separator])
-        delimiter ||= (options[:delimiter] || defaults[:delimiter])
+        options = options.reverse_merge(defaults)
+        #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)
 
         storage_units_format = I18n.translate(:'number.human.storage_units.format', :locale => options[:locale], :raise => true)
 
         if number.to_i < 1024
           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)
+          storage_units_format.gsub(/%n/, number.to_i.to_s).gsub(/%u/, unit).html_safe
         else
           max_exp  = STORAGE_UNITS.size - 1
-          number   = Float(number)
           exponent = (Math.log(number) / Math.log(1024)).to_i # Convert to base 1024
           exponent = max_exp if exponent > max_exp # we need this to avoid overflow for the highest unit
           number  /= 1024 ** exponent
@@ -293,19 +371,138 @@ module ActionView
           unit_key = STORAGE_UNITS[exponent]
           unit = I18n.translate(:"number.human.storage_units.units.#{unit_key}", :locale => options[:locale], :count => number, :raise => true)
 
-          begin
-            escaped_separator = Regexp.escape(separator)
-            formatted_number = number_with_precision(number,
-              :precision => precision,
-              :separator => separator,
-              :delimiter => delimiter
-            ).sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
-            storage_units_format.gsub(/%n/, formatted_number).gsub(/%u/, unit)
-          rescue
-            number
+          formatted_number = number_with_precision(number, options)
+          storage_units_format.gsub(/%n/, formatted_number).gsub(/%u/, unit).html_safe
+        end
+      end
+
+      DECIMAL_UNITS = {0 => :unit, 1 => :ten, 2 => :hundred, 3 => :thousand, 6 => :million, 9 => :billion, 12 => :trillion, 15 => :quadrillion,
+        -1 => :deci, -2 => :centi, -3 => :mili, -6 => :micro, -9 => :nano, -12 => :pico, -15 => :femto}.freeze
+
+      # Pretty prints (formats and approximates) a number in a way it is more readable by humans
+      # (eg.: 1200000000 becomes "1.2 Billion"). This is useful for numbers that
+      # can get very large (and too hard to read).
+      #
+      # 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
+      # a wide range of unit quantifiers, even fractional ones (centi, deci, mili, etc).
+      #
+      # ==== Options
+      # * <tt>:precision</tt>  - Sets the precision of the number (defaults to 3).
+      # * <tt>:significant</tt>  - If +true+, precision will be the # of significant_digits. If +false+, the # of fractional digits (defaults to +true+)
+      # * <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>:units</tt> - A Hash of unit quantifier names. Or a string containing an i18n scope where to find this hash. It might have the following keys:
+      #   * *integers*: <tt>:unit</tt>, <tt>:ten</tt>, <tt>:hundred</tt>, <tt>:thousand</tt>,  <tt>:million</tt>,  <tt>:billion</tt>, <tt>:trillion</tt>, <tt>:quadrillion</tt>
+      #   * *fractionals*: <tt>:deci</tt>, <tt>:centi</tt>, <tt>:mili</tt>, <tt>:micro</tt>, <tt>:nano</tt>, <tt>:pico</tt>, <tt>:femto</tt>
+      # * <tt>:format</tt> - Sets the format of the output string (defaults to "%n %u"). The field types are:
+      #
+      #     %u  The quantifier (ex.: 'thousand')
+      #     %n  The number
+      #
+      # ==== Examples
+      #  number_to_human(123)                                          # => "123"
+      #  number_to_human(1234)                                         # => "1.23 Thousand"
+      #  number_to_human(12345)                                        # => "12.3 Thousand"
+      #  number_to_human(1234567)                                      # => "1.23 Million"
+      #  number_to_human(1234567890)                                   # => "1.23 Billion"
+      #  number_to_human(1234567890123)                                # => "1.23 Trillion"
+      #  number_to_human(1234567890123456)                             # => "1.23 Quadrillion"
+      #  number_to_human(1234567890123456789)                          # => "1230 Quadrillion"
+      #  number_to_human(489939, :precision => 2)                      # => "490 Thousand"
+      #  number_to_human(489939, :precision => 4)                      # => "489.9 Thousand"
+      #  number_to_human(1234567, :precision => 4,
+      #                           :significant => false)               # => "1.2346 Million"
+      #  number_to_human(1234567, :precision => 1,
+      #                           :separator => ',',
+      #                           :significant => false)               # => "1,2 Million"
+      #
+      # 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"
+      #
+      # ==== Custom Unit Quantifiers
+      #
+      # You can also use your own custom unit quantifiers:
+      #  number_to_human(500000, :units => {:unit => "ml", :thousand => "lt"})  # => "500 lt"
+      #
+      # If in your I18n locale you have:
+      #   distance:
+      #     centi:
+      #       one: "centimeter"
+      #       other: "centimeters"
+      #     unit:
+      #       one: "meter"
+      #       other: "meters"
+      #     thousand:
+      #       one: "kilometer"
+      #       other: "kilometers"
+      #     billion: "gazilion-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(343, :units => :distance, :precision => 1)                # => "300 meters"
+      #  number_to_human(1, :units => :distance)                                   # => "1 meter"
+      #  number_to_human(0.34, :units => :distance)                                # => "34 centimeters"
+      #
+      def number_to_human(number, options = {})
+        options.symbolize_keys!
+
+        number = begin
+          Float(number)
+        rescue ArgumentError, TypeError
+          if options[:raise]
+            raise InvalidNumberError, number
+          else
+            return number
           end
         end
+
+        defaults = I18n.translate(:'number.format', :locale => options[:locale], :default => {})
+        human    = I18n.translate(:'number.human.format', :locale => options[:locale], :default => {})
+        defaults = defaults.merge(human)
+
+        options = options.reverse_merge(defaults)
+        #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)
+
+        units = options.delete :units
+        unit_exponents = case units
+        when Hash
+          units
+        when String, Symbol
+          I18n.translate(:"#{units}", :locale => options[:locale], :raise => true)
+        when nil
+          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}
+
+        number_exponent = Math.log10(number).floor
+        display_exponent = unit_exponents.find{|e| number_exponent >= e }
+        number  /= 10 ** display_exponent
+
+        unit = case units
+        when Hash
+          units[DECIMAL_UNITS[display_exponent]]
+        when String, Symbol
+          I18n.translate(:"#{units}.#{DECIMAL_UNITS[display_exponent]}", :locale => options[:locale], :count => number.to_i)
+        else
+          I18n.translate(:"number.human.decimal_units.units.#{DECIMAL_UNITS[display_exponent]}", :locale => options[:locale], :count => number.to_i)
+        end
+
+        decimal_format = options[:format] || I18n.translate(:'number.human.decimal_units.format', :locale => options[:locale], :default => "%n %u")
+        formatted_number = number_with_precision(number, options)
+        decimal_format.gsub(/%n/, formatted_number).gsub(/%u/, unit).strip.html_safe
       end
+
     end
   end
 end