Moving NumberHelpers from ActionView to ActiveSupport

3 files changed, 49 insertions, 285 deletions

diff --git a/actionpack/lib/action_view/helpers/number_helper.rb b/actionpack/lib/action_view/helpers/number_helper.rb
index dfc26acfad..b743f5e0c9 100644
--- a/actionpack/lib/action_view/helpers/number_helper.rb
+++ b/actionpack/lib/action_view/helpers/number_helper.rb
@@ -2,12 +2,16 @@
 
 require 'active_support/core_ext/big_decimal/conversions'
 require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/numeric'
 require 'active_support/core_ext/string/output_safety'
+require 'active_support/number_helper'
+require 'erb'
 
 module ActionView
   # = Action View Number Helpers
   module Helpers #:nodoc:
 
+
     # Provides methods for converting numbers into formatted strings.
     # Methods are provided for phone numbers, currency, percentage,
     # precision, positional notation, file size and pretty printing.
@@ -16,9 +20,6 @@ module ActionView
     # unchanged if can't be converted into a valid number.
     module NumberHelper
 
-      DEFAULT_CURRENCY_VALUES = { :format => "%u%n", :negative_format => "-%u%n", :unit => "$", :separator => ".", :delimiter => ",",
-                                  :precision => 2, :significant => false, :strip_insignificant_zeros => false }
-
       # Raised when argument +number+ param given to the helpers is invalid and
       # the option :raise is set to  +true+.
       class InvalidNumberError < StandardError
@@ -63,25 +64,7 @@ module ActionView
         options = options.symbolize_keys
 
         parse_float(number, true) if options[:raise]
-
-        number       = number.to_s.strip
-        area_code    = options[:area_code]
-        delimiter    = options[:delimiter] || "-"
-        extension    = options[:extension]
-        country_code = options[:country_code]
-
-        if area_code
-          number.gsub!(/(\d{1,3})(\d{3})(\d{4}$)/,"(\\1) \\2#{delimiter}\\3")
-        else
-          number.gsub!(/(\d{0,3})(\d{3})(\d{4})$/,"\\1#{delimiter}\\2#{delimiter}\\3")
-          number.slice!(0, 1) if number.start_with?(delimiter) && !delimiter.blank?
-        end
-
-        str = ''
-        str << "+#{country_code}#{delimiter}" unless country_code.blank?
-        str << number
-        str << " x #{extension}" unless extension.blank?
-        ERB::Util.html_escape(str)
+        ERB::Util.html_escape(ActiveSupport::NumberHelper.number_to_phone(number, options))
       end
 
       # Formats a +number+ into a currency string (e.g., $13.65). You
@@ -128,34 +111,9 @@ module ActionView
       #  # => 1234567890,50 &pound;
       def number_to_currency(number, options = {})
         return unless number
-        options = options.symbolize_keys
-
-        currency = translations_for('currency', options[:locale])
-        currency[:negative_format] ||= "-" + currency[:format] if currency[:format]
-
-        defaults  = DEFAULT_CURRENCY_VALUES.merge(defaults_translations(options[:locale])).merge!(currency)
-        defaults[:negative_format] = "-" + options[:format] if options[:format]
-        options   = defaults.merge!(options)
-
-        unit      = options.delete(:unit)
-        format    = options.delete(:format)
-
-        if number.to_f < 0
-          format = options.delete(:negative_format)
-          number = number.respond_to?("abs") ? number.abs : number.sub(/^-/, '')
-        end
-
-        begin
-          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
+        options = escape_unsafe_delimiters_and_separators(options.symbolize_keys)
+        
+        wrap_with_output_safety_handling(number, options[:raise]){ ActiveSupport::NumberHelper.number_to_currency(number, options) }
       end
 
       # Formats a +number+ as a percentage string (e.g., 65%). You can
@@ -196,24 +154,9 @@ module ActionView
       #  number_to_percentage("98a", :raise => true)                      # => InvalidNumberError
       def number_to_percentage(number, options = {})
         return unless number
-        options = options.symbolize_keys
-
-        defaults = format_translations('percentage', options[:locale])
-        options  = defaults.merge!(options)
-
-        format = options[:format] || "%n%"
-
-        begin
-          value = number_with_precision(number, options.merge(:raise => true))
-          format.gsub(/%n/, value).html_safe
-        rescue InvalidNumberError => e
-          if options[:raise]
-            raise
-          else
-            formatted_number = format.gsub(/%n/, e.number)
-            e.number.to_s.html_safe? ? formatted_number.html_safe : formatted_number
-          end
-        end
+        options = escape_unsafe_delimiters_and_separators(options.symbolize_keys)
+        
+        wrap_with_output_safety_handling(number, options[:raise]){ ActiveSupport::NumberHelper.number_to_percentage(number, options) }
       end
 
       # Formats a +number+ with grouped thousands using +delimiter+
@@ -246,15 +189,9 @@ module ActionView
       #
       #  number_with_delimiter("112a", :raise => true)          # => raise InvalidNumberError
       def number_with_delimiter(number, options = {})
-        options = options.symbolize_keys
-
-        parse_float(number, options[:raise]) or return number
-
-        options = defaults_translations(options[:locale]).merge(options)
+        options = escape_unsafe_delimiters_and_separators(options.symbolize_keys)
 
-        parts = number.to_s.to_str.split('.')
-        parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{options[:delimiter]}")
-        safe_join(parts, options[:separator])
+        wrap_with_output_safety_handling(number, options[:raise]){ ActiveSupport::NumberHelper.number_to_delimited(number, options) }
       end
 
       # Formats a +number+ with the specified level of
@@ -299,41 +236,11 @@ module ActionView
       #  number_with_precision(1111.2345, :precision => 2, :separator => ',', :delimiter => '.')
       #  # => 1.111,23
       def number_with_precision(number, options = {})
-        options = options.symbolize_keys
-
-        number = (parse_float(number, options[:raise]) or return number)
-
-        defaults = format_translations('precision', options[:locale])
-        options  = defaults.merge!(options)
-
-        precision = options.delete :precision
-        significant = options.delete :significant
-        strip_insignificant_zeros = options.delete :strip_insignificant_zeros
+        options = escape_unsafe_delimiters_and_separators(options.symbolize_keys)
 
-        if significant and precision > 0
-          if number == 0
-            digits, rounded_number = 1, 0
-          else
-            digits = (Math.log10(number.abs) + 1).floor
-            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 -= digits
-          precision = precision > 0 ? precision : 0  #don't let it be negative
-        else
-          rounded_number = BigDecimal.new(number.to_s).round(precision).to_f
-          rounded_number = rounded_number.zero? ? rounded_number.abs : rounded_number #prevent showing negative zeros
-        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
+        wrap_with_output_safety_handling(number, options[:raise]){ ActiveSupport::NumberHelper.number_to_rounded(number, options) }
       end
 
-      STORAGE_UNITS = [:byte, :kb, :mb, :gb, :tb].freeze
 
       # Formats the bytes in +number+ into a more understandable
       # representation (e.g., giving it 1500 yields 1.5 KB). This
@@ -383,40 +290,11 @@ module ActionView
       #  number_to_human_size(1234567890123, :precision => 5)        # => "1.1229 TB"
       #  number_to_human_size(524288000, :precision => 5)            # => "500 MB"
       def number_to_human_size(number, options = {})
-        options = options.symbolize_keys
-
-        number = (parse_float(number, options[:raise]) or return number)
-
-        defaults = format_translations('human', options[:locale])
-        options  = defaults.merge!(options)
-
-        #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)
-
-        base = options[:prefix] == :si ? 1000 : 1024
+        options = escape_unsafe_delimiters_and_separators(options.symbolize_keys)
 
-        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(base)).to_i # Convert to base
-          exponent = max_exp if exponent > max_exp # we need this to avoid overflow for the highest unit
-          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)
-
-          formatted_number = number_with_precision(number, options)
-          storage_units_format.gsub(/%n/, formatted_number).gsub(/%u/, unit).html_safe
-        end
+        wrap_with_output_safety_handling(number, options[:raise]){ ActiveSupport::NumberHelper.number_to_human_size(number, options) }
       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
@@ -516,60 +394,33 @@ module ActionView
       #  number_to_human(0.34, :units => :distance)                                # => "34 centimeters"
       #
       def number_to_human(number, options = {})
-        options = options.symbolize_keys
-
-        number = (parse_float(number, options[:raise]) or return number)
+        options = escape_unsafe_delimiters_and_separators(options.symbolize_keys)
 
-        defaults = format_translations('human', options[:locale])
-        options  = defaults.merge!(options)
-
-        #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
-          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| 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
-        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
+        wrap_with_output_safety_handling(number, options[:raise]){ ActiveSupport::NumberHelper.number_to_human(number, options) }
       end
 
       private
-
-      def format_translations(namespace, locale)
-        defaults_translations(locale).merge(translations_for(namespace, locale))
+      
+      def escape_unsafe_delimiters_and_separators(options)
+        options[:separator] = ERB::Util.html_escape(options[:separator]) if options[:separator] && !options[:separator].html_safe?
+        options[:delimiter] = ERB::Util.html_escape(options[:delimiter]) if options[:delimiter] && !options[:delimiter].html_safe?
+        options
       end
-
-      def defaults_translations(locale)
-        I18n.translate(:'number.format', :locale => locale, :default => {})
+      
+      def wrap_with_output_safety_handling(number, raise_on_invalid, &block)
+        raise InvalidNumberError, number if raise_on_invalid && !valid_float?(number)
+        
+        formatted_number = yield
+        
+        if valid_float?(number) || number.html_safe?
+          formatted_number.html_safe
+        else
+          formatted_number
+        end        
       end
-
-      def translations_for(namespace, locale)
-        I18n.translate(:"number.#{namespace}.format", :locale => locale, :default => {})
+      
+      def valid_float?(number)
+        !parse_float(number, false).nil?
       end
 
       def parse_float(number, raise_error)
diff --git a/actionpack/lib/action_view/locale/en.yml b/actionpack/lib/action_view/locale/en.yml
index 8e9db634fb..8a56f147b8 100644
--- a/actionpack/lib/action_view/locale/en.yml
+++ b/actionpack/lib/action_view/locale/en.yml
@@ -1,102 +1,4 @@
 "en":
-  number:
-    # Used in number_with_delimiter()
-    # These are also the defaults for 'currency', 'percentage', 'precision', and 'human'
-    format:
-      # Sets the separator between the units, for more precision (e.g. 1.0 / 2.0 == 0.5)
-      separator: "."
-      # Delimits thousands (e.g. 1,000,000 is a million) (always in groups of three)
-      delimiter: ","
-      # Number of decimals, behind the separator (the number 1 with a precision of 2 gives: 1.00)
-      precision: 3
-      # If set to true, precision will mean the number of significant digits instead
-      # of the number of decimal digits (1234 with precision 2 becomes 1200, 1.23543 becomes 1.2)
-      significant: false
-      # If set, the zeros after the decimal separator will always be stripped (eg.: 1.200 will be 1.2)
-      strip_insignificant_zeros: false
-
-    # Used in number_to_currency()
-    currency:
-      format:
-        # Where is the currency sign? %u is the currency unit, %n the number (default: $5.00)
-        format: "%u%n"
-        unit: "$"
-        # These five are to override number.format and are optional
-        separator: "."
-        delimiter: ","
-        precision: 2
-        significant: false
-        strip_insignificant_zeros: false
-
-    # Used in number_to_percentage()
-    percentage:
-      format:
-        # These five are to override number.format and are optional
-        # separator:
-        delimiter: ""
-        # precision:
-        # significant: false
-        # strip_insignificant_zeros: false
-        format: "%n%"
-
-    # Used in number_to_precision()
-    precision:
-      format:
-        # These five are to override number.format and are optional
-        # separator:
-        delimiter: ""
-        # precision:
-        # significant: false
-        # strip_insignificant_zeros: false
-
-    # Used in number_to_human_size() and number_to_human()
-    human:
-      format:
-        # These five are to override number.format and are optional
-        # separator:
-        delimiter: ""
-        precision: 3
-        significant: true
-        strip_insignificant_zeros: true
-      # Used in number_to_human_size()
-      storage_units:
-        # Storage units output formatting.
-        # %u is the storage unit, %n is the number (default: 2 MB)
-        format: "%n %u"
-        units:
-          byte:
-            one:   "Byte"
-            other: "Bytes"
-          kb: "KB"
-          mb: "MB"
-          gb: "GB"
-          tb: "TB"
-      # Used in number_to_human()
-      decimal_units:
-        format: "%n %u"
-        # Decimal units output formatting
-        # By default we will only quantify some of the exponents
-        # but the commented ones might be defined or overridden
-        # by the user.
-        units:
-          # femto: Quadrillionth
-          # pico: Trillionth
-          # nano: Billionth
-          # micro: Millionth
-          # mili: Thousandth
-          # centi: Hundredth
-          # deci: Tenth
-          unit: ""
-          # ten:
-          #   one: Ten
-          #   other: Tens
-          # hundred: Hundred
-          thousand: Thousand
-          million: Million
-          billion: Billion
-          trillion: Trillion
-          quadrillion: Quadrillion
-
   # Used in distance_of_time_in_words(), distance_of_time_in_words_to_now(), time_ago_in_words()
   datetime:
     distance_in_words:
diff --git a/actionpack/test/template/number_helper_test.rb b/actionpack/test/template/number_helper_test.rb
index 14ca6d9879..057cb47f53 100644
--- a/actionpack/test/template/number_helper_test.rb
+++ b/actionpack/test/template/number_helper_test.rb
@@ -33,6 +33,7 @@ class NumberHelperTest < ActionView::TestCase
     assert_equal("+18005551212", number_to_phone(8005551212, :country_code => 1, :delimiter => ''))
     assert_equal("22-555-1212", number_to_phone(225551212))
     assert_equal("+45-22-555-1212", number_to_phone(225551212, :country_code => 45))
+    assert_equal '111&lt;script&gt;&lt;/script&gt;111&lt;script&gt;&lt;/script&gt;1111', number_to_phone(1111111111, :delimiter => "<script></script>")
   end
 
   def test_number_to_currency
@@ -47,6 +48,8 @@ class NumberHelperTest < ActionView::TestCase
     assert_equal("$1,234,567,890.50", number_to_currency("1234567890.50"))
     assert_equal("1,234,567,890.50 K&#269;", number_to_currency("1234567890.50", {:unit => "K&#269;", :format => "%n %u"}))
     assert_equal("1,234,567,890.50 - K&#269;", number_to_currency("-1234567890.50", {:unit => "K&#269;", :format => "%n %u", :negative_format => "%n - %u"}))
+    assert_equal '$1&lt;script&gt;&lt;/script&gt;01', number_to_currency(1.01, :separator => "<script></script>")
+    assert_equal '$1&lt;script&gt;&lt;/script&gt;000.00', number_to_currency(1000, :delimiter => "<script></script>")
   end
 
   def test_number_to_percentage
@@ -58,6 +61,8 @@ class NumberHelperTest < ActionView::TestCase
     assert_equal("123.4%", number_to_percentage(123.400, :precision => 3, :strip_insignificant_zeros => true))
     assert_equal("1.000,000%", number_to_percentage(1000, :delimiter => '.', :separator => ','))
     assert_equal("1000.000  %", number_to_percentage(1000, :format => "%n  %"))
+    assert_equal '1&lt;script&gt;&lt;/script&gt;010%', number_to_percentage(1.01, :separator => "<script></script>")
+    assert_equal '1&lt;script&gt;&lt;/script&gt;000.000%', number_to_percentage(1000, :delimiter => "<script></script>")
   end
 
   def test_number_with_delimiter
@@ -104,6 +109,8 @@ class NumberHelperTest < ActionView::TestCase
   def test_number_with_precision_with_custom_delimiter_and_separator
     assert_equal '31,83',       number_with_precision(31.825, :precision => 2, :separator => ',')
     assert_equal '1.231,83',    number_with_precision(1231.825, :precision => 2, :separator => ',', :delimiter => '.')
+    assert_equal '1&lt;script&gt;&lt;/script&gt;010', number_with_precision(1.01, :separator => "<script></script>")
+    assert_equal '1&lt;script&gt;&lt;/script&gt;000.000', number_with_precision(1000, :delimiter => "<script></script>")
   end
 
   def test_number_with_precision_with_significant_digits
@@ -193,6 +200,7 @@ class NumberHelperTest < ActionView::TestCase
     assert_equal '1.0 KB',   number_to_human_size(kilobytes(1.0123), :precision => 2, :strip_insignificant_zeros => false)
     assert_equal '1.012 KB',   number_to_human_size(kilobytes(1.0123), :precision => 3, :significant => false)
     assert_equal '1 KB',   number_to_human_size(kilobytes(1.0123), :precision => 0, :significant => true) #ignores significant it precision is 0
+    assert_equal '9&lt;script&gt;&lt;/script&gt;86 KB', number_to_human_size(10100, :separator => "<script></script>")
   end
 
   def test_number_to_human_size_with_custom_delimiter_and_separator
@@ -253,6 +261,9 @@ class NumberHelperTest < ActionView::TestCase
     #Spaces are stripped from the resulting string
     assert_equal '4', number_to_human(4, :units => {:unit => "", :ten => 'tens '})
     assert_equal '4.5  tens', number_to_human(45, :units => {:unit => "", :ten => ' tens   '})
+
+    assert_equal '1&lt;script&gt;&lt;/script&gt;01', number_to_human(1.01, :separator => "<script></script>")
+    assert_equal '100&lt;script&gt;&lt;/script&gt;000 Quadrillion', number_to_human(10**20, :delimiter => "<script></script>")
   end
 
   def test_number_to_human_with_custom_format