activesupport 4.0.12 → 7.0.2.4

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

@@ -1,5 +1,6 @@
-require 'active_support/core_ext/object/duplicable'
-require 'active_support/core_ext/string/inflections'
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/inflections"
 
 module ActiveSupport
   module Cache
@@ -8,82 +9,59 @@ module ActiveSupport
       # duration of a block. Repeated calls to the cache for the same key will hit the
       # in-memory cache for faster access.
       module LocalCache
-        # Class for storing and registering the local caches.
-        class LocalCacheRegistry # :nodoc:
-          extend ActiveSupport::PerThreadRegistry
+        autoload :Middleware, "active_support/cache/strategy/local_cache_middleware"
 
-          def initialize
-            @registry = {}
-          end
+        # Class for storing and registering the local caches.
+        module LocalCacheRegistry # :nodoc:
+          extend self
 
           def cache_for(local_cache_key)
-            @registry[local_cache_key]
+            registry = ActiveSupport::IsolatedExecutionState[:active_support_local_cache_registry] ||= {}
+            registry[local_cache_key]
           end
 
           def set_cache_for(local_cache_key, value)
-            @registry[local_cache_key] = value
+            registry = ActiveSupport::IsolatedExecutionState[:active_support_local_cache_registry] ||= {}
+            registry[local_cache_key] = value
           end
         end
 
         # 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 < Store
+        class LocalStore
           def initialize
-            super
             @data = {}
           end
 
-          # Don't allow synchronizing since it isn't thread safe,
-          def synchronize # :nodoc:
-            yield
-          end
-
           def clear(options = nil)
             @data.clear
           end
 
-          def read_entry(key, options)
+          def read_entry(key)
             @data[key]
           end
 
-          def write_entry(key, value, options)
-            @data[key] = value
-            true
+          def read_multi_entries(keys)
+            @data.slice(*keys)
           end
 
-          def delete_entry(key, options)
-            !!@data.delete(key)
+          def write_entry(key, entry)
+            @data[key] = entry
+            true
           end
-        end
 
-        # Use a local cache for the duration of block.
-        def with_local_cache
-          use_temporary_local_cache(LocalStore.new) { yield }
-        end
-
-        #--
-        # This class wraps up local storage for middlewares. Only the middleware method should
-        # construct them.
-        class Middleware # :nodoc:
-          attr_reader :name, :local_cache_key
-
-          def initialize(name, local_cache_key)
-            @name             = name
-            @local_cache_key = local_cache_key
-            @app              = nil
+          def delete_entry(key)
+            !!@data.delete(key)
           end
 
-          def new(app)
-            @app = app
-            self
+          def fetch_entry(key) # :nodoc:
+            @data.fetch(key) { @data[key] = yield }
           end
+        end
 
-          def call(env)
-            LocalCacheRegistry.set_cache_for(local_cache_key, LocalStore.new)
-            @app.call(env)
-          ensure
-            LocalCacheRegistry.set_cache_for(local_cache_key, nil)
-          end
+        # Use a local cache for the duration of block.
+        def with_local_cache(&block)
+          use_temporary_local_cache(LocalStore.new, &block)
         end
 
         # Middleware class can be inserted as a Rack handler to be local cache for the
@@ -94,75 +72,100 @@ module ActiveSupport
             local_cache_key)
         end
 
-        def clear(options = nil) # :nodoc:
-          local_cache.clear(options) if local_cache
+        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:
-          local_cache.clear(options) if local_cache
+        def delete_matched(matcher, options = nil) # :nodoc:
+          return super unless cache = local_cache
+          cache.clear
           super
         end
 
-        def increment(name, amount = 1, options = nil) # :nodoc:
-          value = bypass_local_cache{super}
-          increment_or_decrement(value, name, amount, options)
+        def increment(name, amount = 1, **options) # :nodoc:
+          return super unless local_cache
+          value = bypass_local_cache { super }
+          write_cache_value(name, value, raw: true, **options)
           value
         end
 
-        def decrement(name, amount = 1, options = nil) # :nodoc:
-          value = bypass_local_cache{super}
-          increment_or_decrement(value, name, amount, options)
+        def decrement(name, amount = 1, **options) # :nodoc:
+          return super unless local_cache
+          value = bypass_local_cache { super }
+          write_cache_value(name, value, raw: true, **options)
           value
         end
 
-        protected
-          def read_entry(key, options) # :nodoc:
-            if local_cache
-              entry = local_cache.read_entry(key, options)
-              unless entry
-                entry = super
-                local_cache.write_entry(key, entry, options)
+        private
+          def read_serialized_entry(key, raw: false, **options)
+            if cache = local_cache
+              hit = true
+              entry = cache.fetch_entry(key) do
+                hit = false
+                super
               end
+              options[:event][:store] = cache.class.name if hit && options[:event]
               entry
             else
               super
             end
           end
 
-          def write_entry(key, entry, options) # :nodoc:
-            local_cache.write_entry(key, entry, options) if local_cache
-            super
+          def read_multi_entries(keys, **options)
+            return super unless local_cache
+
+            local_entries = local_cache.read_multi_entries(keys)
+            missed_keys = keys - local_entries.keys
+
+            if missed_keys.any?
+              local_entries.merge!(super(missed_keys, **options))
+            else
+              local_entries
+            end
           end
 
-          def delete_entry(key, options) # :nodoc:
-            local_cache.delete_entry(key, options) if local_cache
+          def write_serialized_entry(key, payload, **)
+            if return_value = super
+              local_cache.write_entry(key, payload) if local_cache
+            else
+              local_cache.delete_entry(key) if local_cache
+            end
+            return_value
+          end
+
+          def delete_entry(key, **)
+            local_cache.delete_entry(key) if local_cache
             super
           end
 
-        private
-          def increment_or_decrement(value, name, amount, options)
-            if local_cache
-              local_cache.mute do
-                if value
-                  local_cache.write(name, value, options)
-                else
-                  local_cache.delete(name, options)
-                end
-              end
+          def write_cache_value(name, value, **options)
+            name = normalize_key(name, options)
+            cache = local_cache
+            if value
+              cache.write_entry(name, serialize_entry(new_entry(value, **options), **options))
+            else
+              cache.delete_entry(name)
             end
           end
 
           def local_cache_key
-            @local_cache_key ||= "#{self.class.name.underscore}_local_cache_#{object_id}".gsub(/[\/-]/, '_').to_sym
+            @local_cache_key ||= "#{self.class.name.underscore}_local_cache_#{object_id}".gsub(/[\/-]/, "_").to_sym
           end
 
           def local_cache
             LocalCacheRegistry.cache_for(local_cache_key)
           end
 
-          def bypass_local_cache
-            use_temporary_local_cache(nil) { yield }
+          def bypass_local_cache(&block)
+            use_temporary_local_cache(nil, &block)
           end
 
           def use_temporary_local_cache(temporary_cache)

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "rack/body_proxy"
+require "rack/utils"
+
+module ActiveSupport
+  module Cache
+    module Strategy
+      module LocalCache
+        #--
+        # This class wraps up local storage for middlewares. Only the middleware method should
+        # construct them.
+        class Middleware # :nodoc:
+          attr_reader :name, :local_cache_key
+
+          def initialize(name, local_cache_key)
+            @name = name
+            @local_cache_key = local_cache_key
+            @app = nil
+          end
+
+          def new(app)
+            @app = app
+            self
+          end
+
+          def call(env)
+            LocalCacheRegistry.set_cache_for(local_cache_key, LocalStore.new)
+            response = @app.call(env)
+            response[2] = ::Rack::BodyProxy.new(response[2]) do
+              LocalCacheRegistry.set_cache_for(local_cache_key, nil)
+            end
+            cleanup_on_body_close = true
+            response
+          rescue Rack::Utils::InvalidParameterError
+            [400, {}, []]
+          ensure
+            LocalCacheRegistry.set_cache_for(local_cache_key, nil) unless
+              cleanup_on_body_close
+          end
+        end
+      end
+    end
+  end
+end