activesupport 6.1.3.1 → 7.0.0.alpha1

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2005-2020 David Heinemeier Hansson
+Copyright (c) 2005-2021 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/active_support/actionable_error.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveSupport
-  # Actionable errors let's you define actions to resolve an error.
+  # Actionable errors lets you define actions to resolve an error.
   #
   # To make an error actionable, include the <tt>ActiveSupport::ActionableError</tt>
   # module and invoke the +action+ class macro to define the action. An action

data/lib/active_support/array_inquirer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/symbol/starts_ends_with"
-
 module ActiveSupport
   # Wrapping an array in an +ArrayInquirer+ gives a friendlier way to check
   # its string-like contents:

data/lib/active_support/benchmarkable.rb

@@ -34,13 +34,13 @@ module ActiveSupport
     #  <% benchmark 'Process data files', level: :info, silence: true do %>
     #    <%= expensive_and_chatty_files_operation %>
     #  <% end %>
-    def benchmark(message = "Benchmarking", options = {})
+    def benchmark(message = "Benchmarking", options = {}, &block)
       if logger
         options.assert_valid_keys(:level, :silence)
         options[:level] ||= :info
 
         result = nil
-        ms = Benchmark.ms { result = options[:silence] ? logger.silence { yield } : yield }
+        ms = Benchmark.ms { result = options[:silence] ? logger.silence(&block) : yield }
         logger.public_send(options[:level], "%s (%.1fms)" % [ message, ms ])
         result
       else

data/lib/active_support/cache/file_store.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/marshal"
 require "active_support/core_ext/file/atomic"
 require "active_support/core_ext/string/conversions"
 require "uri/common"
@@ -12,7 +11,6 @@ module ActiveSupport
     # FileStore implements the Strategy::LocalCache strategy which implements
     # an in-memory cache inside of a block.
     class FileStore < Store
-      prepend Strategy::LocalCache
       attr_reader :cache_path
 
       DIR_FORMATTER = "%03X"
@@ -20,7 +18,7 @@ module ActiveSupport
       FILEPATH_MAX_SIZE = 900 # max is 1024, plus some room
       GITKEEP_FILES = [".gitkeep", ".keep"].freeze
 
-      def initialize(cache_path, options = nil)
+      def initialize(cache_path, **options)
         super(options)
         @cache_path = cache_path.to_s
       end
@@ -73,19 +71,27 @@ module ActiveSupport
 
       private
         def read_entry(key, **options)
-          if File.exist?(key)
-            entry = File.open(key) { |f| deserialize_entry(f.read) }
+          if payload = read_serialized_entry(key, **options)
+            entry = deserialize_entry(payload)
             entry if entry.is_a?(Cache::Entry)
           end
-        rescue => e
-          logger.error("FileStoreError (#{e}): #{e.message}") if logger
+        end
+
+        def read_serialized_entry(key, **)
+          File.binread(key) if File.exist?(key)
+        rescue => error
+          logger.error("FileStoreError (#{error}): #{error.message}") if logger
           nil
         end
 
         def write_entry(key, entry, **options)
+          write_serialized_entry(key, serialize_entry(entry, **options), **options)
+        end
+
+        def write_serialized_entry(key, payload, **options)
           return false if options[:unless_exist] && File.exist?(key)
           ensure_cache_path(File.dirname(key))
-          File.atomic_write(key, cache_path) { |f| f.write(serialize_entry(entry)) }
+          File.atomic_write(key, cache_path) { |f| f.write(payload) }
           true
         end
 
@@ -95,9 +101,9 @@ module ActiveSupport
               File.delete(key)
               delete_empty_directories(File.dirname(key))
               true
-            rescue => e
+            rescue
               # Just in case the error was caused by another process deleting the file first.
-              raise e if File.exist?(key)
+              raise if File.exist?(key)
               false
             end
           end

data/lib/active_support/cache/mem_cache_store.rb

@@ -7,8 +7,8 @@ rescue LoadError => e
   raise e
 end
 
+require "delegate"
 require "active_support/core_ext/enumerable"
-require "active_support/core_ext/marshal"
 require "active_support/core_ext/array/extract_options"
 
 module ActiveSupport
@@ -26,29 +26,52 @@ module ActiveSupport
     # MemCacheStore implements the Strategy::LocalCache strategy which implements
     # an in-memory cache inside of a block.
     class MemCacheStore < Store
-      DEFAULT_CODER = NullCoder # Dalli automatically Marshal values
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
+      prepend Strategy::LocalCache
+
+      module DupLocalCache
+        class DupLocalStore < DelegateClass(Strategy::LocalCache::LocalStore)
+          def write_entry(_key, entry)
+            if entry.is_a?(Entry)
+              entry.dup_value!
+            end
+            super
+          end
+
+          def fetch_entry(key)
+            entry = super do
+              new_entry = yield
+              if entry.is_a?(Entry)
+                new_entry.dup_value!
+              end
+              new_entry
+            end
+            entry = entry.dup
+
+            if entry.is_a?(Entry)
+              entry.dup_value!
+            end
+
+            entry
+          end
+        end
 
-      # Provide support for raw values in the local cache strategy.
-      module LocalCacheWithRaw # :nodoc:
         private
-          def write_entry(key, entry, **options)
-            if options[:raw] && local_cache
-              raw_entry = Entry.new(entry.value.to_s)
-              raw_entry.expires_at = entry.expires_at
-              super(key, raw_entry, **options)
+          def local_cache
+            if ActiveSupport::Cache.format_version == 6.1
+              if local_cache = super
+                DupLocalStore.new(local_cache)
+              end
             else
               super
             end
           end
       end
-
-      # Advertise cache versioning support.
-      def self.supports_cache_versioning?
-        true
-      end
-
-      prepend Strategy::LocalCache
-      prepend LocalCacheWithRaw
+      prepend DupLocalCache
 
       ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/n
 
@@ -86,6 +109,9 @@ module ActiveSupport
       def initialize(*addresses)
         addresses = addresses.flatten
         options = addresses.extract_options!
+        if options.key?(:cache_nils)
+          options[:skip_nil] = !options.delete(:cache_nils)
+        end
         super(options)
 
         unless [String, Dalli::Client, NilClass].include?(addresses.first.class)
@@ -138,15 +164,72 @@ module ActiveSupport
       end
 
       private
+        module Coders # :nodoc:
+          class << self
+            def [](version)
+              case version
+              when 6.1
+                Rails61Coder
+              when 7.0
+                Rails70Coder
+              else
+                raise ArgumentError, "Unknown ActiveSupport::Cache.format_version #{Cache.format_version.inspect}"
+              end
+            end
+          end
+
+          module Loader
+            def load(payload)
+              if payload.is_a?(Entry)
+                payload
+              else
+                Cache::Coders::Loader.load(payload)
+              end
+            end
+          end
+
+          module Rails61Coder
+            include Loader
+            extend self
+
+            def dump(entry)
+              entry
+            end
+
+            def dump_compressed(entry, threshold)
+              entry.compressed(threshold)
+            end
+          end
+
+          module Rails70Coder
+            include Cache::Coders::Rails70Coder
+            include Loader
+            extend self
+          end
+        end
+
+        def default_coder
+          Coders[Cache.format_version]
+        end
+
         # Read an entry from the cache.
         def read_entry(key, **options)
-          rescue_error_with(nil) { deserialize_entry(@data.with { |c| c.get(key, options) }) }
+          deserialize_entry(read_serialized_entry(key, **options), **options)
+        end
+
+        def read_serialized_entry(key, **options)
+          rescue_error_with(nil) do
+            @data.with { |c| c.get(key, options) }
+          end
         end
 
         # Write an entry to the cache.
         def write_entry(key, entry, **options)
+          write_serialized_entry(key, serialize_entry(entry, **options), **options)
+        end
+
+        def write_serialized_entry(key, payload, **options)
           method = options[:unless_exist] ? :add : :set
-          value = options[:raw] ? entry.value.to_s : serialize_entry(entry)
           expires_in = options[:expires_in].to_i
           if options[:race_condition_ttl] && expires_in > 0 && !options[:raw]
             # Set the memcache expire a few minutes in the future to support race condition ttls on read
@@ -154,7 +237,7 @@ module ActiveSupport
           end
           rescue_error_with false do
             # The value "compress: false" prevents duplicate compression within Dalli.
-            @data.with { |c| c.send(method, key, value, expires_in, **options, compress: false) }
+            @data.with { |c| c.send(method, key, payload, expires_in, **options, compress: false) }
           end
         end
 
@@ -166,7 +249,7 @@ module ActiveSupport
           values = {}
 
           raw_values.each do |key, value|
-            entry = deserialize_entry(value)
+            entry = deserialize_entry(value, raw: options[:raw])
 
             unless entry.expired? || entry.mismatched?(normalize_version(keys_to_names[key], options))
               values[keys_to_names[key]] = entry.value
@@ -181,25 +264,33 @@ module ActiveSupport
           rescue_error_with(false) { @data.with { |c| c.delete(key) } }
         end
 
+        def serialize_entry(entry, raw: false, **options)
+          if raw
+            entry.value.to_s
+          else
+            super(entry, raw: raw, **options)
+          end
+        end
+
         # Memcache keys are binaries. So we need to force their encoding to binary
         # before applying the regular expression to ensure we are escaping all
         # characters properly.
         def normalize_key(key, options)
           key = super
-
           if key
             key = key.dup.force_encoding(Encoding::ASCII_8BIT)
             key = key.gsub(ESCAPE_KEY_CHARS) { |match| "%#{match.getbyte(0).to_s(16).upcase}" }
-            key = "#{key[0, 213]}:md5:#{ActiveSupport::Digest.hexdigest(key)}" if key.size > 250
+            key = "#{key[0, 212]}:hash:#{ActiveSupport::Digest.hexdigest(key)}" if key.size > 250
           end
-
           key
         end
 
-        def deserialize_entry(payload)
-          entry = super
-          entry = Entry.new(entry, compress: false) if entry && !entry.is_a?(Entry)
-          entry
+        def deserialize_entry(payload, raw: false, **)
+          if payload && raw
+            Entry.new(payload)
+          else
+            super(payload)
+          end
         end
 
         def rescue_error_with(fallback)

data/lib/active_support/cache/memory_store.rb

@@ -25,21 +25,25 @@ module ActiveSupport
     # MemoryStore is thread-safe.
     class MemoryStore < Store
       module DupCoder # :nodoc:
-        class << self
-          def load(entry)
-            entry = entry.dup
-            entry.dup_value!
-            entry
-          end
+        extend self
 
-          def dump(entry)
-            entry.dup_value!
-            entry
-          end
+        def dump(entry)
+          entry.dup_value! unless entry.compressed?
+          entry
+        end
+
+        def dump_compressed(entry, threshold)
+          entry = entry.compressed(threshold)
+          entry.dup_value! unless entry.compressed?
+          entry
         end
-      end
 
-      DEFAULT_CODER = DupCoder
+        def load(entry)
+          entry = entry.dup
+          entry.dup_value!
+          entry
+        end
+      end
 
       def initialize(options = nil)
         options ||= {}
@@ -139,6 +143,10 @@ module ActiveSupport
       private
         PER_ENTRY_OVERHEAD = 240
 
+        def default_coder
+          DupCoder
+        end
+
         def cached_size(key, payload)
           key.to_s.bytesize + payload.bytesize + PER_ENTRY_OVERHEAD
         end
@@ -156,7 +164,7 @@ module ActiveSupport
         end
 
         def write_entry(key, entry, **options)
-          payload = serialize_entry(entry)
+          payload = serialize_entry(entry, **options)
           synchronize do
             return false if options[:unless_exist] && @data.key?(key)
 

data/lib/active_support/cache/null_store.rb

@@ -33,10 +33,18 @@ module ActiveSupport
       end
 
       private
-        def read_entry(key, **options)
+        def read_entry(key, **s)
+          deserialize_entry(read_serialized_entry(key))
         end
 
-        def write_entry(key, entry, **options)
+        def read_serialized_entry(_key, **)
+        end
+
+        def write_entry(key, entry, **)
+          write_serialized_entry(key, serialize_entry(entry))
+        end
+
+        def write_serialized_entry(_key, _payload, **)
           true
         end
 

data/lib/active_support/cache/redis_cache_store.rb

@@ -15,8 +15,7 @@ begin
 rescue LoadError
 end
 
-require "digest/sha2"
-require "active_support/core_ext/marshal"
+require "active_support/digest"
 
 module ActiveSupport
   module Cache
@@ -46,7 +45,7 @@ module ActiveSupport
     #   4.0.1+ for distributed mget support.
     # * +delete_matched+ support for Redis KEYS globs.
     class RedisCacheStore < Store
-      # Keys are truncated with their own SHA2 digest if they exceed 1kB
+      # Keys are truncated with the ActiveSupport digest if they exceed 1kB
       MAX_KEY_BYTESIZE = 1024
 
       DEFAULT_REDIS_OPTIONS = {
@@ -71,35 +70,7 @@ module ActiveSupport
         true
       end
 
-      # Support raw values in the local cache strategy.
-      module LocalCacheWithRaw # :nodoc:
-        private
-          def write_entry(key, entry, **options)
-            if options[:raw] && local_cache
-              raw_entry = Entry.new(serialize_entry(entry, raw: true))
-              raw_entry.expires_at = entry.expires_at
-              super(key, raw_entry, **options)
-            else
-              super
-            end
-          end
-
-          def write_multi_entries(entries, **options)
-            if options[:raw] && local_cache
-              raw_entries = entries.map do |key, entry|
-                raw_entry = Entry.new(serialize_entry(entry, raw: true))
-                raw_entry.expires_at = entry.expires_at
-              end.to_h
-
-              super(raw_entries, **options)
-            else
-              super
-            end
-          end
-      end
-
       prepend Strategy::LocalCache
-      prepend LocalCacheWithRaw
 
       class << self
         # Factory method to create a new Redis instance.
@@ -113,7 +84,7 @@ module ActiveSupport
         #   :url    String  ->  Redis.new(url: …)
         #   :url    Array   ->  Redis::Distributed.new([{ url: … }, { url: … }, …])
         #
-        def build_redis(redis: nil, url: nil, **redis_options) #:nodoc:
+        def build_redis(redis: nil, url: nil, **redis_options) # :nodoc:
           urls = Array(url)
 
           if redis.is_a?(Proc)
@@ -169,7 +140,7 @@ module ActiveSupport
       # Race condition TTL is not set by default. This can be used to avoid
       # "thundering herd" cache writes when hot cache entries are expired.
       # See <tt>ActiveSupport::Cache::Store#fetch</tt> for more.
-      def initialize(namespace: nil, compress: true, compress_threshold: 1.kilobyte, coder: DEFAULT_CODER, expires_in: nil, race_condition_ttl: nil, error_handler: DEFAULT_ERROR_HANDLER, **redis_options)
+      def initialize(namespace: nil, compress: true, compress_threshold: 1.kilobyte, coder: default_coder, expires_in: nil, race_condition_ttl: nil, error_handler: DEFAULT_ERROR_HANDLER, **redis_options)
         @redis_options = redis_options
 
         @max_key_bytesize = MAX_KEY_BYTESIZE
@@ -319,12 +290,17 @@ module ActiveSupport
         end
       end
 
-      def mget_capable? #:nodoc:
+      # Get info from redis servers.
+      def stats
+        redis.with { |c| c.info }
+      end
+
+      def mget_capable? # :nodoc:
         set_redis_capabilities unless defined? @mget_capable
         @mget_capable
       end
 
-      def mset_capable? #:nodoc:
+      def mset_capable? # :nodoc:
         set_redis_capabilities unless defined? @mset_capable
         @mset_capable
       end
@@ -344,9 +320,12 @@ module ActiveSupport
         # Store provider interface:
         # Read an entry from the cache.
         def read_entry(key, **options)
+          deserialize_entry(read_serialized_entry(key, **options), **options)
+        end
+
+        def read_serialized_entry(key, raw: false, **options)
           failsafe :read_entry do
-            raw = options&.fetch(:raw, false)
-            deserialize_entry(redis.with { |c| c.get(key) }, raw: raw)
+            redis.with { |c| c.get(key) }
           end
         end
 
@@ -383,9 +362,11 @@ module ActiveSupport
         # Write an entry to the cache.
         #
         # Requires Redis 2.6.12+ for extended SET options.
-        def write_entry(key, entry, unless_exist: false, raw: false, expires_in: nil, race_condition_ttl: nil, **options)
-          serialized_entry = serialize_entry(entry, raw: raw)
+        def write_entry(key, entry, raw: false, **options)
+          write_serialized_entry(key, serialize_entry(entry, raw: raw, **options), raw: raw, **options)
+        end
 
+        def write_serialized_entry(key, payload, raw: false, unless_exist: false, expires_in: nil, race_condition_ttl: nil, **options)
           # If race condition TTL is in use, ensure that cache entries
           # stick around a bit longer after they would have expired
           # so we can purposefully serve stale entries.
@@ -393,16 +374,14 @@ module ActiveSupport
             expires_in += 5.minutes
           end
 
-          failsafe :write_entry, returning: false do
-            if unless_exist || expires_in
-              modifiers = {}
-              modifiers[:nx] = unless_exist
-              modifiers[:px] = (1000 * expires_in.to_f).ceil if expires_in
+          modifiers = {}
+          if unless_exist || expires_in
+            modifiers[:nx] = unless_exist
+            modifiers[:px] = (1000 * expires_in.to_f).ceil if expires_in
+          end
 
-              redis.with { |c| c.set key, serialized_entry, **modifiers }
-            else
-              redis.with { |c| c.set key, serialized_entry }
-            end
+          failsafe :write_entry, returning: false do
+            redis.with { |c| c.set key, payload, **modifiers }
           end
         end
 
@@ -429,7 +408,10 @@ module ActiveSupport
           if entries.any?
             if mset_capable? && expires_in.nil?
               failsafe :write_multi_entries do
-                redis.with { |c| c.mapped_mset(serialize_entries(entries, raw: options[:raw])) }
+                payload = serialize_entries(entries, **options)
+                redis.with do |c|
+                  c.mapped_mset(payload)
+                end
               end
             else
               super
@@ -444,7 +426,7 @@ module ActiveSupport
 
         def truncate_key(key)
           if key && key.bytesize > max_key_bytesize
-            suffix = ":sha2:#{::Digest::SHA2.hexdigest(key)}"
+            suffix = ":hash:#{ActiveSupport::Digest.hexdigest(key)}"
             truncate_at = max_key_bytesize - suffix.bytesize
             "#{key.byteslice(0, truncate_at)}#{suffix}"
           else
@@ -452,25 +434,25 @@ module ActiveSupport
           end
         end
 
-        def deserialize_entry(payload, raw:)
-          if payload && raw
-            Entry.new(payload, compress: false)
+        def deserialize_entry(payload, raw: false, **)
+          if raw && !payload.nil?
+            Entry.new(payload)
           else
             super(payload)
           end
         end
 
-        def serialize_entry(entry, raw: false)
+        def serialize_entry(entry, raw: false, **options)
           if raw
             entry.value.to_s
           else
-            super(entry)
+            super(entry, raw: raw, **options)
           end
         end
 
-        def serialize_entries(entries, raw: false)
+        def serialize_entries(entries, **options)
           entries.transform_values do |entry|
-            serialize_entry entry, raw: raw
+            serialize_entry(entry, **options)
           end
         end
 
@@ -485,8 +467,6 @@ module ActiveSupport
           if @error_handler
             @error_handler.(method: method, exception: exception, returning: returning)
           end
-        rescue => failsafe
-          warn "RedisCacheStore ignored exception in handle_exception: #{failsafe.class}: #{failsafe.message}\n  #{failsafe.backtrace.join("\n  ")}"
         end
     end
   end