activesupport 7.2.2.1 → 8.0.5

data/lib/active_support/broadcast_logger.rb

@@ -76,7 +76,6 @@ module ActiveSupport
 
     # Returns all the logger that are part of this broadcast.
     attr_reader :broadcasts
-    attr_reader :formatter
     attr_accessor :progname
 
     def initialize(*loggers)
@@ -105,131 +104,119 @@ module ActiveSupport
       @broadcasts.delete(logger)
     end
 
-    def level
-      @broadcasts.map(&:level).min
-    end
-
-    def <<(message)
-      dispatch { |logger| logger.<<(message) }
-    end
-
-    def add(...)
-      dispatch { |logger| logger.add(...) }
-    end
-    alias_method :log, :add
-
-    def debug(...)
-      dispatch { |logger| logger.debug(...) }
-    end
-
-    def info(...)
-      dispatch { |logger| logger.info(...) }
-    end
-
-    def warn(...)
-      dispatch { |logger| logger.warn(...) }
-    end
-
-    def error(...)
-      dispatch { |logger| logger.error(...) }
-    end
-
-    def fatal(...)
-      dispatch { |logger| logger.fatal(...) }
-    end
-
-    def unknown(...)
-      dispatch { |logger| logger.unknown(...) }
+    def local_level=(level)
+      @broadcasts.each do |logger|
+        logger.local_level = level if logger.respond_to?(:local_level=)
+      end
     end
 
-    def formatter=(formatter)
-      dispatch { |logger| logger.formatter = formatter }
-
-      @formatter = formatter
-    end
+    def local_level
+      loggers = @broadcasts.select { |logger| logger.respond_to?(:local_level) }
 
-    def level=(level)
-      dispatch { |logger| logger.level = level }
+      loggers.map do |logger|
+        logger.local_level
+      end.first
     end
-    alias_method :sev_threshold=, :level=
 
-    def local_level=(level)
-      dispatch do |logger|
-        logger.local_level = level if logger.respond_to?(:local_level=)
-      end
+    LOGGER_METHODS = %w[
+      << log add debug info warn error fatal unknown
+      level= sev_threshold= close
+      formatter formatter=
+    ] # :nodoc:
+    LOGGER_METHODS.each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(...)
+          dispatch(:#{method}, ...)
+        end
+      RUBY
     end
 
-    def close
-      dispatch { |logger| logger.close }
+    # Returns the lowest level of all the loggers in the broadcast.
+    def level
+      @broadcasts.map(&:level).min
     end
 
-    # +True+ if the log level allows entries with severity Logger::DEBUG to be written
-    # to at least one broadcast. +False+ otherwise.
+    # 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.
+    # Sets the log level to +Logger::DEBUG+ for the whole broadcast.
     def debug!
-      dispatch { |logger| logger.debug! }
+      dispatch(:debug!)
     end
 
-    # +True+ if the log level allows entries with severity Logger::INFO to be written
-    # to at least one broadcast. +False+ otherwise.
+    # 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.
+    # Sets the log level to +Logger::INFO+ for the whole broadcast.
     def info!
-      dispatch { |logger| logger.info! }
+      dispatch(:info!)
     end
 
-    # +True+ if the log level allows entries with severity Logger::WARN to be written
-    # to at least one broadcast. +False+ otherwise.
+    # 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.
+    # Sets the log level to +Logger::WARN+ for the whole broadcast.
     def warn!
-      dispatch { |logger| logger.warn! }
+      dispatch(:warn!)
     end
 
-    # +True+ if the log level allows entries with severity Logger::ERROR to be written
-    # to at least one broadcast. +False+ otherwise.
+    # 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.
+    # Sets the log level to +Logger::ERROR+ for the whole broadcast.
     def error!
-      dispatch { |logger| logger.error! }
+      dispatch(:error!)
     end
 
-    # +True+ if the log level allows entries with severity Logger::FATAL to be written
-    # to at least one broadcast. +False+ otherwise.
+    # 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.
+    # Sets the log level to +Logger::FATAL+ for the whole broadcast.
     def fatal!
-      dispatch { |logger| logger.fatal! }
+      dispatch(:fatal!)
     end
 
     def initialize_copy(other)
       @broadcasts = []
       @progname = other.progname.dup
-      @formatter = other.formatter.dup
 
       broadcast_to(*other.broadcasts.map(&:dup))
     end
 
     private
-      def dispatch(&block)
-        @broadcasts.each { |logger| block.call(logger) }
-        true
+      def dispatch(method, *args, **kwargs, &block)
+        if block_given?
+          # Maintain semantics that the first logger yields the block
+          # as normal, but subsequent loggers won't re-execute the block.
+          # Instead, the initial result is immediately returned.
+          called, result = false, nil
+          block = proc { |*args, **kwargs|
+            if called then result
+            else
+              called = true
+              result = yield(*args, **kwargs)
+            end
+          }
+        end
+
+        @broadcasts.map { |logger|
+          logger.send(method, *args, **kwargs, &block)
+        }.first
       end
 
       def method_missing(name, ...)

data/lib/active_support/cache/file_store.rb

@@ -57,8 +57,13 @@ module ActiveSupport
       #   cache.write("baz", 5)
       #   cache.increment("baz") # => 6
       #
-      def increment(name, amount = 1, options = nil)
-        modify_value(name, amount, options)
+      def increment(name, amount = 1, **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.
@@ -72,8 +77,13 @@ module ActiveSupport
       #   cache.write("baz", 5)
       #   cache.decrement("baz") # => 4
       #
-      def decrement(name, amount = 1, options = nil)
-        modify_value(name, -amount, options)
+      def decrement(name, amount = 1, **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)

data/lib/active_support/cache/mem_cache_store.rb

@@ -60,7 +60,7 @@ module ActiveSupport
         pool_options = retrieve_pool_options(options)
 
         if pool_options
-          ConnectionPool.new(pool_options) { Dalli::Client.new(addresses, options.merge(threadsafe: false)) }
+          ConnectionPool.new(**pool_options) { Dalli::Client.new(addresses, options.merge(threadsafe: false)) }
         else
           Dalli::Client.new(addresses, options)
         end
@@ -90,6 +90,9 @@ module ActiveSupport
         # 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) }
+        # Set the default serializer for Dalli to prevent warning about
+        # inheriting the default serializer.
+        @mem_cache_options[:serializer] = Marshal
         @data = self.class.build_mem_cache(*(addresses + [@mem_cache_options]))
       end
 
@@ -212,26 +215,24 @@ module ActiveSupport
         def read_multi_entries(names, **options)
           keys_to_names = names.index_by { |name| normalize_key(name, options) }
 
-          raw_values = begin
-            @data.with { |c| c.get_multi(keys_to_names.keys) }
-          rescue Dalli::UnmarshalError
-            {}
-          end
+          rescue_error_with({}) do
+            raw_values = @data.with { |c| c.get_multi(keys_to_names.keys) }
 
-          values = {}
+            values = {}
 
-          raw_values.each do |key, value|
-            entry = deserialize_entry(value, raw: options[:raw])
+            raw_values.each do |key, value|
+              entry = deserialize_entry(value, raw: options[:raw])
 
-            unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(keys_to_names[key], options))
-              begin
-                values[keys_to_names[key]] = entry.value
-              rescue DeserializationError
+              unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(keys_to_names[key], options))
+                begin
+                  values[keys_to_names[key]] = entry.value
+                rescue DeserializationError
+                end
               end
             end
-          end
 
-          values
+            values
+          end
         end
 
         # Delete an entry from the cache.
@@ -276,7 +277,7 @@ module ActiveSupport
 
         def rescue_error_with(fallback)
           yield
-        rescue Dalli::DalliError => error
+        rescue Dalli::DalliError, ConnectionPool::Error, ConnectionPool::TimeoutError => error
           logger.error("DalliError (#{error}): #{error.message}") if logger
           ActiveSupport.error_reporter&.report(
             error,

data/lib/active_support/cache/memory_store.rb

@@ -146,8 +146,10 @@ module ActiveSupport
       #   cache.write("baz", 5)
       #   cache.increment("baz") # => 6
       #
-      def increment(name, amount = 1, options = nil)
-        modify_value(name, amount, options)
+      def increment(name, amount = 1, **options)
+        instrument(:increment, name, amount: amount) do
+          modify_value(name, amount, **options)
+        end
       end
 
       # Decrement a cached integer value. Returns the updated value.
@@ -161,8 +163,10 @@ module ActiveSupport
       #   cache.write("baz", 5)
       #   cache.decrement("baz") # => 4
       #
-      def decrement(name, amount = 1, options = nil)
-        modify_value(name, -amount, options)
+      def decrement(name, amount = 1, **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.
@@ -234,7 +238,7 @@ 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)
+        def modify_value(name, amount, **options)
           options = merged_options(options)
           key     = normalize_key(name, options)
           version = normalize_version(name, options)

data/lib/active_support/cache/null_store.rb

@@ -25,10 +25,10 @@ module ActiveSupport
       def cleanup(options = nil)
       end
 
-      def increment(name, amount = 1, options = nil)
+      def increment(name, amount = 1, **options)
       end
 
-      def decrement(name, amount = 1, options = nil)
+      def decrement(name, amount = 1, **options)
       end
 
       def delete_matched(matcher, options = nil)

data/lib/active_support/cache/redis_cache_store.rb

@@ -150,7 +150,7 @@ module ActiveSupport
         universal_options = redis_options.extract!(*UNIVERSAL_OPTIONS)
 
         if pool_options = self.class.send(:retrieve_pool_options, redis_options)
-          @redis = ::ConnectionPool.new(pool_options) { self.class.build_redis(**redis_options) }
+          @redis = ::ConnectionPool.new(**pool_options) { self.class.build_redis(**redis_options) }
         else
           @redis = self.class.build_redis(**redis_options)
         end
@@ -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
@@ -480,7 +483,7 @@ module ActiveSupport
 
         def failsafe(method, returning: nil)
           yield
-        rescue ::Redis::BaseError => error
+        rescue ::Redis::BaseError, ConnectionPool::Error, ConnectionPool::TimeoutError => error
           @error_handler&.call(method: method, exception: error, returning: returning)
           returning
         end

data/lib/active_support/cache/strategy/local_cache.rb

@@ -94,28 +94,54 @@ module ActiveSupport
           super
         end
 
-        def increment(name, amount = 1, options = nil) # :nodoc:
+        def increment(name, amount = 1, **options) # :nodoc:
           return super unless local_cache
           value = bypass_local_cache { super }
-          if options
-            write_cache_value(name, value, raw: true, **options)
-          else
-            write_cache_value(name, value, raw: true)
-          end
+          write_cache_value(name, value, raw: true, **options)
           value
         end
 
-        def decrement(name, amount = 1, options = nil) # :nodoc:
+        def decrement(name, amount = 1, **options) # :nodoc:
           return super unless local_cache
           value = bypass_local_cache { super }
-          if options
-            write_cache_value(name, value, raw: true, **options)
-          else
-            write_cache_value(name, value, raw: true)
-          end
+          write_cache_value(name, value, raw: true, **options)
           value
         end
 
+        def fetch_multi(*names, &block) # :nodoc:
+          return super if local_cache.nil? || names.empty?
+
+          options = names.extract_options!
+          options = merged_options(options)
+
+          keys_to_names = names.index_by { |name| normalize_key(name, options) }
+
+          local_entries = local_cache.read_multi_entries(keys_to_names.keys)
+          results = local_entries.each_with_object({}) do |(key, value), result|
+            # If we recorded a miss in the local cache, `#fetch_multi` will forward
+            # that key to the real store, and the entry will be replaced
+            # local_cache.delete_entry(key)
+            next if value.nil?
+
+            entry = deserialize_entry(value, **options)
+
+            normalized_key = keys_to_names[key]
+            if entry.nil?
+              result[normalized_key] = nil
+            elsif entry.expired? || entry.mismatched?(normalize_version(normalized_key, options))
+              local_cache.delete_entry(key)
+            else
+              result[normalized_key] = entry.value
+            end
+          end
+
+          if results.size < names.size
+            results.merge!(super(*(names - results.keys), options, &block))
+          end
+
+          results
+        end
+
         private
           def read_serialized_entry(key, raw: false, **options)
             if cache = local_cache
@@ -137,17 +163,27 @@ module ActiveSupport
             keys_to_names = names.index_by { |name| normalize_key(name, options) }
 
             local_entries = local_cache.read_multi_entries(keys_to_names.keys)
-            local_entries.transform_keys! { |key| keys_to_names[key] }
-            local_entries.transform_values! do |payload|
-              deserialize_entry(payload, **options)&.value
+
+            results = local_entries.each_with_object({}) do |(key, value), result|
+              next if value.nil? # recorded cache miss
+
+              entry = deserialize_entry(value, **options)
+
+              normalized_key = keys_to_names[key]
+              if entry.nil?
+                result[normalized_key] = nil
+              elsif entry.expired? || entry.mismatched?(normalize_version(normalized_key, options))
+                local_cache.delete_entry(key)
+              else
+                result[normalized_key] = entry.value
+              end
             end
-            missed_names = names - local_entries.keys
 
-            if missed_names.any?
-              local_entries.merge!(super(missed_names, **options))
-            else
-              local_entries
+            if results.size < names.size
+              results.merge!(super(names - results.keys, **options))
             end
+
+            results
           end
 
           def write_serialized_entry(key, payload, **)

data/lib/active_support/cache.rb

@@ -35,6 +35,7 @@ module ActiveSupport
       :race_condition_ttl,
       :serializer,
       :skip_nil,
+      :raw,
     ]
 
     # Mapping of canonical option names to aliases that a store will recognize.
@@ -286,7 +287,7 @@ module ActiveSupport
       #   <tt>coder: nil</tt> to avoid the overhead of safeguarding against
       #   mutation.
       #
-      #   The +:coder+ option is mutally exclusive with the +:serializer+ and
+      #   The +:coder+ option is mutually exclusive with the +:serializer+ and
       #   +:compressor+ options. Specifying them together will raise an
       #   +ArgumentError+.
       #
@@ -386,7 +387,7 @@ module ActiveSupport
       #   process can try to generate a new value after the extended time window
       #   has elapsed.
       #
-      #     # Set all values to expire after one minute.
+      #     # Set all values to expire after one second.
       #     cache = ActiveSupport::Cache::MemoryStore.new(expires_in: 1)
       #
       #     cache.write("foo", "original value")
@@ -419,7 +420,7 @@ module ActiveSupport
       #     t1.join
       #
       #     p val_1 # => "new value 1"
-      #     p val_2 # => "oritinal value"
+      #     p val_2 # => "original value"
       #     p cache.fetch("foo") # => "new value 1"
       #
       #     # The entry requires 3 seconds to expire (expires_in + race_condition_ttl)
@@ -538,10 +539,11 @@ module ActiveSupport
 
         options = names.extract_options!
         options = merged_options(options)
+        keys    = names.map { |name| normalize_key(name, options) }
 
-        instrument_multi :read_multi, names, options do |payload|
+        instrument_multi :read_multi, keys, options do |payload|
           read_multi_entries(names, **options, event: payload).tap do |results|
-            payload[:hits] = results.keys
+            payload[:hits] = results.keys.map { |name| normalize_key(name, options) }
           end
         end
       end
@@ -551,8 +553,9 @@ module ActiveSupport
         return hash if hash.empty?
 
         options = merged_options(options)
+        normalized_hash = hash.transform_keys { |key| normalize_key(key, options) }
 
-        instrument_multi :write_multi, hash, options do |payload|
+        instrument_multi :write_multi, normalized_hash, options do |payload|
           entries = hash.each_with_object({}) do |(name, value), memo|
             memo[normalize_key(name, options)] = Entry.new(value, **options.merge(version: normalize_version(name, options)))
           end
@@ -596,9 +599,9 @@ module ActiveSupport
 
         options = names.extract_options!
         options = merged_options(options)
-
+        keys    = names.map { |name| normalize_key(name, options) }
         writes  = {}
-        ordered = instrument_multi :read_multi, names, options do |payload|
+        ordered = instrument_multi :read_multi, keys, options do |payload|
           if options[:force]
             reads = {}
           else
@@ -610,7 +613,7 @@ module ActiveSupport
           end
           writes.compact! if options[:skip_nil]
 
-          payload[:hits] = reads.keys
+          payload[:hits] = reads.keys.map { |name| normalize_key(name, options) }
           payload[:super_operation] = :fetch_multi
 
           ordered
@@ -943,9 +946,12 @@ module ActiveSupport
         #
         #   namespace_key 'foo', namespace: -> { 'cache' }
         #   # => 'cache:foo'
-        def namespace_key(key, options = nil)
-          options = merged_options(options)
-          namespace = options[:namespace]
+        def namespace_key(key, call_options = nil)
+          namespace = if call_options&.key?(:namespace)
+            call_options[:namespace]
+          else
+            options[:namespace]
+          end
 
           if namespace.respond_to?(:call)
             namespace = namespace.call
@@ -1030,8 +1036,7 @@ module ActiveSupport
               # When an entry has a positive :race_condition_ttl defined, put the stale entry back into the cache
               # for a brief period while the entry is being recalculated.
               entry.expires_at = Time.now.to_f + race_ttl
-              options[:expires_in] = race_ttl * 2
-              write_entry(key, entry, **options)
+              write_entry(key, entry, **options, expires_in: race_ttl * 2)
             else
               delete_entry(key, **options)
             end

data/lib/active_support/callbacks.rb

@@ -6,7 +6,6 @@ require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/class/attribute"
 require "active_support/core_ext/string/filters"
 require "active_support/core_ext/object/blank"
-require "thread"
 
 module ActiveSupport
   # = Active Support \Callbacks
@@ -67,7 +66,7 @@ module ActiveSupport
 
     included do
       extend ActiveSupport::DescendantsTracker
-      class_attribute :__callbacks, instance_writer: false, default: {}
+      class_attribute :__callbacks, instance_writer: false, instance_predicate: false, default: {}
     end
 
     CALLBACK_FILTER_TYPES = [:before, :after, :around].freeze
@@ -499,9 +498,10 @@ module ActiveSupport
           when Conditionals::Value
             ProcCall.new(filter)
           when ::Proc
-            if filter.arity > 1
+            case filter.arity
+            when 2
               InstanceExec2.new(filter)
-            elsif filter.arity > 0
+            when 1, -2
               InstanceExec1.new(filter)
             else
               InstanceExec0.new(filter)
@@ -934,7 +934,10 @@ module ActiveSupport
           end
 
           def set_callbacks(name, callbacks) # :nodoc:
-            unless singleton_class.method_defined?(:__callbacks, false)
+            # HACK: We're making assumption on how `class_attribute` is implemented
+            # to save constantly duping the callback hash. If this desync with class_attribute
+            # we'll lose the optimization, but won't cause an actual behavior bug.
+            unless singleton_class.private_method_defined?(:__class_attr__callbacks, false)
               self.__callbacks = __callbacks.dup
             end
             self.__callbacks[name.to_sym] = callbacks

data/lib/active_support/class_attribute.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module ClassAttribute # :nodoc:
+    class << self
+      def redefine(owner, name, namespaced_name, value)
+        if owner.singleton_class?
+          if owner.attached_object.is_a?(Module)
+            redefine_method(owner, namespaced_name, private: true) { value }
+          else
+            redefine_method(owner, name) { value }
+          end
+        end
+
+        redefine_method(owner.singleton_class, namespaced_name, private: true) { value }
+
+        redefine_method(owner.singleton_class, "#{namespaced_name}=", private: true) do |new_value|
+          if owner.equal?(self)
+            value = new_value
+          else
+            ::ActiveSupport::ClassAttribute.redefine(self, name, namespaced_name, new_value)
+          end
+        end
+      end
+
+      def redefine_method(owner, name, private: false, &block)
+        owner.silence_redefinition_of_method(name)
+        owner.define_method(name, &block)
+        owner.send(:private, name) if private
+      end
+    end
+  end
+end