activesupport 6.0.0 → 6.1.3

data/lib/active_support/multibyte/unicode.rb

@@ -5,53 +5,19 @@ module ActiveSupport
     module Unicode
       extend self
 
-      # A list of all available normalization forms.
-      # See https://www.unicode.org/reports/tr15/tr15-29.html for more
-      # information about normalization.
-      NORMALIZATION_FORMS = [:c, :kc, :d, :kd]
-
-      NORMALIZATION_FORM_ALIASES = { # :nodoc:
-        c: :nfc,
-        d: :nfd,
-        kc: :nfkc,
-        kd: :nfkd
-      }
-
       # The Unicode version that is supported by the implementation
       UNICODE_VERSION = RbConfig::CONFIG["UNICODE_VERSION"]
 
-      # The default normalization used for operations that require
-      # normalization. It can be set to any of the normalizations
-      # in NORMALIZATION_FORMS.
-      #
-      #   ActiveSupport::Multibyte::Unicode.default_normalization_form = :c
-      attr_accessor :default_normalization_form
-      @default_normalization_form = :kc
-
-      # Unpack the string at grapheme boundaries. Returns a list of character
-      # lists.
-      #
-      #   Unicode.unpack_graphemes('क्षि') # => [[2325, 2381], [2359], [2367]]
-      #   Unicode.unpack_graphemes('Café') # => [[67], [97], [102], [233]]
-      def unpack_graphemes(string)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          ActiveSupport::Multibyte::Unicode#unpack_graphemes is deprecated and will be
-          removed from Rails 6.1. Use string.scan(/\X/).map(&:codepoints) instead.
-        MSG
-
-        string.scan(/\X/).map(&:codepoints)
+      def default_normalization_form
+        ActiveSupport::Deprecation.warn(
+          "ActiveSupport::Multibyte::Unicode.default_normalization_form is deprecated and will be removed in Rails 6.2."
+        )
       end
 
-      # Reverse operation of unpack_graphemes.
-      #
-      #   Unicode.pack_graphemes(Unicode.unpack_graphemes('क्षि')) # => 'क्षि'
-      def pack_graphemes(unpacked)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          ActiveSupport::Multibyte::Unicode#pack_graphemes is deprecated and will be
-          removed from Rails 6.1. Use array.flatten.pack("U*") instead.
-        MSG
-
-        unpacked.flatten.pack("U*")
+      def default_normalization_form=(_)
+        ActiveSupport::Deprecation.warn(
+          "ActiveSupport::Multibyte::Unicode.default_normalization_form= is deprecated and will be removed in Rails 6.2."
+        )
       end
 
       # Decompose composed characters to the decomposed form.
@@ -76,7 +42,7 @@ module ActiveSupport
         # Passing +true+ will forcibly tidy all bytes, assuming that the string's
         # encoding is entirely CP1252 or ISO-8859-1.
         def tidy_bytes(string, force = false)
-          return string if string.empty?
+          return string if string.empty? || string.ascii_only?
           return recode_windows1252_chars(string) if force
           string.scrub { |bad| recode_windows1252_chars(bad) }
         end
@@ -107,48 +73,7 @@ module ActiveSupport
         end
       end
 
-      # Returns the KC normalization of the string by default. NFKC is
-      # considered the best normalization form for passing strings to databases
-      # and validations.
-      #
-      # * <tt>string</tt> - The string to perform normalization on.
-      # * <tt>form</tt> - The form you want to normalize in. Should be one of
-      #   the following: <tt>:c</tt>, <tt>:kc</tt>, <tt>:d</tt>, or <tt>:kd</tt>.
-      #   Default is ActiveSupport::Multibyte::Unicode.default_normalization_form.
-      def normalize(string, form = nil)
-        form ||= @default_normalization_form
-
-        # See https://www.unicode.org/reports/tr15, Table 1
-        if alias_form = NORMALIZATION_FORM_ALIASES[form]
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            ActiveSupport::Multibyte::Unicode#normalize is deprecated and will be
-            removed from Rails 6.1. Use String#unicode_normalize(:#{alias_form}) instead.
-          MSG
-
-          string.unicode_normalize(alias_form)
-        else
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            ActiveSupport::Multibyte::Unicode#normalize is deprecated and will be
-            removed from Rails 6.1. Use String#unicode_normalize instead.
-          MSG
-
-          raise ArgumentError, "#{form} is not a valid normalization variant", caller
-        end
-      end
-
-      %w(downcase upcase swapcase).each do |method|
-        define_method(method) do |string|
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          ActiveSupport::Multibyte::Unicode##{method} is deprecated and
-          will be removed from Rails 6.1. Use String methods directly.
-          MSG
-
-          string.send(method)
-        end
-      end
-
       private
-
         def recode_windows1252_chars(string)
           string.encode(Encoding::UTF_8, Encoding::Windows_1252, invalid: :replace, undef: :replace)
         end

data/lib/active_support/notifications.rb

@@ -38,6 +38,19 @@ module ActiveSupport
   #     payload # => Hash, the payload
   #   end
   #
+  # Here, the +start+ and +finish+ values represent wall-clock time. If you are
+  # concerned about accuracy, you can register a monotonic subscriber.
+  #
+  #   ActiveSupport::Notifications.monotonic_subscribe('render') do |name, start, finish, id, payload|
+  #     name    # => String, name of the event (such as 'render' from above)
+  #     start   # => Monotonic time, when the instrumented block started execution
+  #     finish  # => Monotonic time, when the instrumented block ended execution
+  #     id      # => String, unique ID for the instrumenter that fired the event
+  #     payload # => Hash, the payload
+  #   end
+  #
+  # The +start+ and +finish+ values above represent monotonic time.
+  #
   # For instance, let's store all "render" events in an array:
   #
   #   events = []
@@ -135,6 +148,16 @@ module ActiveSupport
   # during the execution of the block. The callback is unsubscribed automatically
   # after that.
   #
+  # To record +started+ and +finished+ values with monotonic time,
+  # specify the optional <tt>:monotonic</tt> option to the
+  # <tt>subscribed</tt> method. The <tt>:monotonic</tt> option is set
+  # to +false+ by default.
+  #
+  #   callback = lambda {|name, started, finished, unique_id, payload| ... }
+  #   ActiveSupport::Notifications.subscribed(callback, "sql.active_record", monotonic: true) do
+  #     ...
+  #   end
+  #
   # === Manual Unsubscription
   #
   # The +subscribe+ method returns a subscriber object:
@@ -155,7 +178,7 @@ module ActiveSupport
   #
   # Subscribers using a regexp or other pattern-matching object will remain subscribed
   # to all events that match their original pattern, unless those events match a string
-  # passed to `unsubscribe`:
+  # passed to +unsubscribe+:
   #
   #   subscriber = ActiveSupport::Notifications.subscribe(/render/) { }
   #   ActiveSupport::Notifications.unsubscribe('render_template.action_view')
@@ -208,12 +231,16 @@ module ActiveSupport
       #   ActiveSupport::Notifications.subscribe(/render/) do |event|
       #     @event = event
       #   end
-      def subscribe(*args, &block)
-        notifier.subscribe(*args, &block)
+      def subscribe(pattern = nil, callback = nil, &block)
+        notifier.subscribe(pattern, callback, monotonic: false, &block)
+      end
+
+      def monotonic_subscribe(pattern = nil, callback = nil, &block)
+        notifier.subscribe(pattern, callback, monotonic: true, &block)
       end
 
-      def subscribed(callback, *args, &block)
-        subscriber = subscribe(*args, &callback)
+      def subscribed(callback, pattern = nil, monotonic: false, &block)
+        subscriber = notifier.subscribe(pattern, callback, monotonic: monotonic)
         yield
       ensure
         unsubscribe(subscriber)

data/lib/active_support/notifications/fanout.rb

@@ -3,6 +3,7 @@
 require "mutex_m"
 require "concurrent/map"
 require "set"
+require "active_support/core_ext/object/try"
 
 module ActiveSupport
   module Notifications
@@ -20,8 +21,8 @@ module ActiveSupport
         super
       end
 
-      def subscribe(pattern = nil, callable = nil, &block)
-        subscriber = Subscribers.new(pattern, callable || block)
+      def subscribe(pattern = nil, callable = nil, monotonic: false, &block)
+        subscriber = Subscribers.new(pattern, callable || block, monotonic)
         synchronize do
           if String === pattern
             @string_subscribers[pattern] << subscriber
@@ -84,8 +85,8 @@ module ActiveSupport
       end
 
       module Subscribers # :nodoc:
-        def self.new(pattern, listener)
-          subscriber_class = Timed
+        def self.new(pattern, listener, monotonic)
+          subscriber_class = monotonic ? MonotonicTimed : Timed
 
           if listener.respond_to?(:start) && listener.respond_to?(:finish)
             subscriber_class = Evented
@@ -103,10 +104,6 @@ module ActiveSupport
           wrap_all pattern, subscriber_class.new(pattern, listener)
         end
 
-        def self.event_object_subscriber(pattern, block)
-          wrap_all pattern, EventObject.new(pattern, block)
-        end
-
         def self.wrap_all(pattern, subscriber)
           unless pattern
             AllMessages.new(subscriber)
@@ -190,6 +187,23 @@ module ActiveSupport
           end
         end
 
+        class MonotonicTimed < Evented # :nodoc:
+          def publish(name, *args)
+            @delegate.call name, *args
+          end
+
+          def start(name, id, payload)
+            timestack = Thread.current[:_timestack_monotonic] ||= []
+            timestack.push Concurrent.monotonic_time
+          end
+
+          def finish(name, id, payload)
+            timestack = Thread.current[:_timestack_monotonic]
+            started = timestack.pop
+            @delegate.call(name, started, Concurrent.monotonic_time, id, payload)
+          end
+        end
+
         class EventObject < Evented
           def start(name, id, payload)
             stack = Thread.current[:_event_stack] ||= []
@@ -201,6 +215,7 @@ module ActiveSupport
           def finish(name, id, payload)
             stack = Thread.current[:_event_stack]
             event = stack.pop
+            event.payload = payload
             event.finish!
             @delegate.call event
           end

data/lib/active_support/notifications/instrumenter.rb

@@ -46,20 +46,14 @@ module ActiveSupport
       end
 
       private
-
         def unique_id
           SecureRandom.hex(10)
         end
     end
 
     class Event
-      attr_reader :name, :time, :end, :transaction_id, :payload, :children
-
-      def self.clock_gettime_supported? # :nodoc:
-        defined?(Process::CLOCK_PROCESS_CPUTIME_ID) &&
-          !Gem.win_platform?
-      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_PROCESS_CPUTIME_ID)
+            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
@@ -99,6 +99,10 @@ module ActiveSupport
     #   number_to_currency(1234567890.506, locale: :fr)  # => "1 234 567 890,51 €"
     #   number_to_currency('123a456')                    # => "$123a456"
     #
+    #   number_to_currency("123a456", raise: true)       # => InvalidNumberError
+    #
+    #   number_to_currency(-0.456789, precision: 0)
+    #   # => "$0"
     #   number_to_currency(-1234567890.50, negative_format: '(%u%n)')
     #   # => "($1,234,567,890.50)"
     #   number_to_currency(1234567890.50, unit: '&pound;', separator: ',', delimiter: '')
@@ -107,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
@@ -120,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+).
@@ -135,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
@@ -194,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+).
@@ -215,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)
@@ -228,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.
     #
@@ -241,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+)
@@ -264,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"
@@ -272,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).
     #
@@ -280,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).
@@ -291,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+)
@@ -328,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,