activesupport 5.2.6 → 6.0.0.beta1

data/lib/active_support/notifications/instrumenter.rb

@@ -52,8 +52,13 @@ module ActiveSupport
     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_PROCESS_CPUTIME_ID) &&
+          !Gem.win_platform?
+      end
+      private_class_method :clock_gettime_supported?
 
       def initialize(name, start, ending, transaction_id, payload)
         @name           = name
@@ -63,6 +68,47 @@ module ActiveSupport
         @end            = ending
         @children       = []
         @duration       = nil
+        @cpu_time_start = nil
+        @cpu_time_finish = nil
+        @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
@@ -88,6 +134,31 @@ module ActiveSupport
       def parent_of?(event)
         @children.include? event
       end
+
+      private
+        def now
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+
+        if clock_gettime_supported?
+          def now_cpu
+            Process.clock_gettime(Process::CLOCK_PROCESS_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/number_helper.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/dependencies/autoload"
+
 module ActiveSupport
   module NumberHelper
     extend ActiveSupport::Autoload
@@ -85,6 +87,9 @@ module ActiveSupport
     #   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.
+    # * <tt>:strip_insignificant_zeros</tt> - If +true+ removes
+    #   insignificant zeros after the decimal separator (defaults to
+    #   +false+).
     #
     # ==== Examples
     #
@@ -100,6 +105,8 @@ module ActiveSupport
     #   # => "&pound;1234567890,50"
     #   number_to_currency(1234567890.50, unit: '&pound;', separator: ',', delimiter: '', format: '%n %u')
     #   # => "1234567890,50 &pound;"
+    #   number_to_currency(1234567890.50, strip_insignificant_zeros: true)
+    #   # => "$1,234,567,890.5"
     def number_to_currency(number, options = {})
       NumberToCurrencyConverter.convert(number, options)
     end

data/lib/active_support/number_helper/number_to_currency_converter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/numeric/inquiry"
+require "active_support/number_helper/number_converter"
 
 module ActiveSupport
   module NumberHelper
@@ -17,7 +17,7 @@ module ActiveSupport
         end
 
         rounded_number = NumberToRoundedConverter.convert(number, options)
-        format.gsub("%n".freeze, rounded_number).gsub("%u".freeze, options[:unit])
+        format.gsub("%n", rounded_number).gsub("%u", options[:unit])
       end
 
       private

data/lib/active_support/number_helper/number_to_delimited_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToDelimitedConverter < NumberConverter #:nodoc:
@@ -14,7 +16,7 @@ module ActiveSupport
       private
 
         def parts
-          left, right = number.to_s.split(".".freeze)
+          left, right = number.to_s.split(".")
           left.gsub!(delimiter_pattern) do |digit_to_delimit|
             "#{digit_to_delimit}#{options[:delimiter]}"
           end

data/lib/active_support/number_helper/number_to_human_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToHumanConverter < NumberConverter # :nodoc:
@@ -25,7 +27,7 @@ module ActiveSupport
 
         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", rounded_number).gsub("%u", unit).strip
       end
 
       private

data/lib/active_support/number_helper/number_to_human_size_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToHumanSizeConverter < NumberConverter #:nodoc:
@@ -22,7 +24,7 @@ module ActiveSupport
           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", number_to_format).gsub("%u", unit)
       end
 
       private

data/lib/active_support/number_helper/number_to_percentage_converter.rb

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

data/lib/active_support/number_helper/number_to_phone_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToPhoneConverter < NumberConverter #:nodoc:

data/lib/active_support/number_helper/number_to_rounded_converter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/number_helper/number_converter"
+
 module ActiveSupport
   module NumberHelper
     class NumberToRoundedConverter < NumberConverter # :nodoc:
@@ -20,9 +22,9 @@ module ActiveSupport
           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 << "0" * precision
+              a, b = s.split(".", 2)
+              a << "."
               a << b[0, precision]
             else
               "%00.#{precision}f" % rounded_number

data/lib/active_support/ordered_options.rb

@@ -39,7 +39,7 @@ module ActiveSupport
     end
 
     def method_missing(name, *args)
-      name_string = name.to_s.dup
+      name_string = name.to_s
       if name_string.chomp!("=")
         self[name_string] = args.first
       else

data/lib/active_support/parameter_filter.rb

@@ -0,0 +1,124 @@
+# 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
+  # hash-like object and replace corresponding value. Filtering only certain
+  # sub-keys from a hash is possible by using the dot notation:
+  # 'credit_card.number'. If a proc is given, each key and value of a hash and
+  # all sub-hashes are passed to it, where the value or the key can be replaced
+  # using String#replace or similar methods.
+  #
+  #   ActiveSupport::ParameterFilter.new([:password])
+  #   => replaces the value to all keys matching /password/i with "[FILTERED]"
+  #
+  #   ActiveSupport::ParameterFilter.new([:foo, "bar"])
+  #   => replaces the value to all keys matching /foo|bar/i with "[FILTERED]"
+  #
+  #   ActiveSupport::ParameterFilter.new(["credit_card.code"])
+  #   => replaces { credit_card: {code: "xxxx"} } with "[FILTERED]", does not
+  #   change { file: { code: "xxxx"} }
+  #
+  #   ActiveSupport::ParameterFilter.new([-> (k, v) do
+  #     v.reverse! if k =~ /secret/i
+  #   end])
+  #   => reverses the value to all keys matching /secret/i
+  class ParameterFilter
+    FILTERED = "[FILTERED]" # :nodoc:
+
+    # Create instance with given filters. Supported type of filters are +String+, +Regexp+, and +Proc+.
+    # Other types of filters are treated as +String+ using +to_s+.
+    # For +Proc+ filters, key, value, and optional original hash is passed to block arguments.
+    #
+    # ==== Options
+    #
+    # * <tt>:mask</tt> - A replaced object when filtered. Defaults to +"[FILTERED]"+
+    def initialize(filters = [], mask: FILTERED)
+      @filters = filters
+      @mask = mask
+    end
+
+    # Mask value of +params+ if key matches one of filters.
+    def filter(params)
+      compiled_filter.call(params)
+    end
+
+    # Returns filtered value for given key. For +Proc+ filters, third block argument is not populated.
+    def filter_param(key, value)
+      @filters.empty? ? value : compiled_filter.value_for_key(key, value)
+    end
+
+  private
+
+    def compiled_filter
+      @compiled_filter ||= CompiledFilter.compile(@filters, mask: @mask)
+    end
+
+    class CompiledFilter # :nodoc:
+      def self.compile(filters, mask:)
+        return lambda { |params| params.dup } if filters.empty?
+
+        strings, regexps, blocks = [], [], []
+
+        filters.each do |item|
+          case item
+          when Proc
+            blocks << item
+          when Regexp
+            regexps << item
+          else
+            strings << Regexp.escape(item.to_s)
+          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?
+
+        new regexps, deep_regexps, blocks, mask: mask
+      end
+
+      attr_reader :regexps, :deep_regexps, :blocks
+
+      def initialize(regexps, deep_regexps, blocks, mask:)
+        @regexps = regexps
+        @deep_regexps = deep_regexps.any? ? deep_regexps : nil
+        @blocks = blocks
+        @mask = mask
+      end
+
+      def call(params, parents = [], original_params = params)
+        filtered_params = params.class.new
+
+        params.each do |key, value|
+          filtered_params[key] = value_for_key(key, value, parents, original_params)
+        end
+
+        filtered_params
+      end
+
+      def value_for_key(key, value, parents = [], original_params = nil)
+        parents.push(key) if deep_regexps
+        if regexps.any? { |r| r.match?(key) }
+          value = @mask
+        elsif deep_regexps && (joined = parents.join(".")) && deep_regexps.any? { |r| r.match?(joined) }
+          value = @mask
+        elsif value.is_a?(Hash)
+          value = call(value, parents, original_params)
+        elsif value.is_a?(Array)
+          value = value.map { |v| v.is_a?(Hash) ? call(v, parents, original_params) : v }
+        elsif blocks.any?
+          key = key.dup if key.duplicable?
+          value = value.dup if value.duplicable?
+          blocks.each { |b| b.arity == 2 ? b.call(key, value) : b.call(key, value, original_params) }
+        end
+        parents.pop if deep_regexps
+        value
+      end
+    end
+  end
+end

data/lib/active_support/rails.rb

@@ -27,9 +27,3 @@ require "active_support/core_ext/module/delegation"
 
 # Defines ActiveSupport::Deprecation.
 require "active_support/deprecation"
-
-# Defines Regexp#match?.
-#
-# This should be removed when Rails needs Ruby 2.4 or later, and the require
-# added where other Regexp extensions are being used (easy to grep).
-require "active_support/core_ext/regexp"

data/lib/active_support/reloader.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/execution_wrapper"
+require "active_support/executor"
 
 module ActiveSupport
   #--
@@ -49,11 +50,9 @@ module ActiveSupport
     def self.reload!
       executor.wrap do
         new.tap do |instance|
-          begin
-            instance.run!
-          ensure
-            instance.complete!
-          end
+          instance.run!
+        ensure
+          instance.complete!
         end
       end
       prepare!

data/lib/active_support/subscriber.rb

@@ -54,25 +54,20 @@ module ActiveSupport
         @@subscribers ||= []
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
-      attr_reader :subscriber, :notifier, :namespace
-
       private
+        attr_reader :subscriber, :notifier, :namespace
 
-      def add_event_subscriber(event) # :doc:
-        return if %w{ start finish }.include?(event.to_s)
+        def add_event_subscriber(event) # :doc:
+          return if %w{ start finish }.include?(event.to_s)
 
-        pattern = "#{event}.#{namespace}"
+          pattern = "#{event}.#{namespace}"
 
-        # Don't add multiple subscribers (eg. if methods are redefined).
-        return if subscriber.patterns.include?(pattern)
+          # Don't add multiple subscribers (eg. if methods are redefined).
+          return if subscriber.patterns.include?(pattern)
 
-        subscriber.patterns << pattern
-        notifier.subscribe(pattern, subscriber)
-      end
+          subscriber.patterns << pattern
+          notifier.subscribe(pattern, subscriber)
+        end
     end
 
     attr_reader :patterns # :nodoc:
@@ -84,32 +79,27 @@ module ActiveSupport
     end
 
     def start(name, id, payload)
-      e = ActiveSupport::Notifications::Event.new(name, now, nil, id, payload)
+      event = ActiveSupport::Notifications::Event.new(name, nil, nil, id, payload)
+      event.start!
       parent = event_stack.last
-      parent << e if parent
+      parent << event if parent
 
-      event_stack.push e
+      event_stack.push event
     end
 
     def finish(name, id, payload)
-      finished  = now
-      event     = event_stack.pop
-      event.end = finished
+      event = event_stack.pop
+      event.finish!
       event.payload.merge!(payload)
 
-      method = name.split(".".freeze).first
+      method = name.split(".").first
       send(method, event)
     end
 
     private
-
       def event_stack
         SubscriberQueueRegistry.instance.get_queue(@queue_key)
       end
-
-      def now
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
   end
 
   # This is a registry for all the event stacks kept for subscribers.