activesupport 6.0.3.4 → 6.1.3

data/lib/active_support/notifications/instrumenter.rb

@@ -52,14 +52,8 @@ module ActiveSupport
     end
 
     class Event
-      attr_reader :name, :time, :end, :transaction_id, :payload, :children
-
-      def self.clock_gettime_supported? # :nodoc:
-        defined?(Process::CLOCK_THREAD_CPUTIME_ID) &&
-          !Gem.win_platform? &&
-          !RUBY_PLATFORM.match?(/solaris/i)
-      end
-      private_class_method :clock_gettime_supported?
+      attr_reader :name, :time, :end, :transaction_id, :children
+      attr_accessor :payload
 
       def initialize(name, start, ending, transaction_id, payload)
         @name           = name
@@ -88,11 +82,6 @@ module ActiveSupport
         @allocation_count_finish = now_allocations
       end
 
-      def end=(ending)
-        ActiveSupport::Deprecation.deprecation_warning(:end=, :finish!)
-        @end = ending
-      end
-
       # Returns the CPU time (in milliseconds) passed since the call to
       # +start!+ and the call to +finish!+
       def cpu_time
@@ -140,11 +129,13 @@ module ActiveSupport
           Concurrent.monotonic_time
         end
 
-        if clock_gettime_supported?
+        begin
+          Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID)
+
           def now_cpu
             Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID)
           end
-        else
+        rescue
           def now_cpu
             0
           end

data/lib/active_support/number_helper.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/dependencies/autoload"
-
 module ActiveSupport
   module NumberHelper
     extend ActiveSupport::Autoload
@@ -73,6 +71,8 @@ module ActiveSupport
     #   (defaults to current locale).
     # * <tt>:precision</tt> - Sets the level of precision (defaults
     #   to 2).
+    # * <tt>:round_mode</tt> - Determine how rounding is performed
+    #   (defaults to :default. See BigDecimal::mode)
     # * <tt>:unit</tt> - Sets the denomination of the currency
     #   (defaults to "$").
     # * <tt>:separator</tt> - Sets the separator between the units
@@ -111,6 +111,8 @@ module ActiveSupport
     #   # => "1234567890,50 &pound;"
     #   number_to_currency(1234567890.50, strip_insignificant_zeros: true)
     #   # => "$1,234,567,890.5"
+    #   number_to_currency(1234567890.50, precision: 0, round_mode: :up)
+    #   # => "$1,234,567,891"
     def number_to_currency(number, options = {})
       NumberToCurrencyConverter.convert(number, options)
     end
@@ -124,6 +126,8 @@ module ActiveSupport
     #   (defaults to current locale).
     # * <tt>:precision</tt> - Sets the precision of the number
     #   (defaults to 3). Keeps the number's precision if +nil+.
+    # * <tt>:round_mode</tt> - Determine how rounding is performed
+    #   (defaults to :default. See BigDecimal::mode)
     # * <tt>:significant</tt> - If +true+, precision will be the number
     #   of significant_digits. If +false+, the number of fractional
     #   digits (defaults to +false+).
@@ -139,15 +143,16 @@ module ActiveSupport
     #
     # ==== Examples
     #
-    #   number_to_percentage(100)                                  # => "100.000%"
-    #   number_to_percentage('98')                                 # => "98.000%"
-    #   number_to_percentage(100, precision: 0)                    # => "100%"
-    #   number_to_percentage(1000, delimiter: '.', separator: ',') # => "1.000,000%"
-    #   number_to_percentage(302.24398923423, precision: 5)        # => "302.24399%"
-    #   number_to_percentage(1000, locale: :fr)                    # => "1000,000%"
-    #   number_to_percentage(1000, precision: nil)                 # => "1000%"
-    #   number_to_percentage('98a')                                # => "98a%"
-    #   number_to_percentage(100, format: '%n  %')                 # => "100.000  %"
+    #   number_to_percentage(100)                                              # => "100.000%"
+    #   number_to_percentage('98')                                             # => "98.000%"
+    #   number_to_percentage(100, precision: 0)                                # => "100%"
+    #   number_to_percentage(1000, delimiter: '.', separator: ',')             # => "1.000,000%"
+    #   number_to_percentage(302.24398923423, precision: 5)                    # => "302.24399%"
+    #   number_to_percentage(1000, locale: :fr)                                # => "1000,000%"
+    #   number_to_percentage(1000, precision: nil)                             # => "1000%"
+    #   number_to_percentage('98a')                                            # => "98a%"
+    #   number_to_percentage(100, format: '%n  %')                             # => "100.000  %"
+    #   number_to_percentage(302.24398923423, precision: 5, round_mode: :down) # => "302.24398%"
     def number_to_percentage(number, options = {})
       NumberToPercentageConverter.convert(number, options)
     end
@@ -198,6 +203,8 @@ module ActiveSupport
     #   (defaults to current locale).
     # * <tt>:precision</tt> - Sets the precision of the number
     #   (defaults to 3). Keeps the number's precision if +nil+.
+    # * <tt>:round_mode</tt> - Determine how rounding is performed
+    #   (defaults to :default. See BigDecimal::mode)
     # * <tt>:significant</tt> - If +true+, precision will be the number
     #   of significant_digits. If +false+, the number of fractional
     #   digits (defaults to +false+).
@@ -219,6 +226,7 @@ module ActiveSupport
     #   number_to_rounded(111.2345, precision: 1, significant: true) # => "100"
     #   number_to_rounded(13, precision: 5, significant: true)       # => "13.000"
     #   number_to_rounded(13, precision: nil)                        # => "13"
+    #   number_to_rounded(389.32314, precision: 0, round_mode: :up)  # => "390"
     #   number_to_rounded(111.234, locale: :fr)                      # => "111,234"
     #
     #   number_to_rounded(13, precision: 5, significant: true, strip_insignificant_zeros: true)
@@ -232,7 +240,7 @@ module ActiveSupport
     end
 
     # Formats the bytes in +number+ into a more understandable
-    # representation (e.g., giving it 1500 yields 1.5 KB). This
+    # representation (e.g., giving it 1500 yields 1.46 KB). This
     # method is useful for reporting file sizes to users. You can
     # customize the format in the +options+ hash.
     #
@@ -245,6 +253,8 @@ module ActiveSupport
     #   (defaults to current locale).
     # * <tt>:precision</tt> - Sets the precision of the number
     #   (defaults to 3).
+    # * <tt>:round_mode</tt> - Determine how rounding is performed
+    #   (defaults to :default. See BigDecimal::mode)
     # * <tt>:significant</tt> - If +true+, precision will be the number
     #   of significant_digits. If +false+, the number of fractional
     #   digits (defaults to +true+)
@@ -268,6 +278,7 @@ module ActiveSupport
     #   number_to_human_size(1234567890123456789)                    # => "1.07 EB"
     #   number_to_human_size(1234567, precision: 2)                  # => "1.2 MB"
     #   number_to_human_size(483989, precision: 2)                   # => "470 KB"
+    #   number_to_human_size(483989, precision: 2, round_mode: :up)  # => "480 KB"
     #   number_to_human_size(1234567, precision: 2, separator: ',')  # => "1,2 MB"
     #   number_to_human_size(1234567890123, precision: 5)            # => "1.1228 TB"
     #   number_to_human_size(524288000, precision: 5)                # => "500 MB"
@@ -276,7 +287,7 @@ module ActiveSupport
     end
 
     # Pretty prints (formats and approximates) a number in a way it
-    # is more readable by humans (eg.: 1200000000 becomes "1.2
+    # is more readable by humans (e.g.: 1200000000 becomes "1.2
     # Billion"). This is useful for numbers that can get very large
     # (and too hard to read).
     #
@@ -284,7 +295,7 @@ module ActiveSupport
     # size.
     #
     # You can also define your own unit-quantifier names if you want
-    # to use other decimal units (eg.: 1500 becomes "1.5
+    # to use other decimal units (e.g.: 1500 becomes "1.5
     # kilometers", 0.150 becomes "150 milliliters", etc). You may
     # define a wide range of unit quantifiers, even fractional ones
     # (centi, deci, mili, etc).
@@ -295,6 +306,8 @@ module ActiveSupport
     #   (defaults to current locale).
     # * <tt>:precision</tt> - Sets the precision of the number
     #   (defaults to 3).
+    # * <tt>:round_mode</tt> - Determine how rounding is performed
+    #   (defaults to :default. See BigDecimal::mode)
     # * <tt>:significant</tt> - If +true+, precision will be the number
     #   of significant_digits. If +false+, the number of fractional
     #   digits (defaults to +true+)
@@ -332,6 +345,8 @@ module ActiveSupport
     #   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(489939, precision: 2
+    #                         , round_mode: :down)   # => "480 Thousand"
     #   number_to_human(1234567, precision: 4,
     #                            significant: false) # => "1.2346 Million"
     #   number_to_human(1234567, precision: 1,

data/lib/active_support/number_helper/number_converter.rb

@@ -30,7 +30,7 @@ module ActiveSupport
           # 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)
+          # If set, the zeros after the decimal separator will always be stripped (e.g.: 1.200 will be 1.2)
           strip_insignificant_zeros: false
         },
 

data/lib/active_support/number_helper/number_to_currency_converter.rb

@@ -9,15 +9,11 @@ module ActiveSupport
 
       def convert
         number = self.number.to_s.strip
-        number_f = number.to_f
         format = options[:format]
 
-        if number_f.negative?
-          number = number_f.abs
-
-          unless options[:precision] == 0 && number < 0.5
-            format = options[:negative_format]
-          end
+        if number.sub!(/^-/, "") &&
+           (options[:precision] != 0 || number.to_f > 0.5)
+          format = options[:negative_format]
         end
 
         rounded_number = NumberToRoundedConverter.convert(number, options)

data/lib/active_support/number_helper/number_to_human_converter.rb

@@ -16,7 +16,7 @@ module ActiveSupport
         @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
+        # For backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files.
         unless options.key?(:strip_insignificant_zeros)
           options[:strip_insignificant_zeros] = true
         end

data/lib/active_support/number_helper/number_to_human_size_converter.rb

@@ -13,7 +13,7 @@ module ActiveSupport
       def convert
         @number = Float(number)
 
-        # for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
+        # For backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files.
         unless options.key?(:strip_insignificant_zeros)
           options[:strip_insignificant_zeros] = true
         end

data/lib/active_support/number_helper/number_to_rounded_converter.rb

@@ -20,14 +20,14 @@ module ActiveSupport
           end
 
           formatted_string =
-            if BigDecimal === rounded_number && rounded_number.finite?
+            if rounded_number.nan? || rounded_number.infinite? || rounded_number == rounded_number.to_i
+              "%00.#{precision}f" % rounded_number
+            else
               s = rounded_number.to_s("F")
               s << "0" * precision
               a, b = s.split(".", 2)
               a << "."
               a << b[0, precision]
-            else
-              "%00.#{precision}f" % rounded_number
             end
         else
           formatted_string = rounded_number

data/lib/active_support/number_helper/rounding_helper.rb

@@ -10,57 +10,41 @@ module ActiveSupport
       end
 
       def round(number)
+        precision = absolute_precision(number)
         return number unless precision
-        number = convert_to_decimal(number)
-        if significant && precision > 0
-          round_significant(number)
-        else
-          round_without_significant(number)
-        end
+
+        rounded_number = convert_to_decimal(number).round(precision, options.fetch(:round_mode, :default))
+        rounded_number.zero? ? rounded_number.abs : rounded_number # prevent showing negative zeros
       end
 
       def digit_count(number)
         return 1 if number.zero?
-        (Math.log10(absolute_number(number)) + 1).floor
+        (Math.log10(number.abs) + 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)
+            BigDecimal(number, digit_count(number.to_i) + options[:precision])
           else
             number.to_d
           end
         end
 
-        def precision
-          options[:precision]
+        def absolute_precision(number)
+          if significant && options[:precision] > 0
+            options[:precision] - digit_count(convert_to_decimal(number))
+          else
+            options[:precision]
+          end
         end
 
         def significant
           options[:significant]
         end
-
-        def absolute_number(number)
-          number.respond_to?(:abs) ? number.abs : number.to_d.abs
-        end
     end
   end
 end

data/lib/active_support/option_merger.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/hash/deep_merge"
+require "active_support/core_ext/symbol/starts_ends_with"
 
 module ActiveSupport
   class OptionMerger #:nodoc:
     instance_methods.each do |method|
-      undef_method(method) if !/^(__|instance_eval|class|object_id)/.match?(method)
+      undef_method(method) unless method.start_with?("__", "instance_eval", "class", "object_id")
     end
 
     def initialize(context, options)
@@ -37,7 +38,7 @@ module ActiveSupport
         end
       else
         def invoke_method(method, arguments, options, &block)
-          arguments << options if options
+          arguments << options.dup if options
           @context.__send__(method, *arguments, &block)
         end
       end

data/lib/active_support/ordered_options.rb

@@ -3,7 +3,9 @@
 require "active_support/core_ext/object/blank"
 
 module ActiveSupport
-  # Usually key value pairs are handled something like this:
+  # +OrderedOptions+ inherits from +Hash+ and provides dynamic accessor methods.
+  #
+  # With a +Hash+, key-value pairs are typically managed like this:
   #
   #   h = {}
   #   h[:boy] = 'John'
@@ -12,7 +14,7 @@ module ActiveSupport
   #   h[:girl] # => 'Mary'
   #   h[:dog]  # => nil
   #
-  # Using +OrderedOptions+, the above code could be reduced to:
+  # Using +OrderedOptions+, the above code can be written as:
   #
   #   h = ActiveSupport::OrderedOptions.new
   #   h.boy = 'John'
@@ -60,6 +62,10 @@ module ActiveSupport
     def extractable_options?
       true
     end
+
+    def inspect
+      "#<#{self.class.name} #{super}>"
+    end
   end
 
   # +InheritableOptions+ provides a constructor to build an +OrderedOptions+

data/lib/active_support/parameter_filter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/object/duplicable"
-require "active_support/core_ext/array/extract"
 
 module ActiveSupport
   # +ParameterFilter+ allows you to specify keys for sensitive data from
@@ -22,7 +21,7 @@ module ActiveSupport
   #   change { file: { code: "xxxx"} }
   #
   #   ActiveSupport::ParameterFilter.new([-> (k, v) do
-  #     v.reverse! if k =~ /secret/i
+  #     v.reverse! if /secret/i.match?(k)
   #   end])
   #   => reverses the value to all keys matching /secret/i
   class ParameterFilter
@@ -34,7 +33,7 @@ module ActiveSupport
     #
     # ==== Options
     #
-    # * <tt>:mask</tt> - A replaced object when filtered. Defaults to +"[FILTERED]"+
+    # * <tt>:mask</tt> - A replaced object when filtered. Defaults to <tt>"[FILTERED]"</tt>.
     def initialize(filters = [], mask: FILTERED)
       @filters = filters
       @mask = mask
@@ -59,24 +58,30 @@ module ActiveSupport
       def self.compile(filters, mask:)
         return lambda { |params| params.dup } if filters.empty?
 
-        strings, regexps, blocks = [], [], []
+        strings, regexps, blocks, deep_regexps, deep_strings = [], [], [], nil, nil
 
         filters.each do |item|
           case item
           when Proc
             blocks << item
           when Regexp
-            regexps << item
+            if item.to_s.include?("\\.")
+              (deep_regexps ||= []) << item
+            else
+              regexps << item
+            end
           else
-            strings << Regexp.escape(item.to_s)
+            s = Regexp.escape(item.to_s)
+            if s.include?("\\.")
+              (deep_strings ||= []) << s
+            else
+              strings << s
+            end
           end
         end
 
-        deep_regexps = regexps.extract! { |r| r.to_s.include?("\\.") }
-        deep_strings = strings.extract! { |s| s.include?("\\.") }
-
         regexps << Regexp.new(strings.join("|"), true) unless strings.empty?
-        deep_regexps << Regexp.new(deep_strings.join("|"), true) unless deep_strings.empty?
+        (deep_regexps ||= []) << Regexp.new(deep_strings.join("|"), true) if deep_strings&.any?
 
         new regexps, deep_regexps, blocks, mask: mask
       end
@@ -85,7 +90,7 @@ module ActiveSupport
 
       def initialize(regexps, deep_regexps, blocks, mask:)
         @regexps = regexps
-        @deep_regexps = deep_regexps.any? ? deep_regexps : nil
+        @deep_regexps = deep_regexps&.any? ? deep_regexps : nil
         @blocks = blocks
         @mask = mask
       end

data/lib/active_support/per_thread_registry.rb

@@ -40,7 +40,7 @@ module ActiveSupport
   # If the class has an initializer, it must accept no arguments.
   module PerThreadRegistry
     def self.extended(object)
-      object.instance_variable_set "@per_thread_registry_key", object.name.freeze
+      object.instance_variable_set :@per_thread_registry_key, object.name.freeze
     end
 
     def instance