activesupport 5.1.1 → 6.1.1

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

@@ -1,4 +1,5 @@
-require "active_support/core_ext/object/duplicable"
+# frozen_string_literal: true
+
 require "active_support/core_ext/string/inflections"
 require "active_support/per_thread_registry"
 
@@ -44,25 +45,40 @@ module ActiveSupport
             yield
           end
 
-          def clear
+          def clear(options = nil)
             @data.clear
           end
 
-          def read_entry(key, options)
+          def read_entry(key, **options)
             @data[key]
           end
 
-          def write_entry(key, value, options)
-            @data[key] = value
+          def read_multi_entries(keys, **options)
+            values = {}
+
+            keys.each do |name|
+              entry = read_entry(name, **options)
+              values[name] = entry.value if entry
+            end
+
+            values
+          end
+
+          def write_entry(key, entry, **options)
+            entry.dup_value!
+            @data[key] = entry
             true
           end
 
-          def delete_entry(key, options)
+          def delete_entry(key, **options)
             !!@data.delete(key)
           end
 
           def fetch_entry(key, options = nil) # :nodoc:
-            @data.fetch(key) { @data[key] = yield }
+            entry = @data.fetch(key) { @data[key] = yield }
+            dup_entry = entry.dup
+            dup_entry&.dup_value!
+            dup_entry
           end
         end
 
@@ -79,59 +95,89 @@ module ActiveSupport
             local_cache_key)
         end
 
-        def clear # :nodoc:
+        def clear(**options) # :nodoc:
+          return super unless cache = local_cache
+          cache.clear(options)
+          super
+        end
+
+        def cleanup(**options) # :nodoc:
           return super unless cache = local_cache
           cache.clear
           super
         end
 
-        def cleanup(options = nil) # :nodoc:
+        def delete_matched(matcher, options = nil) # :nodoc:
           return super unless cache = local_cache
-          cache.clear(options)
+          cache.clear
           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 }
-          write_cache_value(name, value, options)
+          write_cache_value(name, value, **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 }
-          write_cache_value(name, value, options)
+          write_cache_value(name, value, **options)
           value
         end
 
         private
-          def read_entry(key, options)
+          def read_entry(key, **options)
             if cache = local_cache
-              cache.fetch_entry(key) { super }
+              hit = true
+              value = cache.fetch_entry(key) do
+                hit = false
+                super
+              end
+              options[:event][:store] = cache.class.name if hit && options[:event]
+              value
             else
               super
             end
           end
 
-          def write_entry(key, entry, options)
-            local_cache.write_entry(key, entry, options) if local_cache
+          def read_multi_entries(keys, **options)
+            return super unless local_cache
+
+            local_entries = local_cache.read_multi_entries(keys, **options)
+            missed_keys = keys - local_entries.keys
+
+            if missed_keys.any?
+              local_entries.merge!(super(missed_keys, **options))
+            else
+              local_entries
+            end
+          end
+
+          def write_entry(key, entry, **options)
+            if options[:unless_exist]
+              local_cache.delete_entry(key, **options) if local_cache
+            else
+              local_cache.write_entry(key, entry, **options) if local_cache
+            end
+
             super
           end
 
-          def delete_entry(key, options)
-            local_cache.delete_entry(key, options) if local_cache
+          def delete_entry(key, **options)
+            local_cache.delete_entry(key, **options) if local_cache
             super
           end
 
-          def write_cache_value(name, value, options)
+          def write_cache_value(name, value, **options)
             name = normalize_key(name, options)
             cache = local_cache
             cache.mute do
               if value
                 cache.write(name, value, options)
               else
-                cache.delete(name, options)
+                cache.delete(name, **options)
               end
             end
           end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rack/body_proxy"
 require "rack/utils"