Revert "Refactor LocalCache to avoid calling Marshal.dump as much"

activesupport/lib/active_support/cache.rb

@@ -858,10 +858,6 @@ def bytesize
         end
       end
 
-      def compressed? # :nodoc:
-        defined?(@compressed)
-      end
-
       # Duplicates the value in a class. This is used by cache implementations that don't natively
       # serialize entries to protect against accidental cache modifications.
       def dup_value!
@@ -897,6 +893,10 @@ def compress!(compress_threshold)
           end
         end
 
+        def compressed?
+          defined?(@compressed)
+        end
+
         def uncompress(value)
           Marshal.load(Zlib::Inflate.inflate(value))
         end

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

@@ -35,65 +35,6 @@ def self.cache_for(l); instance.cache_for l; 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 Entry # :nodoc:
-            class << self
-              def build(cache_entry)
-                return if cache_entry.nil?
-                return cache_entry if cache_entry.compressed?
-
-                value = cache_entry.value
-                if value.is_a?(String)
-                  DupableEntry.new(cache_entry)
-                elsif !value || value == true || value.is_a?(Numeric)
-                  new(cache_entry)
-                else
-                  MutableEntry.new(cache_entry)
-                end
-              end
-            end
-
-            attr_reader :value, :version, :expires_at
-
-            def initialize(cache_entry)
-              @value = cache_entry.value
-              @expires_at = cache_entry.expires_at
-              @version = cache_entry.version
-            end
-
-            def mismatched?(version)
-              @version && version && @version != version
-            end
-
-            def expired?
-              expires_at && expires_at <= Time.now.to_f
-            end
-          end
-
-          class DupableEntry < Entry # :nodoc:
-            def initialize(_cache_entry)
-              super
-              unless @value.frozen?
-                @value = @value.dup.freeze
-              end
-            end
-
-            def value
-              @value.dup
-            end
-          end
-
-          class MutableEntry < Entry # :nodoc:
-            def initialize(cache_entry)
-              @payload = Marshal.dump(cache_entry.value)
-              @expires_at = cache_entry.expires_at
-              @version = cache_entry.version
-            end
-
-            def value
-              Marshal.load(@payload)
-            end
-          end
-
           def initialize
             super
             @data = {}
@@ -124,7 +65,8 @@ def read_multi_entries(keys, **options)
           end
 
           def write_entry(key, entry, **options)
-            @data[key] = Entry.build(entry)
+            entry.dup_value!
+            @data[key] = entry
             true
           end
 
@@ -133,7 +75,10 @@ def delete_entry(key, **options)
           end
 
           def fetch_entry(key, options = nil) # :nodoc:
-            @data.fetch(key) { @data[key] = Entry.build(yield) }
+            entry = @data.fetch(key) { @data[key] = yield }
+            dup_entry = entry.dup
+            dup_entry&.dup_value!
+            dup_entry
           end
         end
 
@@ -186,12 +131,12 @@ def decrement(name, amount = 1, **options) # :nodoc:
           def read_entry(key, **options)
             if cache = local_cache
               hit = true
-              entry = cache.fetch_entry(key) do
+              value = cache.fetch_entry(key) do
                 hit = false
                 super
               end
               options[:event][:store] = cache.class.name if hit && options[:event]
-              entry
+              value
             else
               super
             end