activesupport 5.0.7.2 → 5.1.7

data/lib/active_support/notifications/fanout.rb

@@ -1,5 +1,5 @@
-require 'mutex_m'
-require 'concurrent/map'
+require "mutex_m"
+require "concurrent/map"
 
 module ActiveSupport
   module Notifications
@@ -68,7 +68,7 @@ module ActiveSupport
 
       module Subscribers # :nodoc:
         def self.new(pattern, listener)
-          if listener.respond_to?(:start) and listener.respond_to?(:finish)
+          if listener.respond_to?(:start) && listener.respond_to?(:finish)
             subscriber = Evented.new pattern, listener
           else
             subscriber = Timed.new pattern, listener

data/lib/active_support/notifications/instrumenter.rb

@@ -1,4 +1,4 @@
-require 'securerandom'
+require "securerandom"
 
 module ActiveSupport
   module Notifications
@@ -14,7 +14,7 @@ module ActiveSupport
       # Instrument the given block by measuring the time taken to execute it
       # and publish it. Notice that events get sent even if an error occurs
       # in the passed-in block.
-      def instrument(name, payload={})
+      def instrument(name, payload = {})
         # some of the listeners might have state
         listeners_state = start name, payload
         begin
@@ -44,9 +44,9 @@ module ActiveSupport
 
       private
 
-      def unique_id
-        SecureRandom.hex(10)
-      end
+        def unique_id
+          SecureRandom.hex(10)
+        end
     end
 
     class Event

data/lib/active_support/number_helper.rb

@@ -4,6 +4,7 @@ module ActiveSupport
 
     eager_autoload do
       autoload :NumberConverter
+      autoload :RoundingHelper
       autoload :NumberToRoundedConverter
       autoload :NumberToDelimitedConverter
       autoload :NumberToHumanConverter
@@ -45,7 +46,7 @@ module ActiveSupport
     #
     #   number_to_phone(75561234567, pattern: /(\d{1,4})(\d{4})(\d{4})$/, area_code: true)
     #   # => "(755) 6123-4567"
-    #   number_to_phone(13312345678, pattern: /(\d{3})(\d{4})(\d{4})$/))
+    #   number_to_phone(13312345678, pattern: /(\d{3})(\d{4})(\d{4})$/)
     #   # => "133-1234-5678"
     def number_to_phone(number, options = {})
       NumberToPhoneConverter.convert(number, options)
@@ -78,7 +79,7 @@ module ActiveSupport
     #   (defaults to "%u%n").  Fields are <tt>%u</tt> for the
     #   currency, and <tt>%n</tt> for the number.
     # * <tt>:negative_format</tt> - Sets the format for negative
-    #   numbers (defaults to prepending an hyphen to the formatted
+    #   numbers (defaults to prepending a hyphen to the formatted
     #   number given by <tt>:format</tt>).  Accepts the same fields
     #   than <tt>:format</tt>, except <tt>%n</tt> is here the
     #   absolute value of the number.
@@ -109,7 +110,7 @@ module ActiveSupport
     # * <tt>:locale</tt> - Sets the locale to be used for formatting
     #   (defaults to current locale).
     # * <tt>:precision</tt> - Sets the precision of the number
-    #   (defaults to 3). Keeps the number's precision if nil.
+    #   (defaults to 3). Keeps the number's precision if +nil+.
     # * <tt>:significant</tt> - If +true+, precision will be the number
     #   of significant_digits. If +false+, the number of fractional
     #   digits (defaults to +false+).
@@ -183,7 +184,7 @@ module ActiveSupport
     # * <tt>:locale</tt> - Sets the locale to be used for formatting
     #   (defaults to current locale).
     # * <tt>:precision</tt> - Sets the precision of the number
-    #   (defaults to 3). Keeps the number's precision if nil.
+    #   (defaults to 3). Keeps the number's precision if +nil+.
     # * <tt>:significant</tt> - If +true+, precision will be the number
     #   of significant_digits. If +false+, the number of fractional
     #   digits (defaults to +false+).

data/lib/active_support/number_helper/number_converter.rb

@@ -1,8 +1,8 @@
-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'
+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 +139,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 +160,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 +169,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,4 +1,4 @@
-require 'active_support/core_ext/numeric/inquiry'
+require "active_support/core_ext/numeric/inquiry"
 
 module ActiveSupport
   module NumberHelper
@@ -15,13 +15,13 @@ module ActiveSupport
         end
 
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        format.gsub('%n'.freeze, rounded_number).gsub('%u'.freeze, options[:unit])
+        format.gsub("%n".freeze, rounded_number).gsub("%u".freeze, options[:unit])
       end
 
       private
 
         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

data/lib/active_support/number_helper/number_to_delimited_converter.rb

@@ -12,7 +12,7 @@ module ActiveSupport
       private
 
         def parts
-          left, right = number.to_s.split('.'.freeze)
+          left, right = number.to_s.split(".".freeze)
           left.gsub!(delimiter_pattern) do |digit_to_delimit|
             "#{digit_to_delimit}#{options[:delimiter]}"
           end
@@ -22,7 +22,6 @@ module ActiveSupport
         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

@@ -9,6 +9,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,29 +19,26 @@ module ActiveSupport
 
         units = opts[:units]
         exponent = calculate_exponent(units)
-        @number = number / (10 ** exponent)
+        @number = number / (10**exponent)
 
-        until (rounded_number = NumberToRoundedConverter.convert(number, options)) != NumberToRoundedConverter.convert(1000, options)
-          @number = number / 1000.0
-          exponent += 3
-        end
+        rounded_number = NumberToRoundedConverter.convert(number, options)
         unit = determine_unit(units, exponent)
-        format.gsub('%n'.freeze, rounded_number).gsub('%u'.freeze, unit).strip
+        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
@@ -56,7 +54,7 @@ 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

data/lib/active_support/number_helper/number_to_human_size_converter.rb

@@ -7,10 +7,6 @@ module ActiveSupport
       self.validate_float = true
 
       def convert
-        if opts.key?(:prefix)
-          ActiveSupport::Deprecation.warn('The :prefix option of `number_to_human_size` is deprecated and will be removed in Rails 5.1 with no replacement.')
-        end
-
         @number = Float(number)
 
         # for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
@@ -21,24 +17,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'.freeze, number_to_format).gsub('%u'.freeze, 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
 
@@ -54,9 +50,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

@@ -5,7 +5,7 @@ module ActiveSupport
 
       def convert
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        options[:format].gsub('%n'.freeze, rounded_number)
+        options[:format].gsub("%n".freeze, rounded_number)
       end
     end
   end

data/lib/active_support/number_helper/number_to_phone_converter.rb

@@ -2,7 +2,7 @@ module ActiveSupport
   module NumberHelper
     class NumberToPhoneConverter < NumberConverter #:nodoc:
       def convert
-        str  = country_code(opts[:country_code])
+        str = country_code(opts[:country_code])
         str << convert_to_phone_number(number.to_s.strip)
         str << phone_ext(opts[:extension])
       end
@@ -51,8 +51,6 @@ module ActiveSupport
         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

@@ -5,40 +5,28 @@ module ActiveSupport
       self.validate_float = true
 
       def convert
-        precision = options.delete :precision
+        helper = RoundingHelper.new(options)
+        rounded_number = helper.round(number)
 
-        if precision
-          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
-
-          if options.delete(:significant) && precision > 0
-            digits, rounded_number = digits_and_rounded_number(precision)
+        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
-          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
           end
 
           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
+              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
-          formatted_string = number
+          formatted_string = rounded_number
         end
 
         delimited_number = NumberToDelimitedConverter.convert(formatted_string, options)
@@ -52,7 +40,7 @@ module ActiveSupport
             [1, 0]
           else
             digits = digit_count(number)
-            multiplier = 10 ** (digits - precision)
+            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]
@@ -74,19 +62,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,64 @@
+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.new(multiplier.to_f.to_s)).round * multiplier
+        end
+
+        def convert_to_decimal(number)
+          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
+        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