activesupport 7.0.4 → 7.1.5.1

data/lib/active_support/cache/serializer_with_fallback.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "active_support/core_ext/kernel/reporting"
+
+module ActiveSupport
+  module Cache
+    module SerializerWithFallback # :nodoc:
+      def self.[](format)
+        if format.to_s.include?("message_pack") && !defined?(ActiveSupport::MessagePack)
+          require "active_support/message_pack"
+        end
+
+        SERIALIZERS.fetch(format)
+      end
+
+      def load(dumped)
+        if dumped.is_a?(String)
+          case
+          when MessagePackWithFallback.dumped?(dumped)
+            MessagePackWithFallback._load(dumped)
+          when Marshal71WithFallback.dumped?(dumped)
+            Marshal71WithFallback._load(dumped)
+          when Marshal70WithFallback.dumped?(dumped)
+            Marshal70WithFallback._load(dumped)
+          else
+            Cache::Store.logger&.warn("Unrecognized payload prefix #{dumped.byteslice(0).inspect}; deserializing as nil")
+            nil
+          end
+        elsif PassthroughWithFallback.dumped?(dumped)
+          PassthroughWithFallback._load(dumped)
+        else
+          Cache::Store.logger&.warn("Unrecognized payload class #{dumped.class}; deserializing as nil")
+          nil
+        end
+      end
+
+      private
+        def marshal_load(payload)
+          Marshal.load(payload)
+        rescue ArgumentError => error
+          raise Cache::DeserializationError, error.message
+        end
+
+        module PassthroughWithFallback
+          include SerializerWithFallback
+          extend self
+
+          def dump(entry)
+            entry
+          end
+
+          def dump_compressed(entry, threshold)
+            entry.compressed(threshold)
+          end
+
+          def _load(entry)
+            entry
+          end
+
+          def dumped?(dumped)
+            dumped.is_a?(Cache::Entry)
+          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
+
+          MARK_UNCOMPRESSED = "\x00".b.freeze
+          MARK_COMPRESSED   = "\x01".b.freeze
+
+          def dump(entry)
+            MARK_UNCOMPRESSED + Marshal.dump(entry.pack)
+          end
+
+          def dump_compressed(entry, threshold)
+            dumped = Marshal.dump(entry.pack)
+
+            if dumped.bytesize >= threshold
+              compressed = Zlib::Deflate.deflate(dumped)
+              return MARK_COMPRESSED + compressed if compressed.bytesize < dumped.bytesize
+            end
+
+            MARK_UNCOMPRESSED + dumped
+          end
+
+          def _load(marked)
+            dumped = marked.byteslice(1..-1)
+            dumped = Zlib::Inflate.inflate(dumped) if marked.start_with?(MARK_COMPRESSED)
+            Cache::Entry.unpack(marshal_load(dumped))
+          end
+
+          def dumped?(dumped)
+            dumped.start_with?(MARK_UNCOMPRESSED, MARK_COMPRESSED)
+          end
+        end
+
+        module Marshal71WithFallback
+          include SerializerWithFallback
+          extend self
+
+          MARSHAL_SIGNATURE = "\x04\x08".b.freeze
+
+          def dump(value)
+            Marshal.dump(value)
+          end
+
+          def _load(dumped)
+            marshal_load(dumped)
+          end
+
+          def dumped?(dumped)
+            dumped.start_with?(MARSHAL_SIGNATURE)
+          end
+        end
+
+        module MessagePackWithFallback
+          include SerializerWithFallback
+          extend self
+
+          def dump(value)
+            ActiveSupport::MessagePack::CacheSerializer.dump(value)
+          end
+
+          def _load(dumped)
+            ActiveSupport::MessagePack::CacheSerializer.load(dumped)
+          end
+
+          def dumped?(dumped)
+            available? && ActiveSupport::MessagePack.signature?(dumped)
+          end
+
+          private
+            def available?
+              return @available if defined?(@available)
+              silence_warnings { require "active_support/message_pack" }
+              @available = true
+            rescue LoadError
+              @available = false
+            end
+        end
+
+        SERIALIZERS = {
+          passthrough: PassthroughWithFallback,
+          marshal_6_1: Marshal61WithFallback,
+          marshal_7_0: Marshal70WithFallback,
+          marshal_7_1: Marshal71WithFallback,
+          message_pack: MessagePackWithFallback,
+        }
+    end
+  end
+end

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,35 +76,43 @@ 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
 
-        def increment(name, amount = 1, **options) # :nodoc:
+        def increment(name, amount = 1, options = nil) # :nodoc:
           return super unless local_cache
           value = bypass_local_cache { super }
-          write_cache_value(name, value, raw: true, **options)
+          if options
+            write_cache_value(name, value, raw: true, **options)
+          else
+            write_cache_value(name, value, raw: true)
+          end
           value
         end
 
-        def decrement(name, amount = 1, **options) # :nodoc:
+        def decrement(name, amount = 1, options = nil) # :nodoc:
           return super unless local_cache
           value = bypass_local_cache { super }
-          write_cache_value(name, value, raw: true, **options)
+          if options
+            write_cache_value(name, value, raw: true, **options)
+          else
+            write_cache_value(name, value, raw: true)
+          end
           value
         end
 
@@ -119,17 +131,20 @@ 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)
+            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).value
+              deserialize_entry(payload, **options)&.value
             end
-            missed_keys = keys - local_entries.keys
+            missed_names = names - local_entries.keys
 
-            if missed_keys.any?
-              local_entries.merge!(super(missed_keys, **options))
+            if missed_names.any?
+              local_entries.merge!(super(missed_names, **options))
             else
               local_entries
             end