activesupport 7.1.3.4 → 8.0.1

data/lib/active_support/array_inquirer.rb

@@ -39,7 +39,7 @@ module ActiveSupport
         name.end_with?("?") || super
       end
 
-      def method_missing(name, *args)
+      def method_missing(name, ...)
         if name.end_with?("?")
           any?(name[0..-2])
         else

data/lib/active_support/backtrace_cleaner.rb

@@ -17,7 +17,8 @@ module ActiveSupport
   # can focus on the rest.
   #
   #   bc = ActiveSupport::BacktraceCleaner.new
-  #   bc.add_filter   { |line| line.gsub(Rails.root.to_s, '') } # strip the Rails.root prefix
+  #   root = "#{Rails.root}/"
+  #   bc.add_filter   { |line| line.delete_prefix(root) } # strip the Rails.root prefix
   #   bc.add_silencer { |line| /puma|rubygems/.match?(line) } # skip any lines from puma or rubygems
   #   bc.clean(exception.backtrace) # perform the cleanup
   #
@@ -33,6 +34,7 @@ module ActiveSupport
   class BacktraceCleaner
     def initialize
       @filters, @silencers = [], []
+      add_core_silencer
       add_gem_filter
       add_gem_silencer
       add_stdlib_silencer
@@ -75,8 +77,9 @@ module ActiveSupport
     # Adds a filter from the block provided. Each line in the backtrace will be
     # mapped against this filter.
     #
-    #   # Will turn "/my/rails/root/app/models/person.rb" into "/app/models/person.rb"
-    #   backtrace_cleaner.add_filter { |line| line.gsub(Rails.root.to_s, '') }
+    #   # Will turn "/my/rails/root/app/models/person.rb" into "app/models/person.rb"
+    #   root = "#{Rails.root}/"
+    #   backtrace_cleaner.add_filter { |line| line.start_with?(root) ? line.from(root.size) : line }
     def add_filter(&block)
       @filters << block
     end
@@ -107,6 +110,11 @@ module ActiveSupport
     private
       FORMATTED_GEMS_PATTERN = /\A[^\/]+ \([\w.]+\) /
 
+      def initialize_copy(_other)
+        @filters = @filters.dup
+        @silencers = @silencers.dup
+      end
+
       def add_gem_filter
         gems_paths = (Gem.path | [Gem.default_dir]).map { |p| Regexp.escape(p) }
         return if gems_paths.empty?
@@ -116,6 +124,10 @@ module ActiveSupport
         add_filter { |line| line.sub(gems_regexp, gems_result) }
       end
 
+      def add_core_silencer
+        add_silencer { |line| line.include?("<internal:") }
+      end
+
       def add_gem_silencer
         add_silencer { |line| FORMATTED_GEMS_PATTERN.match?(line) }
       end

data/lib/active_support/benchmark.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Benchmark # :nodoc:
+    # Benchmark realtime in the specified time unit. By default,
+    # the returned unit is in seconds.
+    #
+    #   ActiveSupport::Benchmark.realtime { sleep 0.1 }
+    #   # => 0.10007
+    #
+    #   ActiveSupport::Benchmark.realtime(:float_millisecond) { sleep 0.1 }
+    #   # => 100.07
+    #
+    # `unit` can be any of the values accepted by Ruby's `Process.clock_gettime`.
+    def self.realtime(unit = :float_second, &block)
+      time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC, unit)
+      yield
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, unit) - time_start
+    end
+  end
+end

data/lib/active_support/benchmarkable.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/benchmark"
 require "active_support/core_ext/hash/keys"
 
 module ActiveSupport
@@ -41,7 +40,9 @@ module ActiveSupport
         options[:level] ||= :info
 
         result = nil
-        ms = Benchmark.ms { result = options[:silence] ? logger.silence(&block) : yield }
+        ms = ActiveSupport::Benchmark.realtime(:float_millisecond) do
+          result = options[:silence] ? logger.silence(&block) : yield
+        end
         logger.public_send(options[:level], "%s (%.1fms)" % [ message, ms ])
         result
       else

data/lib/active_support/broadcast_logger.rb

@@ -113,33 +113,33 @@ module ActiveSupport
       dispatch { |logger| logger.<<(message) }
     end
 
-    def add(*args, &block)
-      dispatch { |logger| logger.add(*args, &block) }
+    def add(...)
+      dispatch { |logger| logger.add(...) }
     end
     alias_method :log, :add
 
-    def debug(*args, &block)
-      dispatch { |logger| logger.debug(*args, &block) }
+    def debug(...)
+      dispatch { |logger| logger.debug(...) }
     end
 
-    def info(*args, &block)
-      dispatch { |logger| logger.info(*args, &block) }
+    def info(...)
+      dispatch { |logger| logger.info(...) }
     end
 
-    def warn(*args, &block)
-      dispatch { |logger| logger.warn(*args, &block) }
+    def warn(...)
+      dispatch { |logger| logger.warn(...) }
     end
 
-    def error(*args, &block)
-      dispatch { |logger| logger.error(*args, &block) }
+    def error(...)
+      dispatch { |logger| logger.error(...) }
     end
 
-    def fatal(*args, &block)
-      dispatch { |logger| logger.fatal(*args, &block) }
+    def fatal(...)
+      dispatch { |logger| logger.fatal(...) }
     end
 
-    def unknown(*args, &block)
-      dispatch { |logger| logger.unknown(*args, &block) }
+    def unknown(...)
+      dispatch { |logger| logger.unknown(...) }
     end
 
     def formatter=(formatter)
@@ -229,17 +229,18 @@ module ActiveSupport
     private
       def dispatch(&block)
         @broadcasts.each { |logger| block.call(logger) }
+        true
       end
 
-      def method_missing(name, *args, **kwargs, &block)
+      def method_missing(name, ...)
         loggers = @broadcasts.select { |logger| logger.respond_to?(name) }
 
         if loggers.none?
-          super(name, *args, **kwargs, &block)
+          super
         elsif loggers.one?
-          loggers.first.send(name, *args, **kwargs, &block)
+          loggers.first.send(name, ...)
         else
-          loggers.map { |logger| logger.send(name, *args, **kwargs, &block) }
+          loggers.map { |logger| logger.send(name, ...) }
         end
       end
 

data/lib/active_support/cache/file_store.rb

@@ -58,7 +58,12 @@ module ActiveSupport
       #   cache.increment("baz") # => 6
       #
       def increment(name, amount = 1, options = nil)
-        modify_value(name, amount, options)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument(:increment, key, amount: amount) do
+          modify_value(name, amount, options)
+        end
       end
 
       # Decrement a cached integer value. Returns the updated value.
@@ -73,13 +78,19 @@ module ActiveSupport
       #   cache.decrement("baz") # => 4
       #
       def decrement(name, amount = 1, options = nil)
-        modify_value(name, -amount, options)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument(:decrement, key, amount: amount) do
+          modify_value(name, -amount, options)
+        end
       end
 
       def delete_matched(matcher, options = nil)
         options = merged_options(options)
+        matcher = key_matcher(matcher, options)
+
         instrument(:delete_matched, matcher.inspect) do
-          matcher = key_matcher(matcher, options)
           search_dir(cache_path) do |path|
             key = file_path_key(path)
             delete_entry(path, **options) if key.match(matcher)
@@ -209,18 +220,22 @@ module ActiveSupport
         # Modifies the amount of an integer value that is stored in the cache.
         # If the key is not found it is created and set to +amount+.
         def modify_value(name, amount, options)
-          file_name = normalize_key(name, options)
+          options = merged_options(options)
+          key = normalize_key(name, options)
+          version = normalize_version(name, options)
+          amount = Integer(amount)
 
-          lock_file(file_name) do
-            options = merged_options(options)
+          lock_file(key) do
+            entry = read_entry(key, **options)
 
-            if num = read(name, options)
-              num = num.to_i + amount
-              write(name, num, options)
-              num
-            else
-              write(name, Integer(amount), options)
+            if !entry || entry.expired? || entry.mismatched?(version)
+              write(name, amount, options)
               amount
+            else
+              num = entry.value.to_i + amount
+              entry = Entry.new(num, expires_at: entry.expires_at, version: entry.version)
+              write_entry(key, entry)
+              num
             end
           end
         end

data/lib/active_support/cache/mem_cache_store.rb

@@ -41,46 +41,6 @@ module ActiveSupport
 
       prepend Strategy::LocalCache
 
-      module DupLocalCache
-        class DupLocalStore < DelegateClass(Strategy::LocalCache::LocalStore)
-          def write_entry(_key, entry)
-            if entry.is_a?(Entry)
-              entry.dup_value!
-            end
-            super
-          end
-
-          def fetch_entry(key)
-            entry = super do
-              new_entry = yield
-              if entry.is_a?(Entry)
-                new_entry.dup_value!
-              end
-              new_entry
-            end
-            entry = entry.dup
-
-            if entry.is_a?(Entry)
-              entry.dup_value!
-            end
-
-            entry
-          end
-        end
-
-        private
-          def local_cache
-            if ActiveSupport::Cache.format_version == 6.1
-              if local_cache = super
-                DupLocalStore.new(local_cache)
-              end
-            else
-              super
-            end
-          end
-      end
-      prepend DupLocalCache
-
       KEY_MAX_SIZE = 250
       ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/n
 
@@ -114,7 +74,6 @@ module ActiveSupport
       #
       # If no addresses are provided, but <tt>ENV['MEMCACHE_SERVERS']</tt> is defined, it will be used instead. Otherwise,
       # +MemCacheStore+ will connect to localhost:11211 (the default memcached port).
-      # Passing a +Dalli::Client+ instance is deprecated and will be removed. Please pass an address instead.
       def initialize(*addresses)
         addresses = addresses.flatten
         options = addresses.extract_options!
@@ -126,19 +85,12 @@ module ActiveSupport
         unless [String, Dalli::Client, NilClass].include?(addresses.first.class)
           raise ArgumentError, "First argument must be an empty array, address, or array of addresses."
         end
-        if addresses.first.is_a?(Dalli::Client)
-          ActiveSupport.deprecator.warn(<<~MSG)
-            Initializing MemCacheStore with a Dalli::Client is deprecated and will be removed in Rails 7.2.
-            Use memcached server addresses instead.
-          MSG
-          @data = addresses.first
-        else
-          @mem_cache_options = options.dup
-          # The value "compress: false" prevents duplicate compression within Dalli.
-          @mem_cache_options[:compress] = false
-          (OVERRIDDEN_OPTIONS - %i(compress)).each { |name| @mem_cache_options.delete(name) }
-          @data = self.class.build_mem_cache(*(addresses + [@mem_cache_options]))
-        end
+
+        @mem_cache_options = options.dup
+        # The value "compress: false" prevents duplicate compression within Dalli.
+        @mem_cache_options[:compress] = false
+        (OVERRIDDEN_OPTIONS - %i(compress)).each { |name| @mem_cache_options.delete(name) }
+        @data = self.class.build_mem_cache(*(addresses + [@mem_cache_options]))
       end
 
       def inspect
@@ -179,9 +131,11 @@ module ActiveSupport
       # <tt>raw: true</tt>, will fail and return +nil+.
       def increment(name, amount = 1, options = nil)
         options = merged_options(options)
-        instrument(:increment, name, amount: amount) do
+        key = normalize_key(name, options)
+
+        instrument(:increment, key, amount: amount) do
           rescue_error_with nil do
-            @data.with { |c| c.incr(normalize_key(name, options), amount, options[:expires_in], amount) }
+            @data.with { |c| c.incr(key, amount, options[:expires_in], amount) }
           end
         end
       end
@@ -203,9 +157,11 @@ module ActiveSupport
       # <tt>raw: true</tt>, will fail and return +nil+.
       def decrement(name, amount = 1, options = nil)
         options = merged_options(options)
-        instrument(:decrement, name, amount: amount) do
+        key = normalize_key(name, options)
+
+        instrument(:decrement, key, amount: amount) do
           rescue_error_with nil do
-            @data.with { |c| c.decr(normalize_key(name, options), amount, options[:expires_in], 0) }
+            @data.with { |c| c.decr(key, amount, options[:expires_in], 0) }
           end
         end
       end
@@ -222,20 +178,6 @@ module ActiveSupport
       end
 
       private
-        def default_serializer
-          if Cache.format_version == 6.1
-            ActiveSupport.deprecator.warn <<~EOM
-              Support for `config.active_support.cache_format_version = 6.1` has been deprecated and will be removed in Rails 7.2.
-
-              Check the Rails upgrade guide at https://guides.rubyonrails.org/upgrading_ruby_on_rails.html#new-activesupport-cache-serialization-format
-              for more information on how to upgrade.
-            EOM
-            Cache::SerializerWithFallback[:passthrough]
-          else
-            super
-          end
-        end
-
         # Read an entry from the cache.
         def read_entry(key, **options)
           deserialize_entry(read_serialized_entry(key, **options), **options)
@@ -259,10 +201,10 @@ module ActiveSupport
             # Set the memcache expire a few minutes in the future to support race condition ttls on read
             expires_in += 5.minutes
           end
-          rescue_error_with false do
+          rescue_error_with nil do
             # Don't pass compress option to Dalli since we are already dealing with compression.
             options.delete(:compress)
-            @data.with { |c| c.send(method, key, payload, expires_in, **options) }
+            @data.with { |c| !!c.send(method, key, payload, expires_in, **options) }
           end
         end
 

data/lib/active_support/cache/memory_store.rb

@@ -147,7 +147,9 @@ module ActiveSupport
       #   cache.increment("baz") # => 6
       #
       def increment(name, amount = 1, options = nil)
-        modify_value(name, amount, options)
+        instrument(:increment, name, amount: amount) do
+          modify_value(name, amount, options)
+        end
       end
 
       # Decrement a cached integer value. Returns the updated value.
@@ -162,14 +164,17 @@ module ActiveSupport
       #   cache.decrement("baz") # => 4
       #
       def decrement(name, amount = 1, options = nil)
-        modify_value(name, -amount, options)
+        instrument(:decrement, name, amount: amount) do
+          modify_value(name, -amount, options)
+        end
       end
 
       # Deletes cache entries if the cache key matches a given pattern.
       def delete_matched(matcher, options = nil)
         options = merged_options(options)
+        matcher = key_matcher(matcher, options)
+
         instrument(:delete_matched, matcher.inspect) do
-          matcher = key_matcher(matcher, options)
           keys = synchronize { @data.keys }
           keys.each do |key|
             delete_entry(key, **options) if key.match(matcher)

data/lib/active_support/cache/redis_cache_store.rb

@@ -173,9 +173,12 @@ module ActiveSupport
         return {} if names.empty?
 
         options = names.extract_options!
-        instrument_multi(:read_multi, names, options) do |payload|
+        options = merged_options(options)
+        keys    = names.map { |name| normalize_key(name, options) }
+
+        instrument_multi(:read_multi, keys, options) do |payload|
           read_multi_entries(names, **options).tap do |results|
-            payload[:hits] = results.keys
+            payload[:hits] = results.keys.map { |name| normalize_key(name, options) }
           end
         end
       end
@@ -196,12 +199,13 @@ module ActiveSupport
       #
       # Failsafe: Raises errors.
       def delete_matched(matcher, options = nil)
-        instrument :delete_matched, matcher do
-          unless String === matcher
-            raise ArgumentError, "Only Redis glob strings are supported: #{matcher.inspect}"
-          end
+        unless String === matcher
+          raise ArgumentError, "Only Redis glob strings are supported: #{matcher.inspect}"
+        end
+        pattern = namespace_key(matcher, options)
+
+        instrument :delete_matched, pattern do
           redis.then do |c|
-            pattern = namespace_key(matcher, options)
             cursor = "0"
             # Fetch keys in batches using SCAN to avoid blocking the Redis server.
             nodes = c.respond_to?(:nodes) ? c.nodes : [c]
@@ -234,10 +238,11 @@ module ActiveSupport
       #
       # Failsafe: Raises errors.
       def increment(name, amount = 1, options = nil)
-        instrument :increment, name, amount: amount do
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument :increment, key, amount: amount do
           failsafe :increment do
-            options = merged_options(options)
-            key = normalize_key(name, options)
             change_counter(key, amount, options)
           end
         end
@@ -260,10 +265,11 @@ module ActiveSupport
       #
       # Failsafe: Raises errors.
       def decrement(name, amount = 1, options = nil)
-        instrument :decrement, name, amount: amount do
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument :decrement, key, amount: amount do
           failsafe :decrement do
-            options = merged_options(options)
-            key = normalize_key(name, options)
             change_counter(key, -amount, options)
           end
         end
@@ -369,8 +375,8 @@ module ActiveSupport
           if pipeline
             pipeline.set(key, payload, **modifiers)
           else
-            failsafe :write_entry, returning: false do
-              redis.then { |c| c.set key, payload, **modifiers }
+            failsafe :write_entry, returning: nil do
+              redis.then { |c| !!c.set(key, payload, **modifiers) }
             end
           end
         end

data/lib/active_support/cache/serializer_with_fallback.rb

@@ -63,28 +63,6 @@ module ActiveSupport
           end
         end
 
-        module Marshal61WithFallback
-          include SerializerWithFallback
-          extend self
-
-          MARSHAL_SIGNATURE = "\x04\x08".b.freeze
-
-          def dump(entry)
-            Marshal.dump(entry)
-          end
-
-          def dump_compressed(entry, threshold)
-            Marshal.dump(entry.compressed(threshold))
-          end
-
-          alias_method :_load, :marshal_load
-          public :_load
-
-          def dumped?(dumped)
-            dumped.start_with?(MARSHAL_SIGNATURE)
-          end
-        end
-
         module Marshal70WithFallback
           include SerializerWithFallback
           extend self
@@ -165,7 +143,6 @@ module ActiveSupport
 
         SERIALIZERS = {
           passthrough: PassthroughWithFallback,
-          marshal_6_1: Marshal61WithFallback,
           marshal_7_0: Marshal70WithFallback,
           marshal_7_1: Marshal71WithFallback,
           message_pack: MessagePackWithFallback,