activesupport 6.1.4.2 → 7.0.2.3

data/lib/active_support/number_helper/number_to_currency_converter.rb

@@ -8,16 +8,21 @@ module ActiveSupport
       self.namespace = :currency
 
       def convert
-        number = self.number.to_s.strip
         format = options[:format]
 
-        if number.sub!(/^-/, "") &&
-           (options[:precision] != 0 || number.to_f > 0.5)
-          format = options[:negative_format]
+        number_f = valid_float?
+        if number_f
+          if number_f.negative?
+            number_f = number_f.abs
+            format = options[:negative_format] if (number_f * 10**options[:precision]) >= 0.5
+          end
+          number_s = NumberToRoundedConverter.convert(number_f, options)
+        else
+          number_s = number.to_s.strip
+          format = options[:negative_format] if number_s.sub!(/^-/, "")
         end
 
-        rounded_number = NumberToRoundedConverter.convert(number, options)
-        format.gsub("%n", rounded_number).gsub("%u", options[:unit])
+        format.gsub("%n", number_s).gsub("%u", options[:unit])
       end
 
       private

data/lib/active_support/number_helper/number_to_delimited_converter.rb

@@ -4,7 +4,7 @@ require "active_support/number_helper/number_converter"
 
 module ActiveSupport
   module NumberHelper
-    class NumberToDelimitedConverter < NumberConverter #:nodoc:
+    class NumberToDelimitedConverter < NumberConverter # :nodoc:
       self.validate_float = true
 
       DEFAULT_DELIMITER_REGEX = /(\d)(?=(\d\d\d)+(?!\d))/

data/lib/active_support/number_helper/number_to_human_size_converter.rb

@@ -4,7 +4,7 @@ require "active_support/number_helper/number_converter"
 
 module ActiveSupport
   module NumberHelper
-    class NumberToHumanSizeConverter < NumberConverter #:nodoc:
+    class NumberToHumanSizeConverter < NumberConverter # :nodoc:
       STORAGE_UNITS = [:byte, :kb, :mb, :gb, :tb, :pb, :eb]
 
       self.namespace      = :human

data/lib/active_support/number_helper/number_to_phone_converter.rb

@@ -4,7 +4,7 @@ require "active_support/number_helper/number_converter"
 
 module ActiveSupport
   module NumberHelper
-    class NumberToPhoneConverter < NumberConverter #:nodoc:
+    class NumberToPhoneConverter < NumberConverter # :nodoc:
       def convert
         str = country_code(opts[:country_code]).dup
         str << convert_to_phone_number(number.to_s.strip)

data/lib/active_support/number_helper/rounding_helper.rb

@@ -35,16 +35,12 @@ module ActiveSupport
         end
 
         def absolute_precision(number)
-          if significant && options[:precision] > 0
+          if options[:significant] && options[:precision] > 0
             options[:precision] - digit_count(convert_to_decimal(number))
           else
             options[:precision]
           end
         end
-
-        def significant
-          options[:significant]
-        end
     end
   end
 end

data/lib/active_support/number_helper.rb

@@ -99,8 +99,6 @@ 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)')

data/lib/active_support/option_merger.rb

@@ -1,10 +1,9 @@
 # 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:
+  class OptionMerger # :nodoc:
     instance_methods.each do |method|
       undef_method(method) unless method.start_with?("__", "instance_eval", "class", "object_id")
     end
@@ -25,22 +24,15 @@ module ActiveSupport
           options = @options
         end
 
-        invoke_method(method, arguments, options, &block)
-      end
-
-      if RUBY_VERSION >= "2.7"
-        def invoke_method(method, arguments, options, &block)
-          if options
-            @context.__send__(method, *arguments, **options, &block)
-          else
-            @context.__send__(method, *arguments, &block)
-          end
-        end
-      else
-        def invoke_method(method, arguments, options, &block)
-          arguments << options.dup if options
+        if options
+          @context.__send__(method, *arguments, **options, &block)
+        else
           @context.__send__(method, *arguments, &block)
         end
       end
+
+      def respond_to_missing?(*arguments)
+        @context.respond_to?(*arguments)
+      end
   end
 end

data/lib/active_support/ordered_hash.rb

@@ -21,7 +21,7 @@ module ActiveSupport
   #
   # <tt>ActiveSupport::OrderedHash</tt> is namespaced to prevent conflicts
   # with other implementations.
-  class OrderedHash < ::Hash
+  class OrderedHash < ::Hash # :nodoc:
     def to_yaml_type
       "!tag:yaml.org,2002:omap"
     end

data/lib/active_support/parameter_filter.rb

@@ -16,6 +16,11 @@ module ActiveSupport
   #   ActiveSupport::ParameterFilter.new([:foo, "bar"])
   #   => replaces the value to all keys matching /foo|bar/i with "[FILTERED]"
   #
+  #   ActiveSupport::ParameterFilter.new([/\Apin\z/i, /\Apin_/i])
+  #   => replaces the value for the exact (case-insensitive) key 'pin' and all
+  #   (case-insensitive) keys beginning with 'pin_', with "[FILTERED]".
+  #   Does not match keys with 'pin' as a substring, such as 'shipping_id'.
+  #
   #   ActiveSupport::ParameterFilter.new(["credit_card.code"])
   #   => replaces { credit_card: {code: "xxxx"} } with "[FILTERED]", does not
   #   change { file: { code: "xxxx"} }

data/lib/active_support/per_thread_registry.rb

@@ -40,6 +40,10 @@ module ActiveSupport
   # If the class has an initializer, it must accept no arguments.
   module PerThreadRegistry
     def self.extended(object)
+      ActiveSupport::Deprecation.warn(<<~MSG)
+        ActiveSupport::PerThreadRegistry is deprecated and will be removed in Rails 7.1.
+        Use `Module#thread_mattr_accessor` instead.
+      MSG
       object.instance_variable_set :@per_thread_registry_key, object.name.freeze
     end
 
@@ -56,5 +60,6 @@ module ActiveSupport
 
         send(name, *args, &block)
       end
+      ruby2_keywords(:method_missing)
   end
 end

data/lib/active_support/railtie.rb

@@ -6,9 +6,25 @@ require "active_support/i18n_railtie"
 module ActiveSupport
   class Railtie < Rails::Railtie # :nodoc:
     config.active_support = ActiveSupport::OrderedOptions.new
+    config.active_support.disable_to_s_conversion = false
 
     config.eager_load_namespaces << ActiveSupport
 
+    initializer "active_support.isolation_level" do |app|
+      if level = app.config.active_support.delete(:isolation_level)
+        ActiveSupport::IsolatedExecutionState.isolation_level = level
+      end
+    end
+
+    initializer "active_support.remove_deprecated_time_with_zone_name" do |app|
+      config.after_initialize do
+        if app.config.active_support.remove_deprecated_time_with_zone_name
+          require "active_support/time_with_zone"
+          TimeWithZone.singleton_class.remove_method(:name)
+        end
+      end
+    end
+
     initializer "active_support.set_authenticated_message_encryption" do |app|
       config.after_initialize do
         unless app.config.active_support.use_authenticated_message_encryption.nil?
@@ -18,28 +34,50 @@ module ActiveSupport
       end
     end
 
+    initializer "active_support.reset_execution_context" do |app|
+      app.reloader.before_class_unload { ActiveSupport::ExecutionContext.clear }
+      app.executor.to_run              { ActiveSupport::ExecutionContext.clear }
+      app.executor.to_complete         { ActiveSupport::ExecutionContext.clear }
+    end
+
     initializer "active_support.reset_all_current_attributes_instances" do |app|
+      executor_around_test_case = app.config.active_support.executor_around_test_case
+
       app.reloader.before_class_unload { ActiveSupport::CurrentAttributes.clear_all }
       app.executor.to_run              { ActiveSupport::CurrentAttributes.reset_all }
       app.executor.to_complete         { ActiveSupport::CurrentAttributes.reset_all }
 
       ActiveSupport.on_load(:active_support_test_case) do
-        require "active_support/current_attributes/test_helper"
-        include ActiveSupport::CurrentAttributes::TestHelper
+        if executor_around_test_case
+          require "active_support/executor/test_helper"
+          include ActiveSupport::Executor::TestHelper
+        else
+          require "active_support/current_attributes/test_helper"
+          include ActiveSupport::CurrentAttributes::TestHelper
+
+          require "active_support/execution_context/test_helper"
+          include ActiveSupport::ExecutionContext::TestHelper
+        end
       end
     end
 
     initializer "active_support.deprecation_behavior" do |app|
-      if deprecation = app.config.active_support.deprecation
-        ActiveSupport::Deprecation.behavior = deprecation
-      end
+      if app.config.active_support.report_deprecations == false
+        ActiveSupport::Deprecation.silenced = true
+        ActiveSupport::Deprecation.behavior = :silence
+        ActiveSupport::Deprecation.disallowed_behavior = :silence
+      else
+        if deprecation = app.config.active_support.deprecation
+          ActiveSupport::Deprecation.behavior = deprecation
+        end
 
-      if disallowed_deprecation = app.config.active_support.disallowed_deprecation
-        ActiveSupport::Deprecation.disallowed_behavior = disallowed_deprecation
-      end
+        if disallowed_deprecation = app.config.active_support.disallowed_deprecation
+          ActiveSupport::Deprecation.disallowed_behavior = disallowed_deprecation
+        end
 
-      if disallowed_warnings = app.config.active_support.disallowed_deprecation_warnings
-        ActiveSupport::Deprecation.disallowed_warnings = disallowed_warnings
+        if disallowed_warnings = app.config.active_support.disallowed_deprecation_warnings
+          ActiveSupport::Deprecation.disallowed_warnings = disallowed_warnings
+        end
       end
     end
 
@@ -75,6 +113,10 @@ module ActiveSupport
       end
     end
 
+    initializer "active_support.set_error_reporter" do |app|
+      ActiveSupport.error_reporter = app.executor.error_reporter
+    end
+
     initializer "active_support.set_configs" do |app|
       app.config.active_support.each do |k, v|
         k = "#{k}="
@@ -84,19 +126,27 @@ module ActiveSupport
 
     initializer "active_support.set_hash_digest_class" do |app|
       config.after_initialize do
-        if app.config.active_support.use_sha1_digests
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            config.active_support.use_sha1_digests is deprecated and will
-            be removed from Rails 6.2. Use
-            config.active_support.hash_digest_class = ::Digest::SHA1 instead.
-          MSG
-          ActiveSupport::Digest.hash_digest_class = ::Digest::SHA1
-        end
-
         if klass = app.config.active_support.hash_digest_class
           ActiveSupport::Digest.hash_digest_class = klass
         end
       end
     end
+
+    initializer "active_support.set_key_generator_hash_digest_class" do |app|
+      config.after_initialize do
+        if klass = app.config.active_support.key_generator_hash_digest_class
+          ActiveSupport::KeyGenerator.hash_digest_class = klass
+        end
+      end
+    end
+
+    initializer "active_support.set_rfc4122_namespaced_uuids" do |app|
+      config.after_initialize do
+        if app.config.active_support.use_rfc4122_namespaced_uuids
+          require "active_support/core_ext/digest"
+          ::Digest::UUID.use_rfc4122_namespaced_uuids = app.config.active_support.use_rfc4122_namespaced_uuids
+        end
+      end
+    end
   end
 end

data/lib/active_support/reloader.rb

@@ -58,7 +58,7 @@ module ActiveSupport
       prepare!
     end
 
-    def self.run! # :nodoc:
+    def self.run!(reset: false) # :nodoc:
       if check!
         super
       else

data/lib/active_support/rescuable.rb

@@ -100,7 +100,7 @@ module ActiveSupport
         end
       end
 
-      def handler_for_rescue(exception, object: self) #:nodoc:
+      def handler_for_rescue(exception, object: self) # :nodoc:
         case rescuer = find_rescue_handler(exception)
         when Symbol
           method = object.method(rescuer)
@@ -167,7 +167,7 @@ module ActiveSupport
 
     # Internal handler lookup. Delegates to class method. Some libraries call
     # this directly, so keeping it around for compatibility.
-    def handler_for_rescue(exception) #:nodoc:
+    def handler_for_rescue(exception) # :nodoc:
       self.class.handler_for_rescue exception, object: self
     end
   end

data/lib/active_support/ruby_features.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module RubyFeatures # :nodoc:
+    CLASS_SUBCLASSES = Class.method_defined?(:subclasses) # RUBY_VERSION >= "3.1"
+  end
+end

data/lib/active_support/secure_compare_rotator.rb

@@ -17,7 +17,7 @@ module ActiveSupport
   #
   #   class MyController < ApplicationController
   #     def authenticate_request
-  #       rotator = ActiveSupport::SecureComparerotator.new('new_password')
+  #       rotator = ActiveSupport::SecureCompareRotator.new('new_password')
   #       rotator.rotate('old_password')
   #
   #       authenticate_or_request_with_http_basic do |username, password|

data/lib/active_support/string_inquirer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/symbol/starts_ends_with"
-
 module ActiveSupport
   # Wrapping a string in this class gives you a prettier way to test
   # for equality. The value returned by <tt>Rails.env</tt> is wrapped

data/lib/active_support/subscriber.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/per_thread_registry"
 require "active_support/notifications"
 
 module ActiveSupport
@@ -150,25 +149,15 @@ module ActiveSupport
       send(method, event)
     end
 
+    def publish_event(event) # :nodoc:
+      method = event.name.split(".").first
+      send(method, event)
+    end
+
     private
       def event_stack
-        SubscriberQueueRegistry.instance.get_queue(@queue_key)
+        registry = ActiveSupport::IsolatedExecutionState[:active_support_subscriber_queue_registry] ||= {}
+        registry[@queue_key] ||= []
       end
   end
-
-  # This is a registry for all the event stacks kept for subscribers.
-  #
-  # See the documentation of <tt>ActiveSupport::PerThreadRegistry</tt>
-  # for further details.
-  class SubscriberQueueRegistry # :nodoc:
-    extend PerThreadRegistry
-
-    def initialize
-      @registry = {}
-    end
-
-    def get_queue(queue_key)
-      @registry[queue_key] ||= []
-    end
-  end
 end

data/lib/active_support/tagged_logging.rb

@@ -57,7 +57,7 @@ module ActiveSupport
       def current_tags
         # We use our object ID here to avoid conflicting with other instances
         thread_key = @thread_key ||= "activesupport_tagged_logging_tags:#{object_id}"
-        Thread.current[thread_key] ||= []
+        IsolatedExecutionState[thread_key] ||= []
       end
 
       def tags_text
@@ -79,7 +79,7 @@ module ActiveSupport
     end
 
     def self.new(logger)
-      logger = logger.dup
+      logger = logger.clone
 
       if logger.formatter
         logger.formatter = logger.formatter.dup

data/lib/active_support/test_case.rb

@@ -12,6 +12,7 @@ require "active_support/testing/constant_lookup"
 require "active_support/testing/time_helpers"
 require "active_support/testing/file_fixtures"
 require "active_support/testing/parallelization"
+require "active_support/testing/parallelize_executor"
 require "concurrent/utility/processor_counter"
 
 module ActiveSupport
@@ -71,26 +72,17 @@ module ActiveSupport
       #
       # The threaded parallelization uses minitest's parallel executor directly.
       # The processes parallelization uses a Ruby DRb server.
-      def parallelize(workers: :number_of_processors, with: :processes)
+      #
+      # Because parallelization presents an overhead, it is only enabled when the
+      # number of tests to run is above the +threshold+ param. The default value is
+      # 50, and it's configurable via +config.active_support.test_parallelization_threshold+.
+      def parallelize(workers: :number_of_processors, with: :processes, threshold: ActiveSupport.test_parallelization_threshold)
         workers = Concurrent.physical_processor_count if workers == :number_of_processors
         workers = ENV["PARALLEL_WORKERS"].to_i if ENV["PARALLEL_WORKERS"]
 
         return if workers <= 1
 
-        executor = case with
-                   when :processes
-                     Testing::Parallelization.new(workers)
-                   when :threads
-                     Minitest::Parallel::Executor.new(workers)
-                   else
-                     raise ArgumentError, "#{with} is not a supported parallelization executor."
-        end
-
-        self.lock_threads = false if defined?(self.lock_threads) && with == :threads
-
-        Minitest.parallel_executor = executor
-
-        parallelize_me!
+        Minitest.parallel_executor = ActiveSupport::Testing::ParallelizeExecutor.new(size: workers, with: with, threshold: threshold)
       end
 
       # Set up hook for parallel testing. This can be used if you have multiple
@@ -107,9 +99,7 @@ module ActiveSupport
       #     end
       #   end
       def parallelize_setup(&block)
-        ActiveSupport::Testing::Parallelization.after_fork_hook do |worker|
-          yield worker
-        end
+        ActiveSupport::Testing::Parallelization.after_fork_hook(&block)
       end
 
       # Clean up hook for parallel testing. This can be used to drop databases
@@ -126,9 +116,7 @@ module ActiveSupport
       #     end
       #   end
       def parallelize_teardown(&block)
-        ActiveSupport::Testing::Parallelization.run_cleanup_hook do |worker|
-          yield worker
-        end
+        ActiveSupport::Testing::Parallelization.run_cleanup_hook(&block)
       end
     end
 

data/lib/active_support/testing/assertions.rb

@@ -99,7 +99,7 @@ module ActiveSupport
         }
         before = exps.map(&:call)
 
-        retval = assert_nothing_raised(&block)
+        retval = _assert_nothing_raised_or_warn("assert_difference", &block)
 
         expressions.zip(exps, before) do |(code, diff), exp, before_value|
           error  = "#{code.inspect} didn't change by #{diff}"
@@ -176,7 +176,7 @@ module ActiveSupport
         exp = expression.respond_to?(:call) ? expression : -> { eval(expression.to_s, block.binding) }
 
         before = exp.call
-        retval = assert_nothing_raised(&block)
+        retval = _assert_nothing_raised_or_warn("assert_changes", &block)
 
         unless from == UNTRACKED
           error = "Expected change from #{from.inspect}"
@@ -189,7 +189,7 @@ module ActiveSupport
         error = "#{expression.inspect} didn't change"
         error = "#{error}. It was already #{to}" if before == to
         error = "#{message}.\n#{error}" if message
-        assert_not_equal before, after, error
+        refute_equal before, after, error
 
         unless to == UNTRACKED
           error = "Expected change to #{to}\n"
@@ -207,16 +207,30 @@ module ActiveSupport
       #     post :create, params: { status: { ok: true } }
       #   end
       #
+      # Provide the optional keyword argument :from to specify the expected
+      # initial value.
+      #
+      #   assert_no_changes -> { Status.all_good? }, from: true do
+      #     post :create, params: { status: { ok: true } }
+      #   end
+      #
       # An error message can be specified.
       #
       #   assert_no_changes -> { Status.all_good? }, 'Expected the status to be good' do
       #     post :create, params: { status: { ok: false } }
       #   end
-      def assert_no_changes(expression, message = nil, &block)
+      def assert_no_changes(expression, message = nil, from: UNTRACKED, &block)
         exp = expression.respond_to?(:call) ? expression : -> { eval(expression.to_s, block.binding) }
 
         before = exp.call
-        retval = assert_nothing_raised(&block)
+        retval = _assert_nothing_raised_or_warn("assert_no_changes", &block)
+
+        unless from == UNTRACKED
+          error = "Expected initial value of #{from.inspect}"
+          error = "#{message}.\n#{error}" if message
+          assert from === before, error
+        end
+
         after = exp.call
 
         error = "#{expression.inspect} changed"
@@ -230,6 +244,22 @@ module ActiveSupport
 
         retval
       end
+
+      private
+        def _assert_nothing_raised_or_warn(assertion, &block)
+          assert_nothing_raised(&block)
+        rescue Minitest::UnexpectedError => e
+          if tagged_logger && tagged_logger.warn?
+            warning = <<~MSG
+              #{self.class} - #{name}: #{e.error.class} raised.
+              If you expected this exception, use `assert_raises` as near to the code that raises as possible.
+              Other block based assertions (e.g. `#{assertion}`) can be used, as long as `assert_raises` is inside their block.
+            MSG
+            tagged_logger.warn warning
+          end
+
+          raise
+        end
     end
   end
 end

data/lib/active_support/testing/deprecation.rb

@@ -4,7 +4,30 @@ require "active_support/deprecation"
 
 module ActiveSupport
   module Testing
-    module Deprecation #:nodoc:
+    module Deprecation
+      # Asserts that a matching deprecation warning was emitted by the given deprecator during the execution of the yielded block.
+      #
+      #   assert_deprecated(/foo/, CustomDeprecator) do
+      #     CustomDeprecator.warn "foo should no longer be used"
+      #   end
+      #
+      # The +match+ object may be a +Regexp+, or +String+ appearing in the message.
+      #
+      #   assert_deprecated('foo', CustomDeprecator) do
+      #     CustomDeprecator.warn "foo should no longer be used"
+      #   end
+      #
+      # If the +match+ is omitted (or explicitly +nil+), any deprecation warning will match.
+      #
+      #   assert_deprecated(nil, CustomDeprecator) do
+      #     CustomDeprecator.warn "foo should no longer be used"
+      #   end
+      #
+      # If no +deprecator+ is given, defaults to ActiveSupport::Deprecation.
+      #
+      #   assert_deprecated do
+      #     ActiveSupport::Deprecation.warn "foo should no longer be used"
+      #   end
       def assert_deprecated(match = nil, deprecator = nil, &block)
         result, warnings = collect_deprecations(deprecator, &block)
         assert !warnings.empty?, "Expected a deprecation warning within the block but received none"
@@ -15,12 +38,40 @@ module ActiveSupport
         result
       end
 
+      # Asserts that no deprecation warnings are emitted by the given deprecator during the execution of the yielded block.
+      #
+      #   assert_not_deprecated(CustomDeprecator) do
+      #     CustomDeprecator.warn "message" # fails assertion
+      #   end
+      #
+      # If no +deprecator+ is given, defaults to ActiveSupport::Deprecation.
+      #
+      #   assert_not_deprecated do
+      #     ActiveSupport::Deprecation.warn "message" # fails assertion
+      #   end
+      #
+      #   assert_not_deprecated do
+      #     CustomDeprecator.warn "message" # passes assertion
+      #   end
       def assert_not_deprecated(deprecator = nil, &block)
         result, deprecations = collect_deprecations(deprecator, &block)
         assert deprecations.empty?, "Expected no deprecation warning within the block but received #{deprecations.size}: \n  #{deprecations * "\n  "}"
         result
       end
 
+      # Returns an array of all the deprecation warnings emitted by the given
+      # +deprecator+ during the execution of the yielded block.
+      #
+      #   collect_deprecations(CustomDeprecator) do
+      #     CustomDeprecator.warn "message"
+      #   end # => ["message"]
+      #
+      # If no +deprecator+ is given, defaults to ActiveSupport::Deprecation.
+      #
+      #   collect_deprecations do
+      #     CustomDeprecator.warn "custom message"
+      #     ActiveSupport::Deprecation.warn "message"
+      #   end # => ["message"]
       def collect_deprecations(deprecator = nil)
         deprecator ||= ActiveSupport::Deprecation
         old_behavior = deprecator.behavior

data/lib/active_support/testing/isolation.rb

@@ -5,7 +5,7 @@ module ActiveSupport
     module Isolation
       require "thread"
 
-      def self.included(klass) #:nodoc:
+      def self.included(klass) # :nodoc:
         klass.class_eval do
           parallelize_me!
         end
@@ -63,7 +63,7 @@ module ActiveSupport
       module Subprocess
         ORIG_ARGV = ARGV.dup unless defined?(ORIG_ARGV)
 
-        # Crazy H4X to get this working in windows / jruby with
+        # Complicated H4X to get this working in windows / jruby with
         # no forking.
         def run_in_isolation(&blk)
           require "tempfile"