faraday-http-cache 2.2.0 → 2.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f19d02b8f8069a385636da706ab6ac31f03ed794
-  data.tar.gz: 86052f071b2b1cee24dc7fa8af957cd59fd95244
+SHA256:
+  metadata.gz: 6f9734c5eda496aee6fc6d189e27f9e39b43600ffb467976649ad3f7046a8efc
+  data.tar.gz: 1a4d2d137c3ec0a97790cc4b5bcb706f7e0c2af0d0700e0ae03dfc79f5e2bdba
 SHA512:
-  metadata.gz: 3c14cd6befa55a2df9e08c24df11fb92a437384e0490a705193506905ac1532fcb43e6439867bc8243b35dafd1610a965fa5a3bbf6feabfe4321544e7cbe1664
-  data.tar.gz: 764cc0374795c32d68bb64399698450c367916b7ef69612d07a91b9619c893fa5b35b65cb76930e9fb129e3d53694bde6a11a99c4ee14238b9beac4f1dd1e2ea
+  metadata.gz: f93240786d8c3b8012cce14545e2f0f34f1bb12811da4edc549ad145284712b59380dac02f91ed6170d19af7af220e48d905a31a1159129d2b32b45799251df6
+  data.tar.gz: 8b2480bebc178003743ca2e0535966ad617349ef7ead2f7b5907f00d4580ba990332472d2ac393dc6b5bd79b787d8d560e5d772f9bfc1faca76ac6b34a5061d7

data/README.md

@@ -1,8 +1,9 @@
 # Faraday Http Cache
 
-[![Build Status](https://secure.travis-ci.org/sourcelevel/faraday-http-cache.svg?branch=master)](https://travis-ci.org/sourcelevel/faraday-http-cache)
+[![Gem Version](https://badge.fury.io/rb/faraday-http-cache.svg)](https://rubygems.org/gems/faraday-http-cache)
+[![Build](https://github.com/sourcelevel/faraday-http-cache/actions/workflows/main.yml/badge.svg)](https://github.com/sourcelevel/faraday-http-cache/actions)
 
-a [Faraday](https://github.com/lostisland/faraday) middleware that respects HTTP cache,
+A [Faraday](https://github.com/lostisland/faraday) middleware that respects HTTP cache,
 by checking expiration and validation of the stored responses.
 
 ## Installation
@@ -53,15 +54,15 @@ This type of store **might not be persisted across multiple processes or connect
 so it is probably not suitable for most production environments.
 Make sure that you configure a store that is suitable for you.
 
-The stdlib `JSON` module is used for serialization by default, which can struggle with unicode 
-characters in responses. For example, if your JSON returns `"name": "Raül"` then you might see 
-errors like:
+The stdlib `JSON` module is used for serialization by default, which can struggle with unicode
+characters in responses in Ruby < 3.1. For example, if your JSON returns `"name": "Raül"` then
+you might see errors like:
 
 ```
 Response could not be serialized: "\xC3" from ASCII-8BIT to UTF-8. Try using Marshal to serialize.
 ```
 
-For full unicode support, or if you expect to be dealing with images, you can use 
+For full unicode support, or if you expect to be dealing with images, you can use the stdlib
 [Marshal][marshal] instead. Alternatively you could use another json library like `oj` or `yajl-ruby`.
 
 ```ruby
@@ -71,9 +72,47 @@ client = Faraday.new do |builder|
 end
 ```
 
+### Strategies
+
+You can provide a `:strategy` option to the middleware to specify the strategy to use.
+
+```ruby
+client = Faraday.new do |builder|
+  builder.use :http_cache, store: Rails.cache, strategy: Faraday::HttpCache::Strategies::ByVary
+  builder.adapter Faraday.default_adapter
+end
+```
+
+Available strategies are:
+
+#### `Faraday::HttpCache::Strategies::ByUrl`
+
+The default strategy.
+It Uses URL + HTTP method to generate cache keys and stores an array of request + response for each key.
+
+#### `Faraday::HttpCache::Strategies::ByVary`
+
+This strategy uses headers from `Vary` header to generate cache keys.
+It also uses cache to store `Vary` headers mapped to the request URL.
+This strategy is more suitable for caching private responses with the same URLs but different results for different users, like `https://api.github.com/user`.
+
+*Note:* To automatically remove stale cache keys, you might want to use the `:expires_in` option.
+
+```ruby
+store = ActiveSupport::Cache.lookup_store(:redis_cache_store, expires_in: 1.day, url: 'redis://localhost:6379/0')
+client = Faraday.new do |builder|
+  builder.use :http_cache, store: store, strategy: Faraday::HttpCache::Strategies::ByVary
+  builder.adapter Faraday.default_adapter
+end
+```
+
+#### Custom strategies
+
+You can write your own strategy by subclassing `Faraday::HttpCache::Strategies::BaseStrategy` and implementing `#write`, `#read` and `#delete` methods.
+
 ### Logging
 
-You can provide a `:logger` option that will be receive debug informations based on the middleware
+You can provide a `:logger` option that will receive debug information based on the middleware
 operations:
 
 ```ruby
@@ -82,7 +121,7 @@ client = Faraday.new do |builder|
   builder.adapter Faraday.default_adapter
 end
 
-client.get('http://site/api/users')
+client.get('https://site/api/users')
 # logs "HTTP Cache: [GET users] miss, store"
 ```
 
@@ -133,6 +172,7 @@ execute the files under the `examples` directory to see a sample of the middlewa
 ## What gets cached?
 
 The middleware will use the following headers to make caching decisions:
+- Vary
 - Cache-Control
 - Age
 - Last-Modified
@@ -155,7 +195,7 @@ client = Faraday.new do |builder|
   builder.adapter Faraday.default_adapter
 end
 
-client.get('http://site/api/some-private-resource') # => will be cached
+client.get('https://site/api/some-private-resource') # => will be cached
 ```
 
 ## License
@@ -163,4 +203,4 @@ client.get('http://site/api/some-private-resource') # => will be cached
 Copyright (c) 2012-2018 Plataformatec.
 Copyright (c) 2019 SourceLevel and contributors.
 
-  [marshal]: http://www.ruby-doc.org/core-2.0/Marshal.html
+  [marshal]: https://www.ruby-doc.org/core-3.0/Marshal.html

data/lib/faraday/http_cache/cache_control.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Faraday
   class HttpCache < Faraday::Middleware
     # Internal: A class to represent the 'Cache-Control' header options.

data/lib/faraday/http_cache/memory_store.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Faraday
+  class HttpCache < Faraday::Middleware
+    # @private
+    # A Hash based store to be used by strategies
+    # when a `store` is not provided for the middleware setup.
+    class MemoryStore
+      def initialize
+        @cache = {}
+      end
+
+      def read(key)
+        @cache[key]
+      end
+
+      def delete(key)
+        @cache.delete(key)
+      end
+
+      def write(key, value)
+        @cache[key] = value
+      end
+    end
+  end
+end

data/lib/faraday/http_cache/request.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Faraday
   class HttpCache < Faraday::Middleware
     # Internal: A class to represent a request
@@ -24,6 +25,7 @@ module Faraday
       def cacheable?
         return false if method != :get && method != :head
         return false if cache_control.no_store?
+
         true
       end
 

data/lib/faraday/http_cache/response.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'time'
 require 'faraday/http_cache/cache_control'
 
@@ -204,7 +205,7 @@ module Faraday
       # Returns nothing.
       def ensure_date_header!
         date
-      rescue
+      rescue StandardError
         headers['Date'] = @now.httpdate
       end
 

data/lib/faraday/http_cache/storage.rb

@@ -1,193 +1,15 @@
 # frozen_string_literal: true
-require 'json'
-require 'digest/sha1'
+
+require 'faraday/http_cache/strategies/by_url'
 
 module Faraday
   class HttpCache < Faraday::Middleware
-    # Internal: A wrapper around an ActiveSupport::CacheStore to store responses.
-    #
-    # Examples
-    #
-    #   # Creates a new Storage using a MemCached backend from ActiveSupport.
-    #   mem_cache_store = ActiveSupport::Cache.lookup_store(:mem_cache_store, ['localhost:11211'])
-    #   Faraday::HttpCache::Storage.new(store: mem_cache_store)
-    #
-    #   # Reuse some other instance of an ActiveSupport::Cache::Store object.
-    #   Faraday::HttpCache::Storage.new(store: Rails.cache)
-    #
-    #   # Creates a new Storage using Marshal for serialization.
-    #   Faraday::HttpCache::Storage.new(store: Rails.cache, serializer: Marshal)
-    class Storage
-      # Public: Gets the underlying cache store object.
-      attr_reader :cache
-
-      # Internal: Initialize a new Storage object with a cache backend.
-      #
-      # :logger     - A Logger object to be used to emit warnings.
-      # :store      - An cache store object that should respond to 'read',
-      #              'write', and 'delete'.
-      # :serializer - A serializer object that should respond to 'dump'
-      #               and 'load'.
-      def initialize(store: nil, serializer: nil, logger: nil)
-        @cache = store || MemoryStore.new
-        @serializer = serializer || JSON
-        @logger = logger
-        assert_valid_store!
-      end
-
-      # Internal: Store a response inside the cache.
-      #
-      # request  - A Faraday::HttpCache::::Request instance of the executed HTTP
-      #            request.
-      # response - The Faraday::HttpCache::Response instance to be stored.
-      #
-      # Returns nothing.
-      def write(request, response)
-        key = cache_key_for(request.url)
-        entry = serialize_entry(request.serializable_hash, response.serializable_hash)
-
-        entries = cache.read(key) || []
-        entries = entries.dup if entries.frozen?
-
-        entries.reject! do |(cached_request, cached_response)|
-          response_matches?(request, deserialize_object(cached_request), deserialize_object(cached_response))
-        end
-
-        entries << entry
-
-        cache.write(key, entries)
-      rescue ::Encoding::UndefinedConversionError => e
-        warn "Response could not be serialized: #{e.message}. Try using Marshal to serialize."
-        raise e
-      end
-
-      # Internal: Attempt to retrieve an stored response that suits the incoming
-      # HTTP request.
-      #
-      # request  - A Faraday::HttpCache::::Request instance of the incoming HTTP
-      #            request.
-      # klass    - The Class to be instantiated with the stored response.
-      #
-      # Returns an instance of 'klass'.
-      def read(request, klass: Faraday::HttpCache::Response)
-        cache_key = cache_key_for(request.url)
-        entries = cache.read(cache_key)
-        response = lookup_response(request, entries)
-
-        if response
-          klass.new(response)
-        end
-      end
-
-      def delete(url)
-        cache_key = cache_key_for(url)
-        cache.delete(cache_key)
-      end
-
-      private
-
-      # Internal: Retrieve a response Hash from the list of entries that match
-      # the given request.
-      #
-      # request  - A Faraday::HttpCache::::Request instance of the incoming HTTP
-      #            request.
-      # entries  - An Array of pairs of Hashes (request, response).
-      #
-      # Returns a Hash or nil.
-      def lookup_response(request, entries)
-        if entries
-          entries = entries.map { |entry| deserialize_entry(*entry) }
-          _, response = entries.find { |req, res| response_matches?(request, req, res) }
-          response
-        end
-      end
-
-      # Internal: Check if a cached response and request matches the given
-      # request.
-      #
-      # request         - A Faraday::HttpCache::::Request instance of the
-      #                   current HTTP request.
-      # cached_request  - The Hash of the request that was cached.
-      # cached_response - The Hash of the response that was cached.
-      #
-      # Returns true or false.
-      def response_matches?(request, cached_request, cached_response)
-        request.method.to_s == cached_request[:method].to_s &&
-          vary_matches?(cached_response, request, cached_request)
-      end
-
-      def vary_matches?(cached_response, request, cached_request)
-        headers = Faraday::Utils::Headers.new(cached_response[:response_headers])
-        vary = headers['Vary'].to_s
-
-        vary.empty? || (vary != '*' && vary.split(/[\s,]+/).all? do |header|
-          request.headers[header] == cached_request[:headers][header]
-        end)
-      end
-
-      def serialize_entry(*objects)
-        objects.map { |object| serialize_object(object) }
-      end
-
-      def serialize_object(object)
-        @serializer.dump(object)
-      end
-
-      def deserialize_entry(*objects)
-        objects.map { |object| deserialize_object(object) }
-      end
-
-      def deserialize_object(object)
-        @serializer.load(object).each_with_object({}) do |(key, value), hash|
-          hash[key.to_sym] = value
-        end
-      end
-
-      # Internal: Computes the cache key for a specific request, taking in
-      # account the current serializer to avoid cross serialization issues.
-      #
-      # url - The request URL.
-      #
-      # Returns a String.
-      def cache_key_for(url)
-        prefix = (@serializer.is_a?(Module) ? @serializer : @serializer.class).name
-        Digest::SHA1.hexdigest("#{prefix}#{url}")
-      end
-
-      # Internal: Checks if the given cache object supports the
-      # expect API ('read' and 'write').
-      #
-      # Raises an 'ArgumentError'.
-      #
-      # Returns nothing.
-      def assert_valid_store!
-        unless cache.respond_to?(:read) && cache.respond_to?(:write) && cache.respond_to?(:delete)
-          raise ArgumentError.new("#{cache.inspect} is not a valid cache store as it does not responds to 'read', 'write' or 'delete'.")
-        end
-      end
-
-      def warn(message)
-        @logger.warn(message) if @logger
-      end
-    end
-
-    # Internal: A Hash based store to be used by the 'Storage' class
-    # when a 'store' is not provided for the middleware setup.
-    class MemoryStore
-      def initialize
-        @cache = {}
-      end
-
-      def read(key)
-        @cache[key]
-      end
-
-      def delete(key)
-        @cache.delete(key)
-      end
-
-      def write(key, value)
-        @cache[key] = value
+    # @deprecated Use Faraday::HttpCache::Strategies::ByUrl instead.
+    class Storage < Faraday::HttpCache::Strategies::ByUrl
+      def initialize(*)
+        Kernel.warn("Deprecated: #{self.class} is deprecated and will be removed in " \
+             'the next major release. Use Faraday::HttpCache::Strategies::ByUrl instead.')
+        super
       end
     end
   end

data/lib/faraday/http_cache/strategies/base_strategy.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'logger'
+require 'faraday/http_cache/memory_store'
+
+module Faraday
+  class HttpCache < Faraday::Middleware
+    module Strategies
+      # Base class for all strategies.
+      # @abstract
+      #
+      # @example
+      #
+      #   # Creates a new strategy using a MemCached backend from ActiveSupport.
+      #   mem_cache_store = ActiveSupport::Cache.lookup_store(:mem_cache_store, ['localhost:11211'])
+      #   Faraday::HttpCache::Strategies::ByVary.new(store: mem_cache_store)
+      #
+      #   # Reuse some other instance of an ActiveSupport::Cache::Store object.
+      #   Faraday::HttpCache::Strategies::ByVary.new(store: Rails.cache)
+      #
+      #   # Creates a new strategy using Marshal for serialization.
+      #   Faraday::HttpCache::Strategies::ByVary.new(store: Rails.cache, serializer: Marshal)
+      class BaseStrategy
+        # Returns the underlying cache store object.
+        attr_reader :cache
+
+        # @param [Hash] options the options to create a message with.
+        # @option options [Faraday::HttpCache::MemoryStore, nil] :store - a cache
+        #   store object that should respond to 'read', 'write', and 'delete'.
+        # @option options [#dump#load] :serializer - an object that should
+        #   respond to 'dump' and 'load'.
+        # @option options [Logger, nil] :logger - an object to be used to emit warnings.
+        def initialize(options = {})
+          @cache = options[:store] || Faraday::HttpCache::MemoryStore.new
+          @serializer = options[:serializer] || JSON
+          @logger = options[:logger] || Logger.new(IO::NULL)
+          @cache_salt = (@serializer.is_a?(Module) ? @serializer : @serializer.class).name
+          assert_valid_store!
+        end
+
+        # Store a response inside the cache.
+        # @abstract
+        def write(_request, _response)
+          raise NotImplementedError, 'Implement this method in your strategy'
+        end
+
+        # Read a response from the cache.
+        # @abstract
+        def read(_request)
+          raise NotImplementedError, 'Implement this method in your strategy'
+        end
+
+        # Delete responses from the cache by the url.
+        # @abstract
+        def delete(_url)
+          raise NotImplementedError, 'Implement this method in your strategy'
+        end
+
+        private
+
+        # @private
+        # @raise [ArgumentError] if the cache object doesn't support the expect API.
+        def assert_valid_store!
+          unless cache.respond_to?(:read) && cache.respond_to?(:write) && cache.respond_to?(:delete)
+            raise ArgumentError.new("#{cache.inspect} is not a valid cache store as it does not responds to 'read', 'write' or 'delete'.")
+          end
+        end
+
+        def serialize_entry(*objects)
+          objects.map { |object| serialize_object(object) }
+        end
+
+        def serialize_object(object)
+          @serializer.dump(object)
+        end
+
+        def deserialize_entry(*objects)
+          objects.map { |object| deserialize_object(object) }
+        end
+
+        def deserialize_object(object)
+          @serializer.load(object).each_with_object({}) do |(key, value), hash|
+            hash[key.to_sym] = value
+          end
+        end
+
+        def warn(message)
+          @logger.warn(message)
+        end
+      end
+    end
+  end
+end

data/lib/faraday/http_cache/strategies/by_url.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'digest/sha1'
+
+require 'faraday/http_cache/strategies/base_strategy'
+
+module Faraday
+  class HttpCache < Faraday::Middleware
+    module Strategies
+      # The original strategy by Faraday::HttpCache.
+      # Uses URL + HTTP method to generate cache keys.
+      class ByUrl < BaseStrategy
+        # Store a response inside the cache.
+        #
+        # @param [Faraday::HttpCache::Request] request - instance of the executed HTTP request.
+        # @param [Faraday::HttpCache::Response] response - instance to be stored.
+        #
+        # @return [void]
+        def write(request, response)
+          key = cache_key_for(request.url)
+          entry = serialize_entry(request.serializable_hash, response.serializable_hash)
+          entries = cache.read(key) || []
+          entries = entries.dup if entries.frozen?
+          entries.reject! do |(cached_request, cached_response)|
+            response_matches?(request, deserialize_object(cached_request), deserialize_object(cached_response))
+          end
+
+          entries << entry
+
+          cache.write(key, entries)
+        rescue ::Encoding::UndefinedConversionError => e
+          warn "Response could not be serialized: #{e.message}. Try using Marshal to serialize."
+          raise e
+        end
+
+        # Fetch a stored response that suits the incoming HTTP request or return nil.
+        #
+        # @param [Faraday::HttpCache::Request] request - an instance of the incoming HTTP request.
+        #
+        # @return [Faraday::HttpCache::Response, nil]
+        def read(request)
+          cache_key = cache_key_for(request.url)
+          entries = cache.read(cache_key)
+          response = lookup_response(request, entries)
+          return nil unless response
+
+          Faraday::HttpCache::Response.new(response)
+        end
+
+        # @param [String] url – the url of a changed resource, will be used to invalidate the cache.
+        #
+        # @return [void]
+        def delete(url)
+          cache_key = cache_key_for(url)
+          cache.delete(cache_key)
+        end
+
+        private
+
+        # Retrieve a response Hash from the list of entries that match the given request.
+        #
+        # @param [Faraday::HttpCache::Request] request - an instance of the incoming HTTP request.
+        # @param [Array<Array(Hash, Hash)>] entries - pairs of Hashes (request, response).
+        #
+        # @return [Hash, nil]
+        def lookup_response(request, entries)
+          if entries
+            entries = entries.map { |entry| deserialize_entry(*entry) }
+            _, response = entries.find { |req, res| response_matches?(request, req, res) }
+            response
+          end
+        end
+
+        # Check if a cached response and request matches the given request.
+        #
+        # @param [Faraday::HttpCache::Request] request - an instance of the incoming HTTP request.
+        # @param [Hash] cached_request - a Hash of the request that was cached.
+        # @param [Hash] cached_response - a Hash of the response that was cached.
+        #
+        # @return [true, false]
+        def response_matches?(request, cached_request, cached_response)
+          request.method.to_s == cached_request[:method].to_s &&
+            vary_matches?(cached_response, request, cached_request)
+        end
+
+        # Check if the cached request matches the incoming
+        # request based on the Vary header of cached response.
+        #
+        # If Vary header is not present, the request is considered to match.
+        # If Vary header is '*', the request is considered to not match.
+        #
+        # @param [Faraday::HttpCache::Request] request - an instance of the incoming HTTP request.
+        # @param [Hash] cached_request - a Hash of the request that was cached.
+        # @param [Hash] cached_response - a Hash of the response that was cached.
+        #
+        # @return [true, false]
+        def vary_matches?(cached_response, request, cached_request)
+          headers = Faraday::Utils::Headers.new(cached_response[:response_headers])
+          vary = headers['Vary'].to_s
+
+          vary.empty? || (vary != '*' && vary.split(/[\s,]+/).all? do |header|
+            request.headers[header] == cached_request[:headers][header]
+          end)
+        end
+
+        # Computes the cache key for a specific request, taking
+        # in account the current serializer to avoid cross serialization issues.
+        #
+        # @param [String] url - the request URL.
+        #
+        # @return [String]
+        def cache_key_for(url)
+          Digest::SHA1.hexdigest("#{@cache_salt}#{url}")
+        end
+      end
+    end
+  end
+end

data/lib/faraday/http_cache/strategies/by_vary.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'digest/sha1'
+
+require 'faraday/http_cache/strategies/base_strategy'
+
+module Faraday
+  class HttpCache < Faraday::Middleware
+    module Strategies
+      # This strategy uses headers from the Vary response header to generate cache keys.
+      # It also uses the index with Vary headers mapped to the request url.
+      # This strategy is more suitable for caching private responses with the same urls,
+      # like https://api.github.com/user.
+      #
+      # This strategy does not support #delete method to clear cache on unsafe methods.
+      class ByVary < BaseStrategy
+        # Store a response inside the cache.
+        #
+        # @param [Faraday::HttpCache::Request] request - instance of the executed HTTP request.
+        # @param [Faraday::HttpCache::Response] response - instance to be stored.
+        #
+        # @return [void]
+        def write(request, response)
+          vary_cache_key = vary_cache_key_for(request)
+          headers = Faraday::Utils::Headers.new(response.payload[:response_headers])
+          vary = headers['Vary'].to_s
+          cache.write(vary_cache_key, vary)
+
+          response_cache_key = response_cache_key_for(request, vary)
+          entry = serialize_object(response.serializable_hash)
+          cache.write(response_cache_key, entry)
+        rescue ::Encoding::UndefinedConversionError => e
+          warn "Response could not be serialized: #{e.message}. Try using Marshal to serialize."
+          raise e
+        end
+
+        # Fetch a stored response that suits the incoming HTTP request or return nil.
+        #
+        # @param [Faraday::HttpCache::Request] request - an instance of the incoming HTTP request.
+        #
+        # @return [Faraday::HttpCache::Response, nil]
+        def read(request)
+          vary_cache_key = vary_cache_key_for(request)
+          vary = cache.read(vary_cache_key)
+          return nil if vary.nil? || vary == '*'
+
+          cache_key = response_cache_key_for(request, vary)
+          response = cache.read(cache_key)
+          return nil if response.nil?
+
+          Faraday::HttpCache::Response.new(deserialize_object(response))
+        end
+
+        # This strategy does not support #delete method to clear cache on unsafe methods.
+        # @return [void]
+        def delete(_url)
+          # do nothing since we can't find the key by url
+        end
+
+        private
+
+        # Computes the cache key for the index with Vary headers.
+        #
+        # @param [Faraday::HttpCache::Request] request - instance of the executed HTTP request.
+        #
+        # @return [String]
+        def vary_cache_key_for(request)
+          method = request.method.to_s
+          Digest::SHA1.hexdigest("by_vary_index#{@cache_salt}#{method}#{request.url}")
+        end
+
+        # Computes the cache key for the response.
+        #
+        # @param [Faraday::HttpCache::Request] request - instance of the executed HTTP request.
+        # @param [String] vary - the Vary header value.
+        #
+        # @return [String]
+        def response_cache_key_for(request, vary)
+          method = request.method.to_s
+          headers = vary.split(/[\s,]+/).uniq.sort.map { |header| request.headers[header] }
+          Digest::SHA1.hexdigest("by_vary#{@cache_salt}#{method}#{request.url}#{headers.join}")
+        end
+      end
+    end
+  end
+end