activesupport 7.0.8.7 → 7.2.3

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

@@ -5,6 +5,8 @@ require "active_support/core_ext/string/inflections"
 module ActiveSupport
   module Cache
     module Strategy
+      # = Local \Cache \Strategy
+      #
       # Caches that implement LocalCache will be backed by an in-memory cache for the
       # duration of a block. Repeated calls to the cache for the same key will hit the
       # in-memory cache for faster access.
@@ -26,6 +28,8 @@ module ActiveSupport
           end
         end
 
+        # = Local \Cache \Store
+        #
         # Simple memory backed cache. This cache is not thread safe and is intended only
         # for serving as a temporary memory cache for a single thread.
         class LocalStore
@@ -72,21 +76,21 @@ module ActiveSupport
             local_cache_key)
         end
 
-        def clear(**options) # :nodoc:
+        def clear(options = nil) # :nodoc:
           return super unless cache = local_cache
           cache.clear(options)
           super
         end
 
-        def cleanup(**options) # :nodoc:
+        def cleanup(options = nil) # :nodoc:
           return super unless cache = local_cache
-          cache.clear
+          cache.clear(options)
           super
         end
 
         def delete_matched(matcher, options = nil) # :nodoc:
           return super unless cache = local_cache
-          cache.clear
+          cache.clear(options)
           super
         end
 
@@ -104,6 +108,40 @@ module ActiveSupport
           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
@@ -119,20 +157,33 @@ module ActiveSupport
             end
           end
 
-          def read_multi_entries(keys, **options)
+          def read_multi_entries(names, **options)
             return super unless local_cache
 
-            local_entries = local_cache.read_multi_entries(keys)
-            local_entries.transform_values! do |payload|
-              deserialize_entry(payload)&.value
+            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|
+              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_keys = keys - local_entries.keys
 
-            if missed_keys.any?
-              local_entries.merge!(super(missed_keys, **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, **)