activesupport 7.1.0.beta1 → 7.1.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b700c44e30a586bad9303faa7189ffbab6e529983cd8813251a698390ca0739d
-  data.tar.gz: 44ecf71d5e2b51d0461e81e3e72b9dbf6611c25ef6eb4fe24dbf054c8488cd92
+  metadata.gz: 680e4677ad9c5c80f0e8ca9b8fe7e4df0706ff259937be2547ba2e73fefc2c59
+  data.tar.gz: 80dbd580c5d1ff3f342599ca0162c20845a7b0ea6a8fa0c88abea51643569ae3
 SHA512:
-  metadata.gz: e31bf27329b619e70a79be7eab163b0cc6f4da5e833c75ee009bc33d7f2573cbc53dcda7f7e950177eb6304d9d2bf7ff997d4d5a2deaec750abadd04a9d95f10
-  data.tar.gz: d5a11fec498e5a0163e4f0d25994ec42c53b05db43cef312078057a200b3c84579bf31931d750d7502c497d6fa73d0d845af0c3c16748721c303459e45a86ace
+  metadata.gz: a3dca2799c3af8ac3a5298a5a67061cf4225bdc388972908f072c877d0c5108b714576db0b550b967c54526c785dd9f601fbc6a4b3720d90bd016ed200088227
+  data.tar.gz: 53b99d38845de0067923c74518c21f2a370f8595e0eb6ad37a0beb5d3c8f2685e774a4aabb361e63aff7b699922fed4615db9e94c36db08f9e7acebff10ab26d

data/CHANGELOG.md

@@ -1,5 +1,59 @@
+## Rails 7.1.0.rc1 (September 27, 2023) ##
+
+*   Add a new public API for broadcasting logs
+
+    This feature existed for a while but was until now a private API.
+    Broadcasting log allows to send log message to difference sinks (STDOUT, a file ...) and
+    is used by default in the development environment to write logs both on STDOUT and in the
+    "development.log" file.
+
+    Basic usage:
+
+    ```ruby
+    stdout_logger = Logger.new(STDOUT)
+    file_logger = Logger.new("development.log")
+    broadcast = ActiveSupport::BroadcastLogger.new(stdout_logger, file_logger)
+
+    broadcast.info("Hello!") # The "Hello!" message is written on STDOUT and in the log file.
+    ```
+
+    Adding other sink(s) to the broadcast:
+
+    ```ruby
+    broadcast = ActiveSupport::BroadcastLogger.new
+    broadcast.broadcast_to(Logger.new(STDERR))
+    ```
+
+    Remove a sink from the broadcast:
+
+    ```ruby
+    stdout_logger = Logger.new(STDOUT)
+    broadcast = ActiveSupport::BroadcastLogger.new(stdout_logger)
+
+    broadcast.stop_broadcasting_to(stdout_logger)
+    ```
+
+    *Edouard Chin*
+
+*   Fix Range#overlap? not taking empty ranges into account on Ruby < 3.3
+
+    *Nobuyoshi Nakada*, *Shouichi Kamiya*, *Hartley McGuire*
+
+*   Use Ruby 3.3 Range#overlap? if available
+
+    *Yasuo Honda*
+
+
 ## Rails 7.1.0.beta1 (September 13, 2023) ##
 
+*   Add `bigdecimal` as Active Support dependency that is a bundled gem candidate for Ruby 3.4.
+
+    `bigdecimal` 3.1.4 or higher version will be installed.
+    Ruby 2.7 and 3.0 users who want `bigdecimal` version 2.0.0 or 3.0.0 behavior as a default gem,
+    pin the `bigdecimal` version in your application Gemfile.
+
+    *Koichi ITO*
+
 *   Add `drb`, `mutex_m` and `base64` that are bundled gem candidates for Ruby 3.4
 
     *Yasuo Honda*
@@ -366,7 +420,7 @@
       ```ruby
       travel_to Time.new(2004, 11, 24) do
         # Inside the `travel_to` block `Time.new` is stubbed
-        assert_equal Time.new.year, 2004
+        assert_equal 2004, Time.new.year
       end
       ```
 
@@ -434,7 +488,7 @@
     string.slice!(0, 1).html_safe? # => true
     # maintain html_safe? after the slice!
     string.html_safe? # => true
-    string.chr # => true
+    string.chr.html_safe? # => true
     ```
 
     *Michael Go*

data/lib/active_support/broadcast_logger.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # = Active Support Broadcast Logger
+  #
+  # The Broadcast logger is a logger used to write messages to multiple IO. It is commonly used
+  # in development to display messages on STDOUT and also write them to a file (development.log).
+  # With the Broadcast logger, you can broadcast your logs to a unlimited number of sinks.
+  #
+  # The BroadcastLogger acts as a standard logger and all methods you are used to are available.
+  # However, all the methods on this logger will propagate and be delegated to the other loggers
+  # that are part of the broadcast.
+  #
+  # Broadcasting your logs.
+  #
+  #   stdout_logger = Logger.new(STDOUT)
+  #   file_logger   = Logger.new("development.log")
+  #   broadcast = BroadcastLogger.new(stdout_logger, file_logger)
+  #
+  #   broadcast.info("Hello world!") # Writes the log to STDOUT and the development.log file.
+  #
+  # Add a logger to the broadcast.
+  #
+  #   stdout_logger = Logger.new(STDOUT)
+  #   broadcast = BroadcastLogger.new(stdout_logger)
+  #   file_logger   = Logger.new("development.log")
+  #   broadcast.broadcast_to(file_logger)
+  #
+  #   broadcast.info("Hello world!") # Writes the log to STDOUT and the development.log file.
+  #
+  # Modifying the log level for all broadcasted loggers.
+  #
+  #   stdout_logger = Logger.new(STDOUT)
+  #   file_logger   = Logger.new("development.log")
+  #   broadcast = BroadcastLogger.new(stdout_logger, file_logger)
+  #
+  #   broadcast.level = Logger::FATAL # Modify the log level for the whole broadcast.
+  #
+  # Stop broadcasting log to a sink.
+  #
+  #   stdout_logger = Logger.new(STDOUT)
+  #   file_logger   = Logger.new("development.log")
+  #   broadcast = BroadcastLogger.new(stdout_logger, file_logger)
+  #   broadcast.info("Hello world!") # Writes the log to STDOUT and the development.log file.
+  #
+  #   broadcast.stop_broadcasting_to(file_logger)
+  #   broadcast.info("Hello world!") # Writes the log *only* to STDOUT.
+  #
+  # At least one sink has to be part of the broadcast. Otherwise, your logs will not
+  # be written anywhere. For instance:
+  #
+  #   broadcast = BroadcastLogger.new
+  #   broadcast.info("Hello world") # The log message will appear nowhere.
+  class BroadcastLogger
+    include ActiveSupport::LoggerSilence
+
+    # Returns all the logger that are part of this broadcast.
+    attr_reader :broadcasts
+    attr_reader :formatter
+    attr_accessor :progname
+
+    def initialize(*loggers)
+      @broadcasts = []
+      @progname = "Broadcast"
+
+      broadcast_to(*loggers)
+    end
+
+    # Add logger(s) to the broadcast.
+    #
+    #   broadcast_logger = ActiveSupport::BroadcastLogger.new
+    #   broadcast_logger.broadcast_to(Logger.new(STDOUT), Logger.new(STDERR))
+    def broadcast_to(*loggers)
+      @broadcasts.concat(loggers)
+    end
+
+    # Remove a logger from the broadcast. When a logger is removed, messages sent to
+    # the broadcast will no longer be written to its sink.
+    #
+    #   sink = Logger.new(STDOUT)
+    #   broadcast_logger = ActiveSupport::BroadcastLogger.new
+    #
+    #   broadcast_logger.stop_broadcasting_to(sink)
+    def stop_broadcasting_to(logger)
+      @broadcasts.delete(logger)
+    end
+
+    def level
+      @broadcasts.map(&:level).min
+    end
+
+    def <<(message)
+      dispatch { |logger| logger.<<(message) }
+    end
+
+    def add(*args, &block)
+      dispatch { |logger| logger.add(*args, &block) }
+    end
+    alias_method :log, :add
+
+    def debug(*args, &block)
+      dispatch { |logger| logger.debug(*args, &block) }
+    end
+
+    def info(*args, &block)
+      dispatch { |logger| logger.info(*args, &block) }
+    end
+
+    def warn(*args, &block)
+      dispatch { |logger| logger.warn(*args, &block) }
+    end
+
+    def error(*args, &block)
+      dispatch { |logger| logger.error(*args, &block) }
+    end
+
+    def fatal(*args, &block)
+      dispatch { |logger| logger.fatal(*args, &block) }
+    end
+
+    def unknown(*args, &block)
+      dispatch { |logger| logger.unknown(*args, &block) }
+    end
+
+    def formatter=(formatter)
+      dispatch { |logger| logger.formatter = formatter }
+
+      @formatter = formatter
+    end
+
+    def level=(level)
+      dispatch { |logger| logger.level = level }
+    end
+    alias_method :sev_threshold=, :level=
+
+    def local_level=(level)
+      dispatch do |logger|
+        logger.local_level = level if logger.respond_to?(:local_level=)
+      end
+    end
+
+    def close
+      dispatch { |logger| logger.close }
+    end
+
+    # +True+ if the log level allows entries with severity Logger::DEBUG to be written
+    # to at least one broadcast. +False+ otherwise.
+    def debug?
+      @broadcasts.any? { |logger| logger.debug? }
+    end
+
+    # Sets the log level to Logger::DEBUG for the whole broadcast.
+    def debug!
+      dispatch { |logger| logger.debug! }
+    end
+
+    # +True+ if the log level allows entries with severity Logger::INFO to be written
+    # to at least one broadcast. +False+ otherwise.
+    def info?
+      @broadcasts.any? { |logger| logger.info? }
+    end
+
+    # Sets the log level to Logger::INFO for the whole broadcast.
+    def info!
+      dispatch { |logger| logger.info! }
+    end
+
+    # +True+ if the log level allows entries with severity Logger::WARN to be written
+    # to at least one broadcast. +False+ otherwise.
+    def warn?
+      @broadcasts.any? { |logger| logger.warn? }
+    end
+
+    # Sets the log level to Logger::WARN for the whole broadcast.
+    def warn!
+      dispatch { |logger| logger.warn! }
+    end
+
+    # +True+ if the log level allows entries with severity Logger::ERROR to be written
+    # to at least one broadcast. +False+ otherwise.
+    def error?
+      @broadcasts.any? { |logger| logger.error? }
+    end
+
+    # Sets the log level to Logger::ERROR for the whole broadcast.
+    def error!
+      dispatch { |logger| logger.error! }
+    end
+
+    # +True+ if the log level allows entries with severity Logger::FATAL to be written
+    # to at least one broadcast. +False+ otherwise.
+    def fatal?
+      @broadcasts.any? { |logger| logger.fatal? }
+    end
+
+    # Sets the log level to Logger::FATAL for the whole broadcast.
+    def fatal!
+      dispatch { |logger| logger.fatal! }
+    end
+
+    private
+      def dispatch(&block)
+        @broadcasts.each { |logger| block.call(logger) }
+      end
+  end
+end

data/lib/active_support/callbacks.rb

@@ -743,7 +743,7 @@ module ActiveSupport
         #
         # The callback can be specified as a symbol naming an instance method; as a
         # proc, lambda, or block; or as an object that responds to a certain method
-        # determined by the <tt>:scope</tt> argument to +define_callbacks+.
+        # determined by the <tt>:scope</tt> argument to #define_callbacks.
         #
         # If a proc, lambda, or block is given, its body is evaluated in the context
         # of the current object. It can also optionally accept the current object as
@@ -787,10 +787,13 @@ module ActiveSupport
           end
         end
 
-        # Skip a previously set callback. Like +set_callback+, <tt>:if</tt> or
+        # Skip a previously set callback. Like #set_callback, <tt>:if</tt> or
         # <tt>:unless</tt> options may be passed in order to control when the
         # callback is skipped.
         #
+        # Note: this example uses +PersonRecord+ and +#saving_message+, which you
+        # can see defined here[rdoc-ref:ActiveSupport::Callbacks]
+        #
         #   class Writer < PersonRecord
         #     attr_accessor :age
         #     skip_callback :save, :before, :saving_message, if: -> { age > 18 }
@@ -933,7 +936,7 @@ module ActiveSupport
         # <tt>!</tt>, <tt>?</tt> or <tt>=</tt>.
         #
         # Calling +define_callbacks+ multiple times with the same +names+ will
-        # overwrite previous callbacks registered with +set_callback+.
+        # overwrite previous callbacks registered with #set_callback.
         def define_callbacks(*names)
           options = names.extract_options!
 

data/lib/active_support/core_ext/hash/deep_merge.rb

@@ -1,6 +1,14 @@
 # frozen_string_literal: true
 
+require "active_support/deep_mergeable"
+
 class Hash
+  include ActiveSupport::DeepMergeable
+
+  ##
+  # :method: deep_merge
+  # :call-seq: deep_merge(other_hash, &block)
+  #
   # Returns a new hash with +self+ and +other_hash+ merged recursively.
   #
   #   h1 = { a: true, b: { c: [1, 2, 3] } }
@@ -15,20 +23,20 @@ class Hash
   #   h2 = { b: 250, c: { c1: 200 } }
   #   h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
   #   # => { a: 100, b: 450, c: { c1: 300 } }
-  def deep_merge(other_hash, &block)
-    dup.deep_merge!(other_hash, &block)
-  end
+  #
+  #--
+  # Implemented by ActiveSupport::DeepMergeable#deep_merge.
+
+  ##
+  # :method: deep_merge!
+  # :call-seq: deep_merge!(other_hash, &block)
+  #
+  # Same as #deep_merge, but modifies +self+.
+  #
+  #--
+  # Implemented by ActiveSupport::DeepMergeable#deep_merge!.
 
-  # Same as +deep_merge+, but modifies +self+.
-  def deep_merge!(other_hash, &block)
-    merge!(other_hash) do |key, this_val, other_val|
-      if this_val.is_a?(Hash) && other_val.is_a?(Hash)
-        this_val.deep_merge(other_val, &block)
-      elsif block_given?
-        block.call(key, this_val, other_val)
-      else
-        other_val
-      end
-    end
+  def deep_merge?(other) # :nodoc:
+    other.is_a?(Hash)
   end
 end

data/lib/active_support/core_ext/range/overlap.rb

@@ -4,8 +4,36 @@ class Range
   # Compare two ranges and see if they overlap each other
   #  (1..5).overlap?(4..6) # => true
   #  (1..5).overlap?(7..9) # => false
-  def overlap?(other)
-    other.begin == self.begin || cover?(other.begin) || other.cover?(self.begin)
+  unless Range.method_defined?(:overlap?)
+    def overlap?(other)
+      raise TypeError unless other.is_a? Range
+
+      self_begin = self.begin
+      other_end = other.end
+      other_excl = other.exclude_end?
+
+      return false if _empty_range?(self_begin, other_end, other_excl)
+
+      other_begin = other.begin
+      self_end = self.end
+      self_excl = self.exclude_end?
+
+      return false if _empty_range?(other_begin, self_end, self_excl)
+      return true if self_begin == other_begin
+
+      return false if _empty_range?(self_begin, self_end, self_excl)
+      return false if _empty_range?(other_begin, other_end, other_excl)
+
+      true
+    end
+
+    private
+    def _empty_range?(b, e, excl)
+      return false if b.nil? || e.nil?
+
+      comp = b <=> e
+      comp.nil? || comp > 0 || (comp == 0 && excl)
+    end
   end
 
   alias :overlaps? :overlap?

data/lib/active_support/deep_mergeable.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # Provides +deep_merge+ and +deep_merge!+ methods. Expects the including class
+  # to provide a <tt>merge!(other, &block)</tt> method.
+  module DeepMergeable # :nodoc:
+    # Returns a new instance with the values from +other+ merged recursively.
+    #
+    #   class Hash
+    #     include ActiveSupport::DeepMergeable
+    #   end
+    #
+    #   hash_1 = { a: true, b: { c: [1, 2, 3] } }
+    #   hash_2 = { a: false, b: { x: [3, 4, 5] } }
+    #
+    #   hash_1.deep_merge(hash_2)
+    #   # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+    #
+    # A block can be provided to merge non-<tt>DeepMergeable</tt> values:
+    #
+    #   hash_1 = { a: 100, b: 200, c: { c1: 100 } }
+    #   hash_2 = { b: 250, c: { c1: 200 } }
+    #
+    #   hash_1.deep_merge(hash_2) do |key, this_val, other_val|
+    #     this_val + other_val
+    #   end
+    #   # => { a: 100, b: 450, c: { c1: 300 } }
+    #
+    def deep_merge(other, &block)
+      dup.deep_merge!(other, &block)
+    end
+
+    # Same as #deep_merge, but modifies +self+.
+    def deep_merge!(other, &block)
+      merge!(other) do |key, this_val, other_val|
+        if this_val.is_a?(DeepMergeable) && this_val.deep_merge?(other_val)
+          this_val.deep_merge(other_val, &block)
+        elsif block_given?
+          block.call(key, this_val, other_val)
+        else
+          other_val
+        end
+      end
+    end
+
+    # Returns true if +other+ can be deep merged into +self+. Classes may
+    # override this method to restrict or expand the domain of deep mergeable
+    # values. Defaults to checking that +other+ is of type +self.class+.
+    def deep_merge?(other)
+      other.is_a?(self.class)
+    end
+  end
+end

data/lib/active_support/gem_version.rb

@@ -10,7 +10,7 @@ module ActiveSupport
     MAJOR = 7
     MINOR = 1
     TINY  = 0
-    PRE   = "beta1"
+    PRE   = "rc1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_support/logger.rb

@@ -19,64 +19,6 @@ module ActiveSupport
       sources.any? { |source| source == logger_source }
     end
 
-    # Broadcasts logs to multiple loggers.
-    def self.broadcast(logger) # :nodoc:
-      Module.new do
-        define_method(:add) do |*args, &block|
-          logger.add(*args, &block)
-          super(*args, &block)
-        end
-
-        define_method(:<<) do |x|
-          logger << x
-          super(x)
-        end
-
-        define_method(:close) do
-          logger.close
-          super()
-        end
-
-        define_method(:progname=) do |name|
-          logger.progname = name
-          super(name)
-        end
-
-        define_method(:formatter=) do |formatter|
-          logger.formatter = formatter
-          super(formatter)
-        end
-
-        define_method(:level=) do |level|
-          logger.level = level
-          super(level)
-        end
-
-        define_method(:local_level=) do |level|
-          logger.local_level = level if logger.respond_to?(:local_level=)
-          super(level) if respond_to?(:local_level=)
-        end
-
-        define_method(:silence) do |level = Logger::ERROR, &block|
-          if logger.respond_to?(:silence)
-            logger.silence(level) do
-              if defined?(super)
-                super(level, &block)
-              else
-                block.call(self)
-              end
-            end
-          else
-            if defined?(super)
-              super(level, &block)
-            else
-              block.call(self)
-            end
-          end
-        end
-      end
-    end
-
     def initialize(*args, **kwargs)
       super
       @formatter ||= SimpleFormatter.new

data/lib/active_support/logger_thread_safe_level.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/concern"
-require "active_support/core_ext/module/attribute_accessors"
-require "concurrent"
-require "fiber"
+require "logger"
 
 module ActiveSupport
   module LoggerThreadSafeLevel # :nodoc:

data/lib/active_support/railtie.rb

@@ -88,7 +88,7 @@ module ActiveSupport
     initializer "active_support.initialize_time_zone" do |app|
       begin
         TZInfo::DataSource.get
-      rescue TZInfo::DataSourceNotFound => e
+      rescue TZInfo::DataSourceNotFound, TZInfo::ZoneinfoDirectoryNotFound => e
         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"

data/lib/active_support/testing/error_reporter_assertions.rb

@@ -3,7 +3,7 @@
 module ActiveSupport
   module Testing
     module ErrorReporterAssertions
-      module ErrorCollector
+      module ErrorCollector # :nodoc:
         @subscribed = false
         @mutex = Mutex.new
 
@@ -51,58 +51,57 @@ module ActiveSupport
         end
       end
 
-      private
-        # Assertion that the block should not cause an exception to be reported
-        # to +Rails.error+.
-        #
-        # Passes if evaluated code in the yielded block reports no exception.
-        #
-        #   assert_no_error_reported do
-        #     perform_service(param: 'no_exception')
-        #   end
-        def assert_no_error_reported(&block)
-          reports = ErrorCollector.record do
-            _assert_nothing_raised_or_warn("assert_no_error_reported", &block)
-          end
-          assert_predicate(reports, :empty?)
+      # Assertion that the block should not cause an exception to be reported
+      # to +Rails.error+.
+      #
+      # Passes if evaluated code in the yielded block reports no exception.
+      #
+      #   assert_no_error_reported do
+      #     perform_service(param: 'no_exception')
+      #   end
+      def assert_no_error_reported(&block)
+        reports = ErrorCollector.record do
+          _assert_nothing_raised_or_warn("assert_no_error_reported", &block)
         end
+        assert_predicate(reports, :empty?)
+      end
 
-        # Assertion that the block should cause at least one exception to be reported
-        # to +Rails.error+.
-        #
-        # Passes if the evaluated code in the yielded block reports a matching exception.
-        #
-        #   assert_error_reported(IOError) do
-        #     Rails.error.report(IOError.new("Oops"))
-        #   end
-        #
-        # To test further details about the reported exception, you can use the return
-        # value.
-        #
-        #   report = assert_error_reported(IOError) do
-        #     # ...
-        #   end
-        #   assert_equal "Oops", report.error.message
-        #   assert_equal "admin", report.context[:section]
-        #   assert_equal :warning, report.severity
-        #   assert_predicate report, :handled?
-        def assert_error_reported(error_class = StandardError, &block)
-          reports = ErrorCollector.record do
-            _assert_nothing_raised_or_warn("assert_error_reported", &block)
-          end
+      # Assertion that the block should cause at least one exception to be reported
+      # to +Rails.error+.
+      #
+      # Passes if the evaluated code in the yielded block reports a matching exception.
+      #
+      #   assert_error_reported(IOError) do
+      #     Rails.error.report(IOError.new("Oops"))
+      #   end
+      #
+      # To test further details about the reported exception, you can use the return
+      # value.
+      #
+      #   report = assert_error_reported(IOError) do
+      #     # ...
+      #   end
+      #   assert_equal "Oops", report.error.message
+      #   assert_equal "admin", report.context[:section]
+      #   assert_equal :warning, report.severity
+      #   assert_predicate report, :handled?
+      def assert_error_reported(error_class = StandardError, &block)
+        reports = ErrorCollector.record do
+          _assert_nothing_raised_or_warn("assert_error_reported", &block)
+        end
 
-          if reports.empty?
-            assert(false, "Expected a #{error_class.name} to be reported, but there were no errors reported.")
-          elsif (report = reports.find { |r| error_class === r.error })
-            self.assertions += 1
-            report
-          else
-            message = "Expected a #{error_class.name} to be reported, but none of the " \
-              "#{reports.size} reported errors matched:  \n" \
-              "#{reports.map { |r| r.error.class.name }.join("\n  ")}"
-            assert(false, message)
-          end
+        if reports.empty?
+          assert(false, "Expected a #{error_class.name} to be reported, but there were no errors reported.")
+        elsif (report = reports.find { |r| error_class === r.error })
+          self.assertions += 1
+          report
+        else
+          message = "Expected a #{error_class.name} to be reported, but none of the " \
+            "#{reports.size} reported errors matched:  \n" \
+            "#{reports.map { |r| r.error.class.name }.join("\n  ")}"
+          assert(false, message)
         end
+      end
     end
   end
 end

data/lib/active_support.rb

@@ -28,6 +28,7 @@ require "active_support/dependencies/autoload"
 require "active_support/version"
 require "active_support/deprecator"
 require "active_support/logger"
+require "active_support/broadcast_logger"
 require "active_support/lazy_load_hooks"
 require "active_support/core_ext/date_and_time/compatibility"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activesupport
 version: !ruby/object:Gem::Version
-  version: 7.1.0.beta1
+  version: 7.1.0.rc1
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-13 00:00:00.000000000 Z
+date: 2023-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n
@@ -165,6 +165,7 @@ files:
 - lib/active_support/array_inquirer.rb
 - lib/active_support/backtrace_cleaner.rb
 - lib/active_support/benchmarkable.rb
+- lib/active_support/broadcast_logger.rb
 - lib/active_support/builder.rb
 - lib/active_support/cache.rb
 - lib/active_support/cache/coder.rb
@@ -306,6 +307,7 @@ files:
 - lib/active_support/core_ext/time/zones.rb
 - lib/active_support/current_attributes.rb
 - lib/active_support/current_attributes/test_helper.rb
+- lib/active_support/deep_mergeable.rb
 - lib/active_support/dependencies.rb
 - lib/active_support/dependencies/autoload.rb
 - lib/active_support/dependencies/interlock.rb
@@ -444,10 +446,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails/rails/issues
-  changelog_uri: https://github.com/rails/rails/blob/v7.1.0.beta1/activesupport/CHANGELOG.md
-  documentation_uri: https://api.rubyonrails.org/v7.1.0.beta1/
+  changelog_uri: https://github.com/rails/rails/blob/v7.1.0.rc1/activesupport/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v7.1.0.rc1/
   mailing_list_uri: https://discuss.rubyonrails.org/c/rubyonrails-talk
-  source_code_uri: https://github.com/rails/rails/tree/v7.1.0.beta1/activesupport
+  source_code_uri: https://github.com/rails/rails/tree/v7.1.0.rc1/activesupport
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: