activesupport 7.1.3.4 → 8.0.1

data/lib/active_support/number_helper.rb

@@ -1,6 +1,28 @@
 # frozen_string_literal: true
 
 module ActiveSupport
+  # = Number Helper
+  #
+  # Provides methods for formatting numbers into currencies, percentages,
+  # phone numbers, and more.
+  #
+  # Example usage in a class:
+  #   class Topic
+  #     include ActiveSupport::NumberHelper
+  #
+  #     def price
+  #       number_to_currency(@price)
+  #     end
+  #   end
+  #
+  # Example usage in a module:
+  #   require "active_support/number_helper"
+  #
+  #   module NumberFormatting
+  #     def format_price(price)
+  #       ActiveSupport::NumberHelper.number_to_currency(price)
+  #     end
+  #   end
   module NumberHelper
     extend ActiveSupport::Autoload
 

data/lib/active_support/option_merger.rb

@@ -31,8 +31,8 @@ module ActiveSupport
         end
       end
 
-      def respond_to_missing?(*arguments)
-        @context.respond_to?(*arguments)
+      def respond_to_missing?(...)
+        @context.respond_to?(...)
       end
   end
 end

data/lib/active_support/ordered_options.rb

@@ -46,18 +46,14 @@ module ActiveSupport
       super(key.to_sym, *identifiers)
     end
 
-    def method_missing(name, *args)
-      name_string = +name.to_s
-      if name_string.chomp!("=")
-        self[name_string] = args.first
+    def method_missing(method, *args)
+      if method.end_with?("=")
+        self[method.name.chomp("=")] = args.first
+      elsif method.end_with?("!")
+        name_string = method.name.chomp("!")
+        self[name_string].presence || raise(KeyError.new(":#{name_string} is blank"))
       else
-        bangs = name_string.chomp!("!")
-
-        if bangs
-          self[name_string].presence || raise(KeyError.new(":#{name_string} is blank"))
-        else
-          self[name_string]
-        end
+        self[method.name]
       end
     end
 
@@ -92,18 +88,60 @@ module ActiveSupport
   #   h.boy  # => 'John'
   class InheritableOptions < OrderedOptions
     def initialize(parent = nil)
-      if parent.kind_of?(OrderedOptions)
+      @parent = parent
+      if @parent.kind_of?(OrderedOptions)
         # use the faster _get when dealing with OrderedOptions
-        super() { |h, k| parent._get(k) }
-      elsif parent
-        super() { |h, k| parent[k] }
+        super() { |h, k| @parent._get(k) }
+      elsif @parent
+        super() { |h, k| @parent[k] }
       else
         super()
+        @parent = {}
       end
     end
 
+    def to_h
+      @parent.merge(self)
+    end
+
+    def ==(other)
+      to_h == other.to_h
+    end
+
+    def inspect
+      "#<#{self.class.name} #{to_h.inspect}>"
+    end
+
+    def to_s
+      to_h.to_s
+    end
+
+    def pretty_print(pp)
+      pp.pp_hash(to_h)
+    end
+
+    alias_method :own_key?, :key?
+    private :own_key?
+
+    def key?(key)
+      super || @parent.key?(key)
+    end
+
+    def overridden?(key)
+      !!(@parent && @parent.key?(key) && own_key?(key.to_sym))
+    end
+
     def inheritable_copy
       self.class.new(self)
     end
+
+    def to_a
+      entries
+    end
+
+    def each(&block)
+      to_h.each(&block)
+      self
+    end
   end
 end

data/lib/active_support/railtie.rb

@@ -89,10 +89,15 @@ module ActiveSupport
       begin
         TZInfo::DataSource.get
       rescue TZInfo::DataSourceNotFound => e
-        raise e.exception "tzinfo-data is not present. Please add gem 'tzinfo-data' to your Gemfile and run bundle install"
+        raise e.exception('tzinfo-data is not present. Please add gem "tzinfo-data" to your Gemfile and run bundle install')
       end
       require "active_support/core_ext/time/zones"
       Time.zone_default = Time.find_zone!(app.config.time_zone)
+      config.eager_load_namespaces << TZInfo
+    end
+
+    initializer "active_support.to_time_preserves_timezone" do |app|
+      ActiveSupport.to_time_preserves_timezone = app.config.active_support.to_time_preserves_timezone
     end
 
     # Sets the default week start
@@ -117,16 +122,8 @@ module ActiveSupport
 
     initializer "active_support.set_configs" do |app|
       app.config.active_support.each do |k, v|
-        if k == "disable_to_s_conversion"
-          ActiveSupport.deprecator.warn("config.active_support.disable_to_s_conversion is deprecated and will be removed in Rails 7.2.")
-        elsif k == "remove_deprecated_time_with_zone_name"
-          ActiveSupport.deprecator.warn("config.active_support.remove_deprecated_time_with_zone_name is deprecated and will be removed in Rails 7.2.")
-        elsif k == "use_rfc4122_namespaced_uuids"
-          ActiveSupport.deprecator.warn("config.active_support.use_rfc4122_namespaced_uuids is deprecated and will be removed in Rails 7.2.")
-        else
-          k = "#{k}="
-          ActiveSupport.public_send(k, v) if ActiveSupport.respond_to? k
-        end
+        k = "#{k}="
+        ActiveSupport.public_send(k, v) if ActiveSupport.respond_to? k
       end
     end
 

data/lib/active_support/string_inquirer.rb

@@ -24,7 +24,7 @@ module ActiveSupport
         method_name.end_with?("?") || super
       end
 
-      def method_missing(method_name, *arguments)
+      def method_missing(method_name, ...)
         if method_name.end_with?("?")
           self == method_name[0..-2]
         else

data/lib/active_support/subscriber.rb

@@ -67,6 +67,7 @@ module ActiveSupport
 
       # Adds event subscribers for all new methods added to the class.
       def method_added(event)
+        super
         # Only public methods are added as subscribers, and only if a notifier
         # has been set up. This means that subscribers will only be set up for
         # classes that call #attach_to.

data/lib/active_support/syntax_error_proxy.rb

@@ -45,7 +45,7 @@ module ActiveSupport
 
     private
       def parse_message_for_trace
-        if source_location_eval?
+        if __getobj__.to_s.start_with?("(eval")
           # If the exception is coming from a call to eval, we need to keep
           # the path of the file in which eval was called to ensure we can
           # return the right source fragment to show the location of the
@@ -56,15 +56,5 @@ module ActiveSupport
           __getobj__.to_s.split("\n")
         end
       end
-
-      if SyntaxError.method_defined?(:path) # Ruby 3.3+
-        def source_location_eval?
-          __getobj__.path.start_with?("(eval")
-        end
-      else # 3.2 and older versions of Ruby
-        def source_location_eval?
-          __getobj__.to_s.start_with?("(eval")
-        end
-      end
   end
 end

data/lib/active_support/tagged_logging.rb

@@ -2,7 +2,6 @@
 
 require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/object/blank"
-require "logger"
 require "active_support/logger"
 
 module ActiveSupport
@@ -114,11 +113,20 @@ module ActiveSupport
       end
     end
 
+    # Returns an `ActiveSupport::Logger` that has already been wrapped with tagged logging concern.
+    def self.logger(*args, **kwargs)
+      new ActiveSupport::Logger.new(*args, **kwargs)
+    end
+
     def self.new(logger)
       logger = logger.clone
 
       if logger.formatter
         logger.formatter = logger.formatter.clone
+
+        # Workaround for https://bugs.ruby-lang.org/issues/20250
+        # Can be removed when Ruby 3.4 is the least supported version.
+        logger.formatter.object_id if logger.formatter.is_a?(Proc)
       else
         # Ensure we set a default formatter so we aren't extending nil!
         logger.formatter = ActiveSupport::Logger::SimpleFormatter.new

data/lib/active_support/test_case.rb

@@ -3,6 +3,7 @@
 require "minitest"
 require "active_support/testing/tagged_logging"
 require "active_support/testing/setup_and_teardown"
+require "active_support/testing/tests_without_assertions"
 require "active_support/testing/assertions"
 require "active_support/testing/error_reporter_assertions"
 require "active_support/testing/deprecation"
@@ -78,7 +79,7 @@ module ActiveSupport
       # 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 = Concurrent.processor_count if workers == :number_of_processors
         workers = ENV["PARALLEL_WORKERS"].to_i if ENV["PARALLEL_WORKERS"]
 
         Minitest.parallel_executor = ActiveSupport::Testing::ParallelizeExecutor.new(size: workers, with: with, threshold: threshold)
@@ -142,6 +143,7 @@ module ActiveSupport
 
     include ActiveSupport::Testing::TaggedLogging
     prepend ActiveSupport::Testing::SetupAndTeardown
+    prepend ActiveSupport::Testing::TestsWithoutAssertions
     include ActiveSupport::Testing::Assertions
     include ActiveSupport::Testing::ErrorReporterAssertions
     include ActiveSupport::Testing::Deprecation

data/lib/active_support/testing/assertions.rb

@@ -19,7 +19,7 @@ module ActiveSupport
       #
       #   assert_not foo, 'foo should be false'
       def assert_not(object, message = nil)
-        message ||= "Expected #{mu_pp(object)} to be nil or false"
+        message ||= -> { "Expected #{mu_pp(object)} to be nil or false" }
         assert !object, message
       end
 
@@ -118,9 +118,13 @@ module ActiveSupport
 
         expressions.zip(exps, before) do |(code, diff), exp, before_value|
           actual = exp.call
-          error  = "#{code.inspect} didn't change by #{diff}, but by #{actual - before_value}"
-          error  = "#{message}.\n#{error}" if message
-          assert_equal(before_value + diff, actual, error)
+          rich_message = -> do
+            code_string = code.respond_to?(:call) ? _callable_to_source_string(code) : code
+            error = "`#{code_string}` didn't change by #{diff}, but by #{actual - before_value}"
+            error = "#{message}.\n#{error}" if message
+            error
+          end
+          assert_equal(before_value + diff, actual, rich_message)
         end
 
         retval
@@ -195,22 +199,32 @@ module ActiveSupport
         retval = _assert_nothing_raised_or_warn("assert_changes", &block)
 
         unless from == UNTRACKED
-          error = "Expected change from #{from.inspect}, got #{before}"
-          error = "#{message}.\n#{error}" if message
-          assert from === before, error
+          rich_message = -> do
+            error = "Expected change from #{from.inspect}, got #{before.inspect}"
+            error = "#{message}.\n#{error}" if message
+            error
+          end
+          assert from === before, rich_message
         end
 
         after = exp.call
 
-        error = "#{expression.inspect} didn't change"
-        error = "#{error}. It was already #{to}" if before == to
-        error = "#{message}.\n#{error}" if message
-        refute_equal before, after, error
+        rich_message = -> do
+          code_string = expression.respond_to?(:call) ? _callable_to_source_string(expression) : expression
+          error = "`#{code_string}` didn't change"
+          error = "#{error}. It was already #{to.inspect}" if before == to
+          error = "#{message}.\n#{error}" if message
+          error
+        end
+        refute_equal before, after, rich_message
 
         unless to == UNTRACKED
-          error = "Expected change to #{to}, got #{after}\n"
-          error = "#{message}.\n#{error}" if message
-          assert to === after, error
+          rich_message = -> do
+            error = "Expected change to #{to.inspect}, got #{after.inspect}\n"
+            error = "#{message}.\n#{error}" if message
+            error
+          end
+          assert to === after, rich_message
         end
 
         retval
@@ -242,20 +256,27 @@ module ActiveSupport
         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
+          rich_message = -> do
+            error = "Expected initial value of #{from.inspect}, got #{before.inspect}"
+            error = "#{message}.\n#{error}" if message
+            error
+          end
+          assert from === before, rich_message
         end
 
         after = exp.call
 
-        error = "#{expression.inspect} changed"
-        error = "#{message}.\n#{error}" if message
+        rich_message = -> do
+          code_string = expression.respond_to?(:call) ? _callable_to_source_string(expression) : expression
+          error = "`#{code_string}` changed"
+          error = "#{message}.\n#{error}" if message
+          error
+        end
 
         if before.nil?
-          assert_nil after, error
+          assert_nil after, rich_message
         else
-          assert_equal before, after, error
+          assert_equal before, after, rich_message
         end
 
         retval
@@ -276,6 +297,43 @@ module ActiveSupport
 
           raise
         end
+
+        def _callable_to_source_string(callable)
+          if defined?(RubyVM::InstructionSequence) && callable.is_a?(Proc)
+            iseq = RubyVM::InstructionSequence.of(callable)
+            source =
+              if iseq.script_lines
+                iseq.script_lines.join("\n")
+              elsif File.readable?(iseq.absolute_path)
+                File.read(iseq.absolute_path)
+              end
+
+            return callable unless source
+
+            location = iseq.to_a[4][:code_location]
+            return callable unless location
+
+            lines = source.lines[(location[0] - 1)..(location[2] - 1)]
+            lines[-1] = lines[-1].byteslice(...location[3])
+            lines[0] = lines[0].byteslice(location[1]...)
+            source = lines.join.strip
+
+            # We ignore procs defined with do/end as they are likely multi-line anyway.
+            if source.start_with?("{")
+              source.delete_suffix!("}")
+              source.delete_prefix!("{")
+              source.strip!
+              # It won't read nice if the callable contains multiple
+              # lines, and it should be a rare occurrence anyway.
+              # Same if it takes arguments.
+              if !source.include?("\n") && !source.start_with?("|")
+                return source
+              end
+            end
+          end
+
+          callable
+        end
     end
   end
 end

data/lib/active_support/testing/constant_stubbing.rb

@@ -15,17 +15,39 @@ module ActiveSupport
       # Using this method rather than forcing <tt>World::List::Import::LARGE_IMPORT_THRESHOLD = 5000</tt> prevents
       # warnings from being thrown, and ensures that the old value is returned after the test has completed.
       #
+      # If the constant doesn't already exists, but you need it set for the duration of the block
+      # you can do so by passing `exists: false`.
+      #
+      #   stub_const(object, :SOME_CONST, 1, exists: false) do
+      #     assert_equal 1, SOME_CONST
+      #   end
+      #
       # Note: Stubbing a const will stub it across all threads. So if you have concurrent threads
       # (like separate test suites running in parallel) that all depend on the same constant, it's possible
       # divergent stubbing will trample on each other.
-      def stub_const(mod, constant, new_value)
-        old_value = mod.const_get(constant, false)
-        mod.send(:remove_const, constant)
-        mod.const_set(constant, new_value)
-        yield
-      ensure
-        mod.send(:remove_const, constant)
-        mod.const_set(constant, old_value)
+      def stub_const(mod, constant, new_value, exists: true)
+        if exists
+          begin
+            old_value = mod.const_get(constant, false)
+            mod.send(:remove_const, constant)
+            mod.const_set(constant, new_value)
+            yield
+          ensure
+            mod.send(:remove_const, constant)
+            mod.const_set(constant, old_value)
+          end
+        else
+          if mod.const_defined?(constant)
+            raise NameError, "already defined constant #{constant} in #{mod.name}"
+          end
+
+          begin
+            mod.const_set(constant, new_value)
+            yield
+          ensure
+            mod.send(:remove_const, constant)
+          end
+        end
       end
     end
   end

data/lib/active_support/testing/deprecation.rb

@@ -29,10 +29,11 @@ module ActiveSupport
       #   end
       def assert_deprecated(match = nil, deprecator = nil, &block)
         match, deprecator = nil, match if match.is_a?(ActiveSupport::Deprecation)
+
         unless deprecator
-          ActiveSupport.deprecator.warn("assert_deprecated without a deprecator is deprecated")
-          deprecator = ActiveSupport::Deprecation._instance
+          raise ArgumentError, "No deprecator given"
         end
+
         result, warnings = collect_deprecations(deprecator, &block)
         assert !warnings.empty?, "Expected a deprecation warning within the block but received none"
         if match
@@ -51,11 +52,7 @@ module ActiveSupport
       #   assert_not_deprecated(ActiveSupport::Deprecation.new) do
       #     CustomDeprecator.warn "message" # passes assertion, different deprecator
       #   end
-      def assert_not_deprecated(deprecator = nil, &block)
-        unless deprecator
-          ActiveSupport.deprecator.warn("assert_not_deprecated without a deprecator is deprecated")
-          deprecator = ActiveSupport::Deprecation._instance
-        end
+      def assert_not_deprecated(deprecator, &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
@@ -69,11 +66,7 @@ module ActiveSupport
       #     ActiveSupport::Deprecation.new.warn "other message"
       #     :result
       #   end # => [:result, ["message"]]
-      def collect_deprecations(deprecator = nil)
-        unless deprecator
-          ActiveSupport.deprecator.warn("collect_deprecations without a deprecator is deprecated")
-          deprecator = ActiveSupport::Deprecation._instance
-        end
+      def collect_deprecations(deprecator)
         old_behavior = deprecator.behavior
         deprecations = []
         deprecator.behavior = Proc.new do |message, callstack|

data/lib/active_support/testing/isolation.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
+require "active_support/testing/parallelize_executor"
+
 module ActiveSupport
   module Testing
     module Isolation
-      require "thread"
+      SubprocessCrashed = Class.new(StandardError)
 
       def self.included(klass) # :nodoc:
         klass.class_eval do
-          parallelize_me!
+          parallelize_me! unless Minitest.parallel_executor.is_a?(ActiveSupport::Testing::ParallelizeExecutor)
         end
       end
 
@@ -16,10 +18,17 @@ module ActiveSupport
       end
 
       def run
-        serialized = run_in_isolation do
+        status, serialized = run_in_isolation do
           super
         end
 
+        unless status&.success?
+          error = SubprocessCrashed.new("Subprocess exited with an error: #{status.inspect}\noutput: #{serialized.inspect}")
+          error.set_backtrace(caller)
+          self.failures << Minitest::UnexpectedError.new(error)
+          return defined?(Minitest::Result) ? Minitest::Result.from(self) : dup
+        end
+
         Marshal.load(serialized)
       end
 
@@ -50,13 +59,13 @@ module ActiveSupport
               end
 
               write.puts [result].pack("m")
-              exit!
+              exit!(0)
             end
 
             write.close
             result = read.read
-            Process.wait2(pid)
-            result.unpack1("m")
+            _, status = Process.wait2(pid)
+            return status, result.unpack1("m")
           end
         end
       end
@@ -75,7 +84,7 @@ module ActiveSupport
             File.open(ENV["ISOLATION_OUTPUT"], "w") do |file|
               file.puts [Marshal.dump(test_result)].pack("m")
             end
-            exit!
+            exit!(0)
           else
             Tempfile.open("isolation") do |tmpfile|
               env = {
@@ -93,13 +102,14 @@ module ActiveSupport
 
               child = IO.popen([env, Gem.ruby, *load_path_args, $0, *ORIG_ARGV, test_opts])
 
+              status = nil
               begin
-                Process.wait(child.pid)
+                _, status = Process.wait2(child.pid)
               rescue Errno::ECHILD # The child process may exit before we wait
                 nil
               end
 
-              return tmpfile.read.unpack1("m")
+              return status, tmpfile.read.unpack1("m")
             end
           end
         end

data/lib/active_support/testing/method_call_assertions.rb

@@ -30,22 +30,8 @@ module ActiveSupport
           assert_called(object, method_name, message, times: 0, &block)
         end
 
-        #--
-        # This method is a temporary wrapper for mock.expect as part of
-        # the Minitest 5.16 / Ruby 3.0 kwargs transition. It can go away
-        # when we drop support for Ruby 2.7.
-        if Minitest::Mock.instance_method(:expect).parameters.map(&:first).include?(:keyrest)
-          def expect_called_with(mock, args, returns: false, **kwargs)
-            mock.expect(:call, returns, args, **kwargs)
-          end
-        else
-          def expect_called_with(mock, args, returns: false, **kwargs)
-            if !kwargs.empty?
-              mock.expect(:call, returns, [*args, kwargs])
-            else
-              mock.expect(:call, returns, args)
-            end
-          end
+        def expect_called_with(mock, args, returns: false, **kwargs)
+          mock.expect(:call, returns, args, **kwargs)
         end
 
         def assert_called_on_instance_of(klass, method_name, message = nil, times: 1, returns: nil)

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

@@ -6,6 +6,8 @@ require "drb/unix" unless Gem.win_platform?
 module ActiveSupport
   module Testing
     class Parallelization # :nodoc:
+      PrerecordResultClass = Struct.new(:name)
+
       class Server
         include DRb::DRbUndumped
 
@@ -21,6 +23,7 @@ module ActiveSupport
           @in_flight.delete([result.klass, result.name])
 
           reporter.synchronize do
+            reporter.prerecord(PrerecordResultClass.new(result.klass), result.name)
             reporter.record(result)
           end
         end

data/lib/active_support/testing/setup_and_teardown.rb

@@ -46,6 +46,8 @@ module ActiveSupport
           run_callbacks :teardown
         rescue => e
           self.failures << Minitest::UnexpectedError.new(e)
+        rescue Minitest::Assertion => e
+          self.failures << e
         end
 
         super