activesupport 4.2.11.1 → 6.0.3.1

data/lib/active_support/notifications/instrumenter.rb

@@ -1,4 +1,6 @@
-require 'securerandom'
+# frozen_string_literal: true
+
+require "securerandom"
 
 module ActiveSupport
   module Notifications
@@ -11,18 +13,21 @@ module ActiveSupport
         @notifier = notifier
       end
 
-      # 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={})
-        start name, payload
+      # Given a block, instrument it by measuring the time taken to execute
+      # and publish it. Without a block, simply send a message via the
+      # notifier. Notice that events get sent even if an error occurs in the
+      # passed-in block.
+      def instrument(name, payload = {})
+        # some of the listeners might have state
+        listeners_state = start name, payload
         begin
-          yield payload
+          yield payload if block_given?
         rescue Exception => e
           payload[:exception] = [e.class.name, e.message]
+          payload[:exception_object] = e
           raise e
         ensure
-          finish name, payload
+          finish_with_state listeners_state, name, payload
         end
       end
 
@@ -36,16 +41,25 @@ module ActiveSupport
         @notifier.finish name, @id, payload
       end
 
-      private
-
-      def unique_id
-        SecureRandom.hex(10)
+      def finish_with_state(listeners_state, name, payload)
+        @notifier.finish name, @id, payload, listeners_state
       end
+
+      private
+        def unique_id
+          SecureRandom.hex(10)
+        end
     end
 
     class Event
-      attr_reader :name, :time, :transaction_id, :payload, :children
-      attr_accessor :end
+      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?
 
       def initialize(name, start, ending, transaction_id, payload)
         @name           = name
@@ -54,11 +68,63 @@ module ActiveSupport
         @transaction_id = transaction_id
         @end            = ending
         @children       = []
-        @duration       = nil
+        @cpu_time_start = 0
+        @cpu_time_finish = 0
+        @allocation_count_start = 0
+        @allocation_count_finish = 0
+      end
+
+      # Record information at the time this event starts
+      def start!
+        @time = now
+        @cpu_time_start = now_cpu
+        @allocation_count_start = now_allocations
+      end
+
+      # Record information at the time this event finishes
+      def finish!
+        @cpu_time_finish = now_cpu
+        @end = now
+        @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
+        (@cpu_time_finish - @cpu_time_start) * 1000
+      end
+
+      # Returns the idle time time (in milliseconds) passed since the call to
+      # +start!+ and the call to +finish!+
+      def idle_time
+        duration - cpu_time
+      end
+
+      # Returns the number of allocations made since the call to +start!+ and
+      # the call to +finish!+
+      def allocations
+        @allocation_count_finish - @allocation_count_start
+      end
+
+      # Returns the difference in milliseconds between when the execution of the
+      # event started and when it ended.
+      #
+      #   ActiveSupport::Notifications.subscribe('wait') do |*args|
+      #     @event = ActiveSupport::Notifications::Event.new(*args)
+      #   end
+      #
+      #   ActiveSupport::Notifications.instrument('wait') do
+      #     sleep 1
+      #   end
+      #
+      #   @event.duration # => 1000.138
       def duration
-        @duration ||= 1000.0 * (self.end - time)
+        1000.0 * (self.end - time)
       end
 
       def <<(event)
@@ -68,6 +134,31 @@ module ActiveSupport
       def parent_of?(event)
         @children.include? event
       end
+
+      private
+        def now
+          Concurrent.monotonic_time
+        end
+
+        if clock_gettime_supported?
+          def now_cpu
+            Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID)
+          end
+        else
+          def now_cpu
+            0
+          end
+        end
+
+        if defined?(JRUBY_VERSION)
+          def now_allocations
+            0
+          end
+        else
+          def now_allocations
+            GC.stat :total_allocated_objects
+          end
+        end
     end
   end
 end

data/lib/active_support/notifications.rb

@@ -1,6 +1,8 @@
-require 'active_support/notifications/instrumenter'
-require 'active_support/notifications/fanout'
-require 'active_support/per_thread_registry'
+# frozen_string_literal: true
+
+require "active_support/notifications/instrumenter"
+require "active_support/notifications/fanout"
+require "active_support/per_thread_registry"
 
 module ActiveSupport
   # = Notifications
@@ -13,7 +15,7 @@ module ActiveSupport
   # To instrument an event you just need to do:
   #
   #   ActiveSupport::Notifications.instrument('render', extra: :information) do
-  #     render text: 'Foo'
+  #     render plain: 'Foo'
   #   end
   #
   # That first executes the block and then notifies all subscribers once done.
@@ -32,7 +34,7 @@ module ActiveSupport
   #     name    # => String, name of the event (such as 'render' from above)
   #     start   # => Time, when the instrumented block started execution
   #     finish  # => Time, when the instrumented block ended execution
-  #     id      # => String, unique ID for this notification
+  #     id      # => String, unique ID for the instrumenter that fired the event
   #     payload # => Hash, the payload
   #   end
   #
@@ -48,7 +50,7 @@ module ActiveSupport
   # The block is saved and will be called whenever someone instruments "render":
   #
   #   ActiveSupport::Notifications.instrument('render', extra: :information) do
-  #     render text: 'Foo'
+  #     render plain: 'Foo'
   #   end
   #
   #   event = events.first
@@ -57,20 +59,25 @@ module ActiveSupport
   #   event.payload   # => { extra: :information }
   #
   # The block in the <tt>subscribe</tt> call gets the name of the event, start
-  # timestamp, end timestamp, a string with a unique identifier for that event
+  # timestamp, end timestamp, a string with a unique identifier for that event's instrumenter
   # (something like "535801666f04d0298cd6"), and a hash with the payload, in
   # that order.
   #
   # If an exception happens during that particular instrumentation the payload will
   # have a key <tt>:exception</tt> with an array of two elements as value: a string with
   # the name of the exception class, and the exception message.
+  # The <tt>:exception_object</tt> key of the payload will have the exception
+  # itself as the value:
+  #
+  #   event.payload[:exception]         # => ["ArgumentError", "Invalid value"]
+  #   event.payload[:exception_object]  # => #<ArgumentError: Invalid value>
   #
-  # As the previous example depicts, the class <tt>ActiveSupport::Notifications::Event</tt>
+  # As the earlier example depicts, the class <tt>ActiveSupport::Notifications::Event</tt>
   # is able to take the arguments as they come and provide an object-oriented
   # interface to that data.
   #
-  # It is also possible to pass an object as the second parameter passed to the
-  # <tt>subscribe</tt> method instead of a block:
+  # It is also possible to pass an object which responds to <tt>call</tt> method
+  # as the second parameter to the <tt>subscribe</tt> method instead of a block:
   #
   #   module ActionController
   #     class PageRequest
@@ -146,6 +153,15 @@ module ActiveSupport
   #
   #   ActiveSupport::Notifications.unsubscribe("render")
   #
+  # 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`:
+  #
+  #   subscriber = ActiveSupport::Notifications.subscribe(/render/) { }
+  #   ActiveSupport::Notifications.unsubscribe('render_template.action_view')
+  #   subscriber.matches?('render_template.action_view') # => false
+  #   subscriber.matches?('render_partial.action_view') # => true
+  #
   # == Default Queue
   #
   # Notifications ships with a queue implementation that consumes and publishes events
@@ -167,6 +183,31 @@ module ActiveSupport
         end
       end
 
+      # Subscribe to a given event name with the passed +block+.
+      #
+      # You can subscribe to events by passing a String to match exact event
+      # names, or by passing a Regexp to match all events that match a pattern.
+      #
+      #   ActiveSupport::Notifications.subscribe(/render/) do |*args|
+      #     @event = ActiveSupport::Notifications::Event.new(*args)
+      #   end
+      #
+      # The +block+ will receive five parameters with information about the event:
+      #
+      #   ActiveSupport::Notifications.subscribe('render') do |name, start, finish, id, payload|
+      #     name    # => String, name of the event (such as 'render' from above)
+      #     start   # => Time, when the instrumented block started execution
+      #     finish  # => Time, when the instrumented block ended execution
+      #     id      # => String, unique ID for the instrumenter that fired the event
+      #     payload # => Hash, the payload
+      #   end
+      #
+      # If the block passed to the method only takes one parameter,
+      # it will yield an event object to the block:
+      #
+      #   ActiveSupport::Notifications.subscribe(/render/) do |event|
+      #     @event = event
+      #   end
       def subscribe(*args, &block)
         notifier.subscribe(*args, &block)
       end

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
@@ -134,22 +136,21 @@ module ActiveSupport
       end
 
       private
-
         def options
           @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,19 +161,19 @@ module ActiveSupport
           options
         end
 
-        def translate_number_value_with_default(key, i18n_options = {}) #:nodoc:
-          I18n.translate(key, { default: default_value(key), scope: :number }.merge!(i18n_options))
+        def translate_number_value_with_default(key, **i18n_options)
+          I18n.translate(key, **{ default: default_value(key), scope: :number }.merge!(i18n_options))
         end
 
-        def translate_in_locale(key, i18n_options = {})
-          translate_number_value_with_default(key, { locale: options[:locale] }.merge(i18n_options))
+        def translate_in_locale(key, **i18n_options)
+          translate_number_value_with_default(key, **{ locale: options[:locale] }.merge(i18n_options))
         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/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToCurrencyConverter < NumberConverter # :nodoc:
@@ -5,38 +9,33 @@ module ActiveSupport
 
       def convert
         number = self.number.to_s.strip
+        number_f = number.to_f
         format = options[:format]
 
-        if is_negative?(number)
-          format = options[:negative_format]
-          number = absolute_value(number)
+        if number_f.negative?
+          number = number_f.abs
+
+          unless options[:precision] == 0 && number < 0.5
+            format = options[:negative_format]
+          end
         end
 
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        format.gsub(/%n/, rounded_number).gsub(/%u/, options[:unit])
+        format.gsub("%n", rounded_number).gsub("%u", 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-/, '')
-        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,23 +1,30 @@
+# frozen_string_literal: true
+
+require "active_support/number_helper/number_converter"
+
 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])
       end
 
       private
-
         def parts
-          left, right = number.to_s.split('.')
-          left.gsub!(DELIMITED_REGEX) do |digit_to_delimit|
+          left, right = number.to_s.split(".")
+          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,7 @@
+# frozen_string_literal: true
+
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToHumanConverter < NumberConverter # :nodoc:
@@ -9,6 +13,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 +23,25 @@ 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", rounded_number).gsub("%u", 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 +57,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,11 @@
+# frozen_string_literal: true
+
+require "active_support/number_helper/number_converter"
+
 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 +21,23 @@ 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", number_to_format).gsub("%u", 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 +53,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,7 @@
+# frozen_string_literal: true
+
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToPercentageConverter < NumberConverter # :nodoc:
@@ -5,7 +9,7 @@ module ActiveSupport
 
       def convert
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        options[:format].gsub(/%n/, rounded_number)
+        options[:format].gsub("%n", rounded_number)
       end
     end
   end

data/lib/active_support/number_helper/number_to_phone_converter.rb

@@ -1,14 +1,17 @@
+# frozen_string_literal: true
+
+require "active_support/number_helper/number_converter"
+
 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
 
       private
-
         def convert_to_phone_number(number)
           if opts[:area_code]
             convert_with_area_code(number)
@@ -18,12 +21,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 +50,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
-