faraday-http-cache 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 80c7adcab041a8cfdcc1bfa6ac4a8ddd30661d9b
-  data.tar.gz: 688398ca6e4d77ac6769f66925c3108d5257ecdd
+  metadata.gz: f18d30f7f544974ede44d28d9bba250e746a9b2e
+  data.tar.gz: 29cfe8e36786c6a0a47d3d9f1b3cbdb2388f1a19
 SHA512:
-  metadata.gz: 789666e8549d1cb08978ae0870d97333e333541f0a774ec7bc10563dce42d3b4f9cf4ec425d16d03d13ae81d5420f5f5ecb8e71962525370b0aa9b39edae0f7b
-  data.tar.gz: 936fd149b8b358248bdb868fd347c7a53bc5115dae097a9ef6137680afc8d2584bf2f6066f328664132cc0191a9e199a813d31ee803ee1b5bdd8af02f9f8c514
+  metadata.gz: 14809735e62b3f547d9a8a9b8e35ce1be0f44a962650a2c196d4dece1c372829184766cc979ec1bf8cad3cfd4011dd086aebefd74e1f11847b684e277853bf8e
+  data.tar.gz: a1cdb3e8286c86b03f61dfb6516affbe2b743707b4b7c7d68a8c45e34df55bfd9dcd9e3c7e8290d8f965f3ee36af762a8be2fd751730a6842244a00534c05eac

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2012-2013 Plataformatec.
+Copyright 2012-2014 Plataformatec.
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.

data/README.md

@@ -15,26 +15,30 @@ gem 'faraday-http-cache'
 
 ## Usage and configuration
 
-You have to use the middleware in the Faraday instance that you want to. You can use the new
+You have to use the middleware in the Faraday instance that you want to,
+along with a suitable `store` to cache the responses. You can use the new
 shortcut using a symbol or passing the middleware class
 
 ```ruby
 client = Faraday.new do |builder|
-  builder.use :http_cache
+  builder.use :http_cache, store: Rails.cache
   # or
-  builder.use Faraday::HttpCache
+  builder.use Faraday::HttpCache, store: Rails.cache
 
   builder.adapter Faraday.default_adapter
 end
 ```
 
-The middleware uses the `ActiveSupport::Cache` API to record the responses from the targeted
-endpoints, and any extra configuration option will be used to setup the cache store.
+The middleware accepts a `store` option for the cache backend responsible for recording
+the API responses that should be stored. Stores should respond to `write` and `read`,
+just like an object from the `ActiveSupport::Cache` API.
 
 ```ruby
 # Connect the middleware to a Memcache instance.
+store = ActiveSupport::Cache.lookup_store(:mem_cache_store, ['localhost:11211'])
+
 client = Faraday.new do |builder|
-  builder.use :http_cache, store: :mem_cache_store, store_options: ['localhost:11211']
+  builder.use :http_cache, store: store
   builder.adapter Faraday.default_adapter
 end
 
@@ -44,16 +48,16 @@ client = Faraday.new do |builder|
   builder.adapter Faraday.default_adapter
 end
 ```
+The default store provided is a simple in memory cache that lives on the client
+instance, so it's important to configure a proper one for your production environment.
 
-The default store provided by ActiveSupport is the `MemoryStore` one, so it's important to
-configure a proper one for your production environment.
-
-MultiJson is used for serialization by default. If you expect to be dealing
-with images, you can use [Marshal][marshal] instead.
+the stdlib `JSON` module is used for serialization by default.
+If you expect to be dealing with images, you can use [Marshal][marshal] instead, or
+if you want to use another json library like `oj` or `yajl-ruby`.
 
 ```ruby
 client = Faraday.new do |builder|
-  builder.use :http_cache, serializer: Marshal
+  builder.use :http_cache, store: Rails.cache, serializer: Marshal
   builder.adapter Faraday.default_adapter
 end
 ```
@@ -65,7 +69,7 @@ operations:
 
 ```ruby
 client = Faraday.new do |builder|
-  builder.use :http_cache, logger: Rails.logger
+  builder.use :http_cache, store: Rails.cache, logger: Rails.logger
   builder.adapter Faraday.default_adapter
 end
 
@@ -91,10 +95,23 @@ The middleware will use the following headers to make caching decisions:
 
 The `max-age`, `must-revalidate`, `proxy-revalidate` and `s-maxage` directives are checked.
 
-Note: private caches are ignored.
+### Shared vs. non-shared caches
+
+By default, the middleware acts as a "shared cache" per RFC 2616. This means it does not cache
+responses with `Cache-Control: private`. This behavior can be changed by passing in the
+`:shared_cache` configuration option:
+
+```ruby
+client = Faraday.new do |builder|
+  builder.use :http_cache, shared_cache: false
+  builder.adapter Faraday.default_adapter
+end
+
+client.get('http://site/api/some-private-resource') # => will be cached
+```
 
 ## License
 
-Copyright (c) 2012-2013 Plataformatec. See LICENSE file.
+Copyright (c) 2012-2014 Plataformatec. See LICENSE file.
 
   [marshal]: http://www.ruby-doc.org/core-2.0/Marshal.html

data/lib/faraday/http_cache.rb

@@ -1,8 +1,4 @@
 require 'faraday'
-require 'multi_json'
-
-require 'active_support/core_ext/hash/slice'
-require 'active_support/deprecation'
 
 require 'faraday/http_cache/storage'
 require 'faraday/http_cache/response'
@@ -21,13 +17,13 @@ module Faraday
   #
   #   # Using the middleware with a simple client:
   #   client = Faraday.new do |builder|
-  #     builder.user :http_cache
+  #     builder.user :http_cache, store: my_store_backend
   #     builder.adapter Faraday.default_adapter
   #   end
   #
   #   # Attach a Logger to the middleware.
   #   client = Faraday.new do |builder|
-  #     builder.use :http_cache, logger: my_logger_instance
+  #     builder.use :http_cache, logger: my_logger_instance, store: my_store_backend
   #     builder.adapter Faraday.default_adapter
   #   end
   #
@@ -38,14 +34,21 @@ module Faraday
   #
   #   # Use Marshal for serialization
   #   client = Faraday.new do |builder|
-  #     builder.use :http_cache, serializer: Marshal
+  #     builder.use :http_cache, store: Rails.cache, serializer: Marshal
   #   end
   class HttpCache < Faraday::Middleware
+    # Internal: valid options for the 'initialize' configuration Hash.
+    VALID_OPTIONS = [:store, :serializer, :logger, :store_options, :shared_cache]
 
     # Public: Initializes a new HttpCache middleware.
     #
-    # app - the next endpoint on the 'Faraday' stack.
-    # arguments - aditional options to setup the logger and the storage.
+    # app  - the next endpoint on the 'Faraday' stack.
+    # args - aditional options to setup the logger and the storage.
+    #             :logger        - A logger object.
+    #             :serializer    - A serializer that should respond to 'dump' and 'load'.
+    #             :shared_cache  - A flag to mark the middleware as a shared cache or not.
+    #             :store         - A cache store that should respond to 'read' and 'write'.
+    #             :store_options - Deprecated: additional options to setup the cache store.
     #
     # Examples:
     #
@@ -56,20 +59,25 @@ module Faraday
     #   Faraday:HttpCache.new(app, logger: my_logger, serializer: Marshal)
     #
     #   # Initialize the middleware with a FileStore at the 'tmp' dir.
-    #   Faraday::HttpCache.new(app, store: :file_store, store_options: ['tmp'])
+    #   store = ActiveSupport::Cache.lookup_store(:file_store, ['tmp'])
+    #   Faraday::HttpCache.new(app, store: store)
     #
     #   # Initialize the middleware with a MemoryStore and logger
-    #   Faraday::HttpCache.new(app, store: :memory_store, logger: my_logger, store_options: [size: 1024])
+    #   store = ActiveSupport::Cache.lookup_store
+    #   Faraday::HttpCache.new(app, store: store, logger: my_logger)
     def initialize(app, *args)
       super(app)
       @logger = nil
+      @shared_cache = true
       if args.first.is_a? Hash
         options = args.first
         @logger = options[:logger]
+        @shared_cache = options.fetch(:shared_cache, true)
       else
         options = parse_deprecated_options(*args)
       end
 
+      assert_valid_options!(options)
       @storage = Storage.new(options)
     end
 
@@ -107,6 +115,12 @@ module Faraday
       end
     end
 
+    # Internal: Should this cache instance act like a "shared cache" according
+    # to the the definition in RFC 2616?
+    def shared_cache?
+      @shared_cache
+    end
+
     private
     # Internal: Receive the deprecated arguments to initialize the old API
     # and returns a Hash compatible with the new API
@@ -147,7 +161,7 @@ module Faraday
     def parse_deprecated_options(*args)
       options = {}
       if args.length > 0
-        ActiveSupport::Deprecation.warn('This api is deprecated, refer to the documentation for the new one', caller)
+        Kernel.warn('DEPRECATION WARNING: This API is deprecated, refer to the documentation for the new one', caller)
       end
 
       options[:store] = args.shift
@@ -156,7 +170,8 @@ module Faraday
         hash_params = args.first
         options[:serializer] = hash_params.delete(:serializer)
 
-        @logger = hash_params.delete(:logger)
+        @logger = hash_params[:logger]
+        @shared_cache = hash_params.fetch(:shared_cache, true)
       end
 
       options[:store_options] = args
@@ -243,7 +258,7 @@ module Faraday
     #
     # Returns nothing.
     def store(response)
-      if response.cacheable?
+      if shared_cache? ? response.cacheable_in_shared_cache? : response.cacheable_in_private_cache?
         trace :store
         @storage.write(@request, response)
       else
@@ -271,7 +286,13 @@ module Faraday
     # Returns a 'Hash' containing the ':status', ':body' and 'response_headers'
     # entries.
     def create_response(env)
-      env.to_hash.slice(:status, :body, :response_headers)
+      hash = env.to_hash
+
+      {
+        status: hash[:status],
+        body: hash[:body],
+        response_headers: hash[:response_headers]
+      }
     end
 
     # Internal: Creates a new 'Hash' containing the request information.
@@ -281,9 +302,13 @@ module Faraday
     # Returns a 'Hash' containing the ':method', ':url' and 'request_headers'
     # entries.
     def create_request(env)
-      request = env.to_hash.slice(:method, :url, :request_headers)
-      request[:request_headers] = request[:request_headers].dup
-      request
+      hash = env.to_hash
+
+      {
+        method: hash[:method],
+        url: hash[:url],
+        request_headers: hash[:request_headers].dup
+      }
     end
 
     # Internal: Logs the trace info about the incoming request
@@ -299,6 +324,21 @@ module Faraday
       line = "HTTP Cache: [#{method} #{path}] #{@trace.join(', ')}"
       @logger.debug(line)
     end
+
+    # Internal: Checks if the given 'options' Hash contains only
+    # valid keys. Please see the 'VALID_OPTIONS' constant for the
+    # acceptable keys.
+    #
+    # Raises an 'ArgumentError'.
+    #
+    # Returns nothing.
+    def assert_valid_options!(options)
+      options.each_key do |key|
+        unless VALID_OPTIONS.include?(key)
+          raise ArgumentError.new("Unknown option: #{key}. Valid options are :#{VALID_OPTIONS.join(', ')}")
+        end
+      end
+    end
   end
 end
 

data/lib/faraday/http_cache/response.rb

@@ -59,17 +59,29 @@ module Faraday
         @payload[:status] == 304
       end
 
-      # Internal: Checks if the response can be cached by the client.
-      # This is validated by the 'Cache-Control' directives, the response
-      # status code and it's freshness or validation status.
+      # Internal: Checks if the response can be cached by the client when the
+      # client is acting as a shared cache per RFC 2616. This is validated by
+      # the 'Cache-Control' directives, the response status code and it's
+      # freshness or validation status.
+      #
+      # Returns false if the 'Cache-Control' says that we can't store the
+      # response, or it can be stored in private caches only, or if isn't fresh
+      # or it can't be revalidated with the origin server. Otherwise, returns
+      # true.
+      def cacheable_in_shared_cache?
+        cacheable?(true)
+      end
+
+      # Internal: Checks if the response can be cached by the client when the
+      # client is acting as a private cache per RFC 2616. This is validated by
+      # the 'Cache-Control' directives, the response status code and it's
+      # freshness or validation status.
       #
       # Returns false if the 'Cache-Control' says that we can't store the
       # response, or if isn't fresh or it can't be revalidated with the origin
       # server. Otherwise, returns true.
-      def cacheable?
-        return false if cache_control.private? || cache_control.no_store?
-
-        cacheable_status_code? && (validateable? || fresh?)
+      def cacheable_in_private_cache?
+        cacheable?(false)
       end
 
       # Internal: Gets the response age in seconds.
@@ -124,7 +136,12 @@ module Faraday
       # Returns a 'Hash'.
       def serializable_hash
         prepare_to_cache
-        @payload.slice(:status, :body, :response_headers)
+
+        {
+          status: @payload[:status],
+          body: @payload[:body],
+          response_headers: @payload[:response_headers]
+        }
       end
 
       private
@@ -137,6 +154,15 @@ module Faraday
         headers.key?('Last-Modified') || headers.key?('ETag')
       end
 
+      # Internal: The logic behind cacheable_in_private_cache? and
+      # cacheable_in_shared_cache? The logic is the same except for the
+      # treatment of the private Cache-Control directive.
+      def cacheable?(shared_cache)
+        return false if (cache_control.private? && shared_cache) || cache_control.no_store?
+
+        cacheable_status_code? && (validateable? || fresh?)
+      end
+
       # Internal: Validates the response status against the
       # `CACHEABLE_STATUS_CODES' constant.
       #
@@ -177,12 +203,14 @@ module Faraday
         @payload[:response_headers]
       end
 
-      # Internal: Prepares the response headers ready to be cached.
+      # Internal: Prepares the response headers to be cached.
       #
-      # It removes the age header if present to allow cached responses
+      # It removes the 'Age' header if present to allow cached responses
       # to continue aging while cached. It also normalizes the 'max-age'
       # related headers if the 'Age' header is provided to ensure accuracy
       # once the 'Age' header is removed.
+      #
+      # Returns nothing.
       def prepare_to_cache
         if headers.key? 'Age'
           cache_control.normalize_max_ages(headers['Age'].to_i)

data/lib/faraday/http_cache/storage.rb

@@ -1,10 +1,9 @@
+require 'json'
 require 'digest/sha1'
-require 'active_support/cache'
-require 'active_support/core_ext/hash/keys'
 
 module Faraday
   class HttpCache < Faraday::Middleware
-    # Internal: A Wrapper around a ActiveSupport::CacheStore to store responses.
+    # Internal: A Wrapper around an ActiveSupport::CacheStore to store responses.
     #
     # Examples
     #   # Creates a new Storage using a MemCached backend from ActiveSupport.
@@ -16,20 +15,25 @@ module Faraday
     #   # Creates a new Storage using Marshal for serialization.
     #   Faraday::HttpCache::Storage.new(:memory_store, serializer: Marshal)
     class Storage
-      attr_reader :cache
-
       # Internal: Initialize a new Storage object with a cache backend.
       #
-      # options      - Storage options (default: {}).
-      #                :store         - An ActiveSupport::CacheStore identifier.
-      #                :serializer    - A serializer class for the body.
-      #                                 Should respond to #dump and #load.
-      #                :store_options - An array containg the options for
-      #                                 the cache store
+      # options - Storage options (default: {}).
+      #           :logger        - A Logger object to be used to emit warnings.
+      #           :store         - An cache store object that should
+      #                            respond to 'dump' and 'load'.
+      #           :serializer    - A serializer object that should
+      #                            respond to 'dump' and 'load'.
+      #           :store_options - An array containg the options for
+      #                            the cache store.
       def initialize(options = {})
-        store = options[:store]
-        @serializer = options[:serializer] || MultiJson
-        @cache = ActiveSupport::Cache.lookup_store(store, options[:store_options])
+        @cache = options[:store] || MemoryStore.new
+        @serializer = options[:serializer] || JSON
+        @logger = options[:logger]
+        if @cache.is_a? Symbol
+          @cache = lookup_store(@cache, options[:store_options])
+        end
+        assert_valid_store!
+        notify_memory_store_usage
       end
 
       # Internal: Writes a response with a key based on the given request.
@@ -42,7 +46,7 @@ module Faraday
       def write(request, response)
         key = cache_key_for(request)
         value = @serializer.dump(response.serializable_hash)
-        cache.write(key, value)
+        @cache.write(key, value)
       end
 
       # Internal: Reads a key based on the given request from the underlying cache.
@@ -53,11 +57,14 @@ module Faraday
       #           :request_headers - The custom headers for the request.
       # klass - The Class to be instantiated with the recovered informations.
       def read(request, klass = Faraday::HttpCache::Response)
-        key = cache_key_for(request)
-        value = cache.read(key)
+        cache_key = cache_key_for(request)
+        found = @cache.read(cache_key)
+
+        if found
+          payload = @serializer.load(found).each_with_object({}) do |(key,value), hash|
+            hash[key.to_sym] = value
+          end
 
-        if value
-          payload = @serializer.load(value).symbolize_keys
           klass.new(payload)
         end
       end
@@ -71,8 +78,72 @@ module Faraday
       #
       # Returns the encoded String.
       def cache_key_for(request)
-        array = request.stringify_keys.to_a.sort
-        Digest::SHA1.hexdigest(@serializer.dump(array))
+        cache_keys = request.each_with_object([]) do |(key, value), parts|
+          parts << [key.to_s, value]
+        end
+
+        Digest::SHA1.hexdigest(@serializer.dump(cache_keys.sort))
+      end
+
+      # Internal: Logs a warning when the 'cache' implementation
+      # isn't suitable for production use.
+      #
+      # Returns nothing.
+      def notify_memory_store_usage
+        return if @logger.nil?
+
+        kind = @cache.class.name.split('::').last.sub('Store', '').downcase
+        if kind == 'memory'
+          @logger.warn 'HTTP Cache: using a MemoryStore is not advised as the cache might not be persisted across multiple processes or connection instances.'
+        end
+      end
+
+      # Internal: Creates a cache store from 'ActiveSupport' with a set of options.
+      #
+      # store   - A 'Symbol' with the store name.
+      # options - Additional options for the cache store.
+      #
+      # Returns an 'ActiveSupport::Cache' store.
+      def lookup_store(store, options)
+        if @logger
+          @logger.warn "Passing a Symbol as the 'store' is deprecated, please pass the cache store instead."
+        end
+
+        begin
+          require 'active_support/cache'
+          ActiveSupport::Cache.lookup_store(store, options)
+        rescue LoadError => e
+          puts "You're missing the 'activesupport' gem. Add it to your Gemfile, bundle it and try again"
+          raise e
+        end
+      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)
+          raise ArgumentError.new("#{@cache.inspect} is not a valid cache store as it does not responds to 'read' and 'write'.")
+        end
+      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 write(key, value)
+        @cache[key] = value
       end
     end
   end

data/spec/json_spec.rb

@@ -12,6 +12,9 @@ describe Faraday::HttpCache do
   end
 
   it 'works fine with other middlewares' do
+    if Faraday::VERSION == '0.9.0'
+      pending 'faraday_middleware is not compatible with faraday 0.9'
+    end
     client.get('clear')
     expect(client.get('json').body['count']).to eq(1)
     expect(client.get('json').body['count']).to eq(1)

data/spec/middleware_spec.rb

@@ -1,11 +1,12 @@
 require 'spec_helper'
 
 describe Faraday::HttpCache do
-  let(:logger) { double('a Logger object', debug: nil) }
+  let(:logger) { double('a Logger object', debug: nil, warn: nil) }
+  let(:options) { { logger: logger } }
 
   let(:client) do
     Faraday.new(url: ENV['FARADAY_SERVER']) do |stack|
-      stack.use Faraday::HttpCache, logger: logger
+      stack.use Faraday::HttpCache, options
       adapter = ENV['FARADAY_ADAPTER']
       stack.headers['X-Faraday-Adapter'] = adapter
       stack.adapter adapter.to_sym
@@ -36,14 +37,32 @@ describe Faraday::HttpCache do
     client.get('broken')
   end
 
-  it 'does not cache requests with a private cache control' do
-    client.get('private')
-    expect(client.get('private').body).to eq('2')
+  describe 'when acting as a shared cache' do
+    let(:options) { { logger: logger, shared_cache: true } }
+
+    it 'does not cache requests with a private cache control' do
+      client.get('private')
+      expect(client.get('private').body).to eq('2')
+    end
+
+    it 'logs that a private response is invalid' do
+      expect(logger).to receive(:debug).with('HTTP Cache: [GET /private] miss, invalid')
+      client.get('private')
+    end
   end
 
-  it 'logs that a private response is invalid' do
-    expect(logger).to receive(:debug).with('HTTP Cache: [GET /private] miss, invalid')
-    client.get('private')
+  describe 'when acting as a private cache' do
+    let(:options) { { logger: logger, shared_cache: false } }
+
+    it 'does cache requests with a private cache control' do
+      client.get('private')
+      expect(client.get('private').body).to eq('1')
+    end
+
+    it 'logs that a private response is stored' do
+      expect(logger).to receive(:debug).with('HTTP Cache: [GET /private] miss, store')
+      client.get('private')
+    end
   end
 
   it 'does not cache requests with a explicit no-store directive' do
@@ -152,42 +171,67 @@ describe Faraday::HttpCache do
     expect(first_vary).not_to eql(second_vary)
   end
 
+  it 'raises an error when misconfigured' do
+    expect {
+      client = Faraday.new(url: ENV['FARADAY_SERVER']) do |stack|
+        stack.use Faraday::HttpCache, i_have_no_idea: true
+      end
+
+      client.get('get')
+    }.to raise_error(ArgumentError)
+  end
+
   describe 'Configuration options' do
     let(:app) { double('it is an app!') }
 
     it 'uses the options to create a Cache Store' do
-      expect(ActiveSupport::Cache).to receive(:lookup_store).with(:file_store, ['tmp'])
-      Faraday::HttpCache.new(app, store: :file_store, store_options: ['tmp'])
+      store = double(read: nil, write: nil)
+
+      expect(Faraday::HttpCache::Storage).to receive(:new).with(store: store)
+      Faraday::HttpCache.new(app, store: store)
     end
 
     it 'accepts a Hash option' do
-      expect(ActiveSupport::Cache).to receive(:lookup_store).with(:memory_store, [{ size: 1024 }])
+      expect(ActiveSupport::Cache).to receive(:lookup_store).with(:memory_store, [{ size: 1024 }]).and_call_original
       Faraday::HttpCache.new(app, store: :memory_store, store_options: [size: 1024])
     end
 
     it 'consumes the "logger" key' do
-      expect(ActiveSupport::Cache).to receive(:lookup_store).with(:memory_store, nil)
+      expect(ActiveSupport::Cache).to receive(:lookup_store).with(:memory_store, nil).and_call_original
       Faraday::HttpCache.new(app, store: :memory_store, logger: logger)
     end
 
+    describe '#shared_cache?' do
+      it 'is true by default' do
+        expect(Faraday::HttpCache.new(app).shared_cache?).to eq(true)
+      end
+
+      it 'is true when configured to true' do
+        expect(Faraday::HttpCache.new(app, shared_cache: true).shared_cache?).to eq(true)
+      end
+
+      it 'is false when configured to be false' do
+        expect(Faraday::HttpCache.new(app, shared_cache: false).shared_cache?).to eq(false)
+      end
+    end
+
     context 'with deprecated options format' do
+      before do
+        allow(Kernel).to receive(:warn)
+      end
+
       it 'uses the options to create a Cache Store' do
-        expect(ActiveSupport::Cache).to receive(:lookup_store).with(:file_store, ['tmp'])
+        expect(ActiveSupport::Cache).to receive(:lookup_store).with(:file_store, ['tmp']).and_call_original
         Faraday::HttpCache.new(app, :file_store, 'tmp')
       end
 
       it 'accepts a Hash option' do
-        expect(ActiveSupport::Cache).to receive(:lookup_store).with(:memory_store, [{ size: 1024 }])
+        expect(ActiveSupport::Cache).to receive(:lookup_store).with(:memory_store, [{ size: 1024 }]).and_call_original
         Faraday::HttpCache.new(app, :memory_store, size: 1024)
       end
 
-      it 'consumes the "logger" key' do
-        expect(ActiveSupport::Cache).to receive(:lookup_store).with(:memory_store, [{}])
-        Faraday::HttpCache.new(app, :memory_store, logger: logger)
-      end
-
       it 'warns the user about the deprecated options' do
-        expect(ActiveSupport::Deprecation).to receive(:warn)
+        expect(Kernel).to receive(:warn)
 
         Faraday::HttpCache.new(app, :memory_store, logger: logger)
       end

data/spec/response_spec.rb

@@ -1,25 +1,56 @@
 require 'spec_helper'
 
 describe Faraday::HttpCache::Response do
-  describe 'cacheable?' do
+  describe 'cacheable_in_shared_cache?' do
     it 'the response is not cacheable if the response is marked as private' do
-      headers  = { 'Cache-Control' => 'private' }
-      response = Faraday::HttpCache::Response.new(response_headers: headers)
+      headers  = { 'Cache-Control' => 'private, max-age=400' }
+      response = Faraday::HttpCache::Response.new(status: 200, response_headers: headers)
 
-      expect(response).not_to be_cacheable
+      expect(response).not_to be_cacheable_in_shared_cache
     end
 
     it 'the response is not cacheable if it should not be stored' do
-      headers  = { 'Cache-Control' => 'no-store' }
-      response = Faraday::HttpCache::Response.new(response_headers: headers)
+      headers  = { 'Cache-Control' => 'no-store, max-age=400' }
+      response = Faraday::HttpCache::Response.new(status: 200, response_headers: headers)
+
+      expect(response).not_to be_cacheable_in_shared_cache
+    end
+
+    it 'the response is not cacheable when the status code is not acceptable' do
+      headers  = { 'Cache-Control' => 'max-age=400' }
+      response = Faraday::HttpCache::Response.new(status: 503, response_headers: headers)
+      expect(response).not_to be_cacheable_in_shared_cache
+    end
+
+    [200, 203, 300, 301, 302, 404, 410].each do |status|
+      it "the response is cacheable if the status code is #{status} and the response is fresh" do
+        headers  = { 'Cache-Control' => 'max-age=400' }
+        response = Faraday::HttpCache::Response.new(status: status, response_headers: headers)
+
+        expect(response).to be_cacheable_in_shared_cache
+      end
+    end
+  end
+
+  describe 'cacheable_in_private_cache?' do
+    it 'the response is cacheable if the response is marked as private' do
+      headers  = { 'Cache-Control' => 'private, max-age=400' }
+      response = Faraday::HttpCache::Response.new(status: 200, response_headers: headers)
+
+      expect(response).to be_cacheable_in_private_cache
+    end
+
+    it 'the response is not cacheable if it should not be stored' do
+      headers  = { 'Cache-Control' => 'no-store, max-age=400' }
+      response = Faraday::HttpCache::Response.new(status: 200, response_headers: headers)
 
-      expect(response).not_to be_cacheable
+      expect(response).not_to be_cacheable_in_private_cache
     end
 
     it 'the response is not cacheable when the status code is not acceptable' do
       headers  = { 'Cache-Control' => 'max-age=400' }
       response = Faraday::HttpCache::Response.new(status: 503, response_headers: headers)
-      expect(response).not_to be_cacheable
+      expect(response).not_to be_cacheable_in_private_cache
     end
 
     [200, 203, 300, 301, 302, 404, 410].each do |status|
@@ -27,14 +58,14 @@ describe Faraday::HttpCache::Response do
         headers  = { 'Cache-Control' => 'max-age=400' }
         response = Faraday::HttpCache::Response.new(status: status, response_headers: headers)
 
-        expect(response).to be_cacheable
+        expect(response).to be_cacheable_in_private_cache
       end
     end
   end
 
   describe 'freshness' do
     it 'is fresh if the response still has some time to live' do
-      date = 200.seconds.ago.httpdate
+      date = (Time.now - 200).httpdate
       headers = { 'Cache-Control' => 'max-age=400', 'Date' => date }
       response = Faraday::HttpCache::Response.new(response_headers: headers)
 
@@ -42,7 +73,7 @@ describe Faraday::HttpCache::Response do
     end
 
     it 'is not fresh when the ttl has expired' do
-      date = 500.seconds.ago.httpdate
+      date = (Time.now - 500).httpdate
       headers = { 'Cache-Control' => 'max-age=400', 'Date' => date }
       response = Faraday::HttpCache::Response.new(response_headers: headers)
 
@@ -108,7 +139,7 @@ describe Faraday::HttpCache::Response do
     end
 
     it 'calculates the time from the "Date" header' do
-      date = 3.seconds.ago.httpdate
+      date = (Time.now - 3).httpdate
       response = Faraday::HttpCache::Response.new(response_headers: { 'Date' => date })
       expect(response.age).to eq(3)
     end
@@ -121,7 +152,7 @@ describe Faraday::HttpCache::Response do
 
   describe 'time to live calculation' do
     it 'returns the time to live based on the max age limit' do
-      date = 200.seconds.ago.httpdate
+      date = (Time.now - 200).httpdate
       headers = { 'Cache-Control' => 'max-age=400', 'Date' => date }
       response = Faraday::HttpCache::Response.new(response_headers: headers)
       expect(response.ttl).to eq(200)
@@ -160,9 +191,9 @@ describe Faraday::HttpCache::Response do
       headers = {
           'Age' => 6,
           'Cache-Control' => 'public, max-age=40',
-          'Date' => 38.seconds.ago.httpdate,
-          'Expires' => 37.seconds.from_now.httpdate,
-          'Last-Modified' => 300.seconds.ago.httpdate
+          'Date' => (Time.now - 38).httpdate,
+          'Expires' => (Time.now - 37).httpdate,
+          'Last-Modified' => (Time.now - 300).httpdate
       }
       response = Faraday::HttpCache::Response.new(response_headers: headers)
       expect(response).to be_fresh

data/spec/spec_helper.rb

@@ -3,9 +3,7 @@ require 'socket'
 
 require 'faraday-http-cache'
 require 'faraday_middleware'
-require 'active_support/core_ext/date/calculations'
-require 'active_support/core_ext/numeric/time'
-require 'json'
+require 'active_support/cache'
 
 require 'support/test_app'
 require 'support/test_server'
@@ -18,14 +16,10 @@ ENV['FARADAY_ADAPTER'] ||= 'net_http'
 server.start
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
-  config.filter_run :focus
   config.order = 'random'
 
   config.after(:suite) do
     server.stop
   end
 end
-
-ActiveSupport::Deprecation.silenced = true

data/spec/storage_spec.rb

@@ -13,9 +13,34 @@ describe Faraday::HttpCache::Storage do
   subject { storage }
 
   describe 'Cache configuration' do
-    it 'lookups a ActiveSupport cache store' do
-      expect(ActiveSupport::Cache).to receive(:lookup_store).with(:file_store, ['/tmp'])
-      Faraday::HttpCache::Storage.new({ store: :file_store, store_options: ['/tmp'] })
+    it 'uses a MemoryStore by default' do
+      expect(Faraday::HttpCache::MemoryStore).to receive(:new).and_call_original
+      Faraday::HttpCache::Storage.new
+    end
+
+    it 'emits a warning when using a MemoryStore' do
+      logger = double
+      expect(logger).to receive(:warn).with(/using a MemoryStore is not advised/)
+      Faraday::HttpCache::Storage.new(logger: logger)
+    end
+
+    it 'lookups an ActiveSupport cache store if a Symbol is given' do
+      expect(ActiveSupport::Cache).to receive(:lookup_store).with(:file_store, ['/tmp']).and_call_original
+      Faraday::HttpCache::Storage.new(store: :file_store, store_options: ['/tmp'])
+    end
+
+    it 'emits a warning when doing the lookup of an ActiveSupport cache store' do
+      logger = double
+      expect(logger).to receive(:warn).with(/Passing a Symbol as the 'store' is deprecated/)
+      Faraday::HttpCache::Storage.new(store: :file_store, logger: logger)
+    end
+
+    it 'raises an error when the given store is not valid' do
+      wrong = double
+
+      expect {
+        Faraday::HttpCache::Storage.new(store: wrong)
+      }.to raise_error(ArgumentError)
     end
   end
 
@@ -29,7 +54,7 @@ describe Faraday::HttpCache::Storage do
     end
 
     context 'with default serializer' do
-      let(:serialized) { MultiJson.dump(response.serializable_hash) }
+      let(:serialized) { JSON.dump(response.serializable_hash) }
       let(:cache_key)  { '503ac9f7180ca1cdec49e8eb73a9cc0b47c27325' }
       it_behaves_like 'serialization'
     end
@@ -63,9 +88,9 @@ describe Faraday::HttpCache::Storage do
       headers = {
           'Age' => 6,
           'Cache-Control' => 'public, max-age=40',
-          'Date' => 38.seconds.ago.httpdate,
-          'Expires' => 37.seconds.from_now.httpdate,
-          'Last-Modified' => 300.seconds.ago.httpdate
+          'Date' => (Time.now - 38).httpdate,
+          'Expires' => (Time.now - 37).httpdate,
+          'Last-Modified' => (Time.now - 300).httpdate
       }
       response = Faraday::HttpCache::Response.new(response_headers: headers)
       expect(response).to be_fresh
@@ -78,9 +103,10 @@ describe Faraday::HttpCache::Storage do
 
     it 'is fresh until cached and that 1 second elapses then the response is no longer fresh' do
       headers = {
-          'Date' => 39.seconds.ago.httpdate,
-          'Expires' => 40.seconds.from_now.httpdate,
+          'Date' => (Time.now - 39).httpdate,
+          'Expires' => (Time.now + 40).httpdate,
       }
+
       response = Faraday::HttpCache::Response.new(response_headers: headers)
       expect(response).to be_fresh
       subject.write(request, response)

data/spec/support/test_app.rb

@@ -1,4 +1,5 @@
 require 'sinatra/base'
+require 'json'
 
 class TestApp < Sinatra::Base
 
@@ -8,7 +9,7 @@ class TestApp < Sinatra::Base
 
   set :counter, 0
   set :requests, 0
-  set :yesterday, 1.day.ago.httpdate
+  set :yesterday, (Date.today - 1).httpdate
 
   get '/ping' do
     'PONG'
@@ -21,7 +22,7 @@ class TestApp < Sinatra::Base
   end
 
   get '/json' do
-    json = MultiJson.encode(count: increment_counter.to_i)
+    json = JSON.dump(count: increment_counter.to_i)
     [200, { 'Cache-Control' => 'max-age=400', 'Content-Type' => 'application/json' }, json]
   end
 
@@ -44,7 +45,7 @@ class TestApp < Sinatra::Base
   end
 
   get '/private' do
-    [200, { 'Cache-Control' => 'private' }, increment_counter]
+    [200, { 'Cache-Control' => 'private, max-age=100' }, increment_counter]
   end
 
   get '/dontstore' do

metadata

@@ -1,71 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: faraday-http-cache
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Lucas Mazza
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-09 00:00:00.000000000 Z
+date: 2014-01-30 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.8'
-- !ruby/object:Gem::Dependency
-  name: multi_json
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.3'
 description: Middleware to handle HTTP caching
 email:
-- contact@plataformatec.com.br
+- opensource@plataformatec.com.br
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
+- lib/faraday-http-cache.rb
+- lib/faraday/http_cache.rb
 - lib/faraday/http_cache/cache_control.rb
 - lib/faraday/http_cache/response.rb
 - lib/faraday/http_cache/storage.rb
-- lib/faraday/http_cache.rb
-- lib/faraday-http-cache.rb
 - spec/binary_spec.rb
 - spec/cache_control_spec.rb
 - spec/json_spec.rb
@@ -86,17 +58,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: A Faraday middleware that stores and validates cache expiration.