activesupport 6.1.7.8 → 7.0.0.alpha1

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,20 +24,9 @@ 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

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

@@ -56,6 +56,6 @@ module ActiveSupport
 
         send(name, *args, &block)
       end
-      ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+      ruby2_keywords(:method_missing)
   end
 end

data/lib/active_support/railtie.rb

@@ -9,6 +9,15 @@ module ActiveSupport
 
     config.eager_load_namespaces << ActiveSupport
 
+    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?
@@ -30,16 +39,22 @@ module ActiveSupport
     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
 
@@ -88,9 +103,9 @@ module ActiveSupport
           ActiveSupport::Deprecation.warn(<<-MSG.squish)
             config.active_support.use_sha1_digests is deprecated and will
             be removed from Rails 7.0. Use
-            config.active_support.hash_digest_class = ::Digest::SHA1 instead.
+            config.active_support.hash_digest_class = OpenSSL::Digest::SHA1 instead.
           MSG
-          ActiveSupport::Digest.hash_digest_class = ::Digest::SHA1
+          ActiveSupport::Digest.hash_digest_class = OpenSSL::Digest::SHA1
         end
 
         if klass = app.config.active_support.hash_digest_class
@@ -98,5 +113,13 @@ module ActiveSupport
         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
   end
 end

data/lib/active_support/reloader.rb

@@ -58,7 +58,7 @@ module ActiveSupport
       prepare!
     end
 
-    def self.run!(reset: false) # :nodoc:
+    def self.run! # :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/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

@@ -150,6 +150,11 @@ 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)

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}"
@@ -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,7 @@ require "active_support/deprecation"
 
 module ActiveSupport
   module Testing
-    module Deprecation #:nodoc:
+    module Deprecation # :nodoc:
       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"

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

data/lib/active_support/testing/method_call_assertions.rb

@@ -6,10 +6,10 @@ module ActiveSupport
   module Testing
     module MethodCallAssertions # :nodoc:
       private
-        def assert_called(object, method_name, message = nil, times: 1, returns: nil)
+        def assert_called(object, method_name, message = nil, times: 1, returns: nil, &block)
           times_called = 0
 
-          object.stub(method_name, proc { times_called += 1; returns }) { yield }
+          object.stub(method_name, proc { times_called += 1; returns }, &block)
 
           error = "Expected #{method_name} to be called #{times} times, " \
             "but was called #{times_called} times"
@@ -17,16 +17,16 @@ module ActiveSupport
           assert_equal times, times_called, error
         end
 
-        def assert_called_with(object, method_name, args, returns: nil)
+        def assert_called_with(object, method_name, args, returns: nil, &block)
           mock = Minitest::Mock.new
 
-          if args.all? { |arg| arg.is_a?(Array) }
+          if args.all?(Array)
             args.each { |arg| mock.expect(:call, returns, arg) }
           else
             mock.expect(:call, returns, args)
           end
 
-          object.stub(method_name, mock) { yield }
+          object.stub(method_name, mock, &block)
 
           mock.verify
         end

data/lib/active_support/testing/parallelization/server.rb

@@ -49,6 +49,10 @@ module ActiveSupport
           @active_workers.size > 0
         end
 
+        def interrupt
+          @queue.clear
+        end
+
         def shutdown
           # Wait for initial queue to drain
           while @queue.length != 0

data/lib/active_support/testing/parallelization/worker.rb

@@ -69,6 +69,9 @@ module ActiveSupport
               Minitest::UnexpectedError.new(error)
             end
             @queue.record(reporter, result)
+          rescue Interrupt
+            @queue.interrupt
+            raise
           end
 
           set_process_title("(idle)")

data/lib/active_support/testing/parallelization.rb

@@ -42,6 +42,10 @@ module ActiveSupport
         @queue_server << work
       end
 
+      def size
+        @worker_count
+      end
+
       def shutdown
         @queue_server.shutdown
         @worker_pool.each { |pid| Process.waitpid pid }

data/lib/active_support/testing/parallelize_executor.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Testing
+    class ParallelizeExecutor # :nodoc:
+      attr_reader :size, :parallelize_with, :threshold
+
+      def initialize(size:, with:, threshold: ActiveSupport.test_parallelization_threshold)
+        @size = size
+        @parallelize_with = with
+        @threshold = threshold
+      end
+
+      def start
+        parallelize if should_parallelize?
+        show_execution_info
+
+        parallel_executor.start if parallelized?
+      end
+
+      def <<(work)
+        parallel_executor << work if parallelized?
+      end
+
+      def shutdown
+        parallel_executor.shutdown if parallelized?
+      end
+
+      private
+        def parallel_executor
+          @parallel_executor ||= build_parallel_executor
+        end
+
+        def build_parallel_executor
+          case parallelize_with
+          when :processes
+            Testing::Parallelization.new(size)
+          when :threads
+            ActiveSupport::TestCase.lock_threads = false if defined?(ActiveSupport::TestCase.lock_threads)
+            Minitest::Parallel::Executor.new(size)
+          else
+            raise ArgumentError, "#{parallelize_with} is not a supported parallelization executor."
+          end
+        end
+
+        def parallelize
+          @parallelized = true
+          Minitest::Test.parallelize_me!
+        end
+
+        def parallelized?
+          @parallelized if defined?(@parallelized)
+        end
+
+        def should_parallelize?
+          ENV["PARALLEL_WORKERS"] || tests_count > threshold
+        end
+
+        def tests_count
+          @tests_count ||= Minitest::Runnable.runnables.sum { |runnable| runnable.runnable_methods.size }
+        end
+
+        def show_execution_info
+          puts execution_info
+        end
+
+        def execution_info
+          if parallelized?
+            "Running #{tests_count} tests in parallel using #{parallel_executor.size} #{parallelize_with}"
+          else
+            "Running #{tests_count} tests in a single process (parallelization threshold is #{threshold})"
+          end
+        end
+    end
+  end
+end

data/lib/active_support/testing/stream.rb

@@ -2,7 +2,7 @@
 
 module ActiveSupport
   module Testing
-    module Stream #:nodoc:
+    module Stream # :nodoc:
       private
         def silence_stream(stream)
           old_stream = stream.dup
@@ -14,11 +14,9 @@ module ActiveSupport
           old_stream.close
         end
 
-        def quietly
+        def quietly(&block)
           silence_stream(STDOUT) do
-            silence_stream(STDERR) do
-              yield
-            end
+            silence_stream(STDERR, &block)
           end
         end
 

data/lib/active_support/testing/tagged_logging.rb

@@ -4,7 +4,7 @@ module ActiveSupport
   module Testing
     # Logs a "PostsControllerTest: test name" heading before each test to
     # make test.log easier to search and follow along with.
-    module TaggedLogging #:nodoc:
+    module TaggedLogging # :nodoc:
       attr_writer :tagged_logger
 
       def before_setup

data/lib/active_support/testing/time_helpers.rb

@@ -126,7 +126,7 @@ module ActiveSupport
       #   end
       #   Time.current # => Sat, 09 Nov 2013 15:34:49 EST -05:00
       def travel_to(date_or_time)
-        if block_given? && simple_stubs.stubbing(Time, :now)
+        if block_given? && in_block
           travel_to_nested_block_call = <<~MSG
 
       Calling `travel_to` with a block, when we have previously already made a call to `travel_to`, can lead to confusing time stubbing.
@@ -156,19 +156,28 @@ module ActiveSupport
 
         if date_or_time.is_a?(Date) && !date_or_time.is_a?(DateTime)
           now = date_or_time.midnight.to_time
+        elsif date_or_time.is_a?(String)
+          now = Time.zone.parse(date_or_time)
         else
           now = date_or_time.to_time.change(usec: 0)
         end
 
+        stubbed_time = Time.now if simple_stubs.stubbing(Time, :now)
         simple_stubs.stub_object(Time, :now) { at(now.to_i) }
         simple_stubs.stub_object(Date, :today) { jd(now.to_date.jd) }
         simple_stubs.stub_object(DateTime, :now) { jd(now.to_date.jd, now.hour, now.min, now.sec, Rational(now.utc_offset, 86400)) }
 
         if block_given?
           begin
+            self.in_block = true
             yield
           ensure
-            travel_back
+            if stubbed_time
+              travel_to stubbed_time
+            else
+              travel_back
+            end
+            self.in_block = false
           end
         end
       end
@@ -230,6 +239,8 @@ module ActiveSupport
         def simple_stubs
           @simple_stubs ||= SimpleStubs.new
         end
+
+        attr_accessor :in_block
     end
   end
 end