activesupport 4.2.11.1 → 5.2.8.1

data/lib/active_support/number_helper/number_converter.rb

@@ -1,8 +1,10 @@
-require 'active_support/core_ext/big_decimal/conversions'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/hash/keys'
-require 'active_support/i18n'
-require 'active_support/core_ext/class/attribute'
+# frozen_string_literal: true
+
+require "active_support/core_ext/big_decimal/conversions"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/hash/keys"
+require "active_support/i18n"
+require "active_support/core_ext/class/attribute"
 
 module ActiveSupport
   module NumberHelper
@@ -139,17 +141,17 @@ module ActiveSupport
           @options ||= format_options.merge(opts)
         end
 
-        def format_options #:nodoc:
+        def format_options
           default_format_options.merge!(i18n_format_options)
         end
 
-        def default_format_options #:nodoc:
+        def default_format_options
           options = DEFAULTS[:format].dup
           options.merge!(DEFAULTS[namespace][:format]) if namespace
           options
         end
 
-        def i18n_format_options #:nodoc:
+        def i18n_format_options
           locale = opts[:locale]
           options = I18n.translate(:'number.format', locale: locale, default: {}).dup
 
@@ -160,7 +162,7 @@ module ActiveSupport
           options
         end
 
-        def translate_number_value_with_default(key, i18n_options = {}) #:nodoc:
+        def translate_number_value_with_default(key, i18n_options = {})
           I18n.translate(key, { default: default_value(key), scope: :number }.merge!(i18n_options))
         end
 
@@ -169,10 +171,10 @@ module ActiveSupport
         end
 
         def default_value(key)
-          key.split('.').reduce(DEFAULTS) { |defaults, k| defaults[k.to_sym] }
+          key.split(".").reduce(DEFAULTS) { |defaults, k| defaults[k.to_sym] }
         end
 
-        def valid_float? #:nodoc:
+        def valid_float?
           Float(number)
         rescue ArgumentError, TypeError
           false

data/lib/active_support/number_helper/number_to_currency_converter.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/numeric/inquiry"
+
 module ActiveSupport
   module NumberHelper
     class NumberToCurrencyConverter < NumberConverter # :nodoc:
@@ -7,36 +11,32 @@ module ActiveSupport
         number = self.number.to_s.strip
         format = options[:format]
 
-        if is_negative?(number)
+        if number.to_f.negative?
           format = options[:negative_format]
           number = absolute_value(number)
         end
 
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        format.gsub(/%n/, rounded_number).gsub(/%u/, options[:unit])
+        format.gsub("%n".freeze, rounded_number).gsub("%u".freeze, options[:unit])
       end
 
       private
 
-        def is_negative?(number)
-          number.to_f.phase != 0
-        end
-
         def absolute_value(number)
-          number.respond_to?("abs") ? number.abs : number.sub(/\A-/, '')
+          number.respond_to?(:abs) ? number.abs : number.sub(/\A-/, "")
         end
 
         def options
           @options ||= begin
             defaults = default_format_options.merge(i18n_opts)
-            # Override negative format if format options is given
+            # Override negative format if format options are given
             defaults[:negative_format] = "-#{opts[:format]}" if opts[:format]
             defaults.merge!(opts)
           end
         end
 
         def i18n_opts
-          # Set International negative format if not exists
+          # Set International negative format if it does not exist
           i18n = i18n_format_options
           i18n[:negative_format] ||= "-#{i18n[:format]}" if i18n[:format]
           i18n

data/lib/active_support/number_helper/number_to_delimited_converter.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module NumberHelper
     class NumberToDelimitedConverter < NumberConverter #:nodoc:
       self.validate_float = true
 
-      DELIMITED_REGEX = /(\d)(?=(\d\d\d)+(?!\d))/
+      DEFAULT_DELIMITER_REGEX = /(\d)(?=(\d\d\d)+(?!\d))/
 
       def convert
         parts.join(options[:separator])
@@ -12,12 +14,16 @@ module ActiveSupport
       private
 
         def parts
-          left, right = number.to_s.split('.')
-          left.gsub!(DELIMITED_REGEX) do |digit_to_delimit|
+          left, right = number.to_s.split(".".freeze)
+          left.gsub!(delimiter_pattern) do |digit_to_delimit|
             "#{digit_to_delimit}#{options[:delimiter]}"
           end
           [left, right].compact
         end
+
+        def delimiter_pattern
+          options.fetch(:delimiter_pattern, DEFAULT_DELIMITER_REGEX)
+        end
     end
   end
 end

data/lib/active_support/number_helper/number_to_human_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module NumberHelper
     class NumberToHumanConverter < NumberConverter # :nodoc:
@@ -9,6 +11,7 @@ module ActiveSupport
       self.validate_float = true
 
       def convert # :nodoc:
+        @number = RoundingHelper.new(options).round(number)
         @number = Float(number)
 
         # for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
@@ -18,27 +21,26 @@ module ActiveSupport
 
         units = opts[:units]
         exponent = calculate_exponent(units)
-        @number = number / (10 ** exponent)
-
-        unit = determine_unit(units, exponent)
+        @number = number / (10**exponent)
 
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        format.gsub(/%n/, rounded_number).gsub(/%u/, unit).strip
+        unit = determine_unit(units, exponent)
+        format.gsub("%n".freeze, rounded_number).gsub("%u".freeze, unit).strip
       end
 
       private
 
         def format
-          options[:format] || translate_in_locale('human.decimal_units.format')
+          options[:format] || translate_in_locale("human.decimal_units.format")
         end
 
         def determine_unit(units, exponent)
           exp = DECIMAL_UNITS[exponent]
           case units
           when Hash
-            units[exp] || ''
+            units[exp] || ""
           when String, Symbol
-            I18n.translate("#{units}.#{exp}", :locale => options[:locale], :count => number.to_i)
+            I18n.translate("#{units}.#{exp}", locale: options[:locale], count: number.to_i)
           else
             translate_in_locale("human.decimal_units.units.#{exp}", count: number.to_i)
           end
@@ -54,12 +56,12 @@ module ActiveSupport
           when Hash
             units
           when String, Symbol
-            I18n.translate(units.to_s, :locale => options[:locale], :raise => true)
+            I18n.translate(units.to_s, locale: options[:locale], raise: true)
           when nil
             translate_in_locale("human.decimal_units.units", raise: true)
           else
             raise ArgumentError, ":units must be a Hash or String translation scope."
-          end.keys.map { |e_name| INVERTED_DECIMAL_UNITS[e_name] }.sort_by { |e| -e }
+          end.keys.map { |e_name| INVERTED_DECIMAL_UNITS[e_name] }.sort_by(&:-@)
         end
     end
   end

data/lib/active_support/number_helper/number_to_human_size_converter.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module NumberHelper
     class NumberToHumanSizeConverter < NumberConverter #:nodoc:
-      STORAGE_UNITS = [:byte, :kb, :mb, :gb, :tb]
+      STORAGE_UNITS = [:byte, :kb, :mb, :gb, :tb, :pb, :eb]
 
       self.namespace      = :human
       self.validate_float = true
@@ -17,24 +19,24 @@ module ActiveSupport
         if smaller_than_base?
           number_to_format = number.to_i.to_s
         else
-          human_size = number / (base ** exponent)
+          human_size = number / (base**exponent)
           number_to_format = NumberToRoundedConverter.convert(human_size, options)
         end
-        conversion_format.gsub(/%n/, number_to_format).gsub(/%u/, unit)
+        conversion_format.gsub("%n".freeze, number_to_format).gsub("%u".freeze, unit)
       end
 
       private
 
         def conversion_format
-          translate_number_value_with_default('human.storage_units.format', :locale => options[:locale], :raise => true)
+          translate_number_value_with_default("human.storage_units.format", locale: options[:locale], raise: true)
         end
 
         def unit
-          translate_number_value_with_default(storage_unit_key, :locale => options[:locale], :count => number.to_i, :raise => true)
+          translate_number_value_with_default(storage_unit_key, locale: options[:locale], count: number.to_i, raise: true)
         end
 
         def storage_unit_key
-          key_end = smaller_than_base? ? 'byte' : STORAGE_UNITS[exponent]
+          key_end = smaller_than_base? ? "byte" : STORAGE_UNITS[exponent]
           "human.storage_units.units.#{key_end}"
         end
 
@@ -50,9 +52,8 @@ module ActiveSupport
         end
 
         def base
-          opts[:prefix] == :si ? 1000 : 1024
+          1024
         end
     end
   end
 end
-

data/lib/active_support/number_helper/number_to_percentage_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module NumberHelper
     class NumberToPercentageConverter < NumberConverter # :nodoc:
@@ -5,7 +7,7 @@ module ActiveSupport
 
       def convert
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        options[:format].gsub(/%n/, rounded_number)
+        options[:format].gsub("%n".freeze, rounded_number)
       end
     end
   end

data/lib/active_support/number_helper/number_to_phone_converter.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module NumberHelper
     class NumberToPhoneConverter < NumberConverter #:nodoc:
       def convert
-        str  = country_code(opts[:country_code])
+        str = country_code(opts[:country_code]).dup
         str << convert_to_phone_number(number.to_s.strip)
         str << phone_ext(opts[:extension])
       end
@@ -18,12 +20,16 @@ module ActiveSupport
         end
 
         def convert_with_area_code(number)
-          number.gsub!(/(\d{1,3})(\d{3})(\d{4}$)/,"(\\1) \\2#{delimiter}\\3")
+          default_pattern = /(\d{1,3})(\d{3})(\d{4}$)/
+          number.gsub!(regexp_pattern(default_pattern),
+                       "(\\1) \\2#{delimiter}\\3")
           number
         end
 
         def convert_without_area_code(number)
-          number.gsub!(/(\d{0,3})(\d{3})(\d{4})$/,"\\1#{delimiter}\\2#{delimiter}\\3")
+          default_pattern = /(\d{0,3})(\d{3})(\d{4})$/
+          number.gsub!(regexp_pattern(default_pattern),
+                       "\\1#{delimiter}\\2#{delimiter}\\3")
           number.slice!(0, 1) if start_with_delimiter?(number)
           number
         end
@@ -43,7 +49,10 @@ module ActiveSupport
         def phone_ext(ext)
           ext.blank? ? "" : " x #{ext}"
         end
+
+        def regexp_pattern(default_pattern)
+          opts.fetch :pattern, default_pattern
+        end
     end
   end
 end
-

data/lib/active_support/number_helper/number_to_rounded_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveSupport
   module NumberHelper
     class NumberToRoundedConverter < NumberConverter # :nodoc:
@@ -5,63 +7,36 @@ module ActiveSupport
       self.validate_float = true
 
       def convert
-        precision = options.delete :precision
-        significant = options.delete :significant
-
-        case number
-        when Float, String
-          @number = BigDecimal(number.to_s)
-        when Rational
-          @number = BigDecimal(number, digit_count(number.to_i) + precision)
-        else
-          @number = number.to_d
-        end
+        helper = RoundingHelper.new(options)
+        rounded_number = helper.round(number)
+
+        if precision = options[:precision]
+          if options[:significant] && precision > 0
+            digits = helper.digit_count(rounded_number)
+            precision -= digits
+            precision = 0 if precision < 0 # don't let it be negative
+          end
 
-        if significant && precision > 0
-          digits, rounded_number = digits_and_rounded_number(precision)
-          precision -= digits
-          precision = 0 if precision < 0 # don't let it be negative
+          formatted_string =
+            if BigDecimal === rounded_number && rounded_number.finite?
+              s = rounded_number.to_s("F")
+              s << "0".freeze * precision
+              a, b = s.split(".".freeze, 2)
+              a << ".".freeze
+              a << b[0, precision]
+            else
+              "%00.#{precision}f" % rounded_number
+            end
         else
-          rounded_number = number.round(precision)
-          rounded_number = rounded_number.to_i if precision == 0 && rounded_number.finite?
-          rounded_number = rounded_number.abs if rounded_number.zero? # prevent showing negative zeros
+          formatted_string = rounded_number
         end
 
-        formatted_string =
-          if BigDecimal === rounded_number && rounded_number.finite?
-            s = rounded_number.to_s('F') + '0'*precision
-            a, b = s.split('.', 2)
-            a + '.' + b[0, precision]
-          else
-            "%00.#{precision}f" % rounded_number
-          end
-
         delimited_number = NumberToDelimitedConverter.convert(formatted_string, options)
         format_number(delimited_number)
       end
 
       private
 
-        def digits_and_rounded_number(precision)
-          if zero?
-            [1, 0]
-          else
-            digits = digit_count(number)
-            multiplier = 10 ** (digits - precision)
-            rounded_number = calculate_rounded_number(multiplier)
-            digits = digit_count(rounded_number) # After rounding, the number of digits may have changed
-            [digits, rounded_number]
-          end
-        end
-
-        def calculate_rounded_number(multiplier)
-          (number / BigDecimal.new(multiplier.to_f.to_s)).round * multiplier
-        end
-
-        def digit_count(number)
-          number.zero? ? 1 : (Math.log10(absolute_number(number)) + 1).floor
-        end
-
         def strip_insignificant_zeros
           options[:strip_insignificant_zeros]
         end
@@ -69,19 +44,11 @@ module ActiveSupport
         def format_number(number)
           if strip_insignificant_zeros
             escaped_separator = Regexp.escape(options[:separator])
-            number.sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
+            number.sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, "")
           else
             number
           end
         end
-
-        def absolute_number(number)
-          number.respond_to?(:abs) ? number.abs : number.to_d.abs
-        end
-
-        def zero?
-          number.respond_to?(:zero?) ? number.zero? : number.to_d.zero?
-        end
     end
   end
 end

data/lib/active_support/number_helper/rounding_helper.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module NumberHelper
+    class RoundingHelper # :nodoc:
+      attr_reader :options
+
+      def initialize(options)
+        @options = options
+      end
+
+      def round(number)
+        return number unless precision
+        number = convert_to_decimal(number)
+        if significant && precision > 0
+          round_significant(number)
+        else
+          round_without_significant(number)
+        end
+      end
+
+      def digit_count(number)
+        return 1 if number.zero?
+        (Math.log10(absolute_number(number)) + 1).floor
+      end
+
+      private
+        def round_without_significant(number)
+          number = number.round(precision)
+          number = number.to_i if precision == 0 && number.finite?
+          number = number.abs if number.zero? # prevent showing negative zeros
+          number
+        end
+
+        def round_significant(number)
+          return 0 if number.zero?
+          digits = digit_count(number)
+          multiplier = 10**(digits - precision)
+          (number / BigDecimal(multiplier.to_f.to_s)).round * multiplier
+        end
+
+        def convert_to_decimal(number)
+          case number
+          when Float, String
+            BigDecimal(number.to_s)
+          when Rational
+            BigDecimal(number, digit_count(number.to_i) + precision)
+          else
+            number.to_d
+          end
+        end
+
+        def precision
+          options[:precision]
+        end
+
+        def significant
+          options[:significant]
+        end
+
+        def absolute_number(number)
+          number.respond_to?(:abs) ? number.abs : number.to_d.abs
+        end
+    end
+  end
+end