faraday-manual-cache 0.1.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a68b0911c029cdb80405cae43fee9559e976d7bb
-  data.tar.gz: 64f2279973047eb744398526cf3ce5a62f541c0f
+SHA256:
+  metadata.gz: 5687d1ea9b8a6e476067698ee92e5ad59249d6744589d97d2ccfd7f0ddc17447
+  data.tar.gz: 8a90c333880ef44bc400347f76e44121628c43fe4ec4a7d7b3adfa1d537c9391
 SHA512:
-  metadata.gz: 2b54c26beca7332c2bcd52bd5f2c0d504e43187ce3c6f52f8e48f508063155ca4f349f0a2dda20090789afdd6a4ec52ab106afa3076ab466bfd309c21d8776db
-  data.tar.gz: 0a9c7c49bddc69c01d6243f9e1c102bc221ad771a74f288bdf917023481e9daf64491fa154aa5c53dcb3af7655d34e90f6e742330d184b906ff9227ada5e782b
+  metadata.gz: bc1dbefa346aa1999e4491abfe42a575b9670d9861656f2728670a404f062056e5f76e5f70ff4e9969bed5452f51d8428a2dac7cef38ea600dd518de6cd6d7d8
+  data.tar.gz: cd7847c0c26d2a9eb0f3427901555bf0114db9c37fb10512c0fc7cb86b58a961551766efda5f5d09cb69c819d32feb355a27f9056965b0a7f87568e0b5fdcd04

data/.circleci/config.yml

@@ -0,0 +1,9 @@
+version: 2
+jobs:
+  build:
+    docker:
+      - image: circleci/ruby:2.4.1
+    steps:
+      - checkout
+      - run: bundle install
+      - run: bundle exec rspec --color --require spec_helper spec --format progress

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/README.md

@@ -18,9 +18,19 @@ Or install it yourself as:
 
     $ gem install faraday-manual-cache
 
+## Configuration
+
+Create a configuration file and select your memory store class. If you use Rails, just create an initializator.
+
+```ruby
+FaradayManualCache.configure do |config|
+  config.memory_store = ActiveSupport::Cache::MemoryStore.new
+end
+```
+
 ## Usage
 
-Super simple example that caches using the default store (`MemoryStore`) for the default expires_in (30 seconds): 
+Super simple example that caches using the default store (`MemoryStore`) for the default expires_in (30 seconds):
 
 ```ruby
 require 'faraday'
@@ -33,29 +43,29 @@ end
 ```
 The middleware currently takes several options:
 
+  * `conditions`: Conditional caching (default GET and HEAD requests).
+  * `cache_key`: Key for requests comparison (default URL)
   * `expires_in`: Cache expiry, in seconds (default 30).
-  * `store`: The `ActiveSupport::Cache`-compatible store to use (default `ActiveSupport::Cache::MemoryStore`).
-  * `store_options`: Options passed to the store if created by lookup (e.g. when specifying `:memory_store`, `:redis_store`, etc).
+  * `logger`: Specify a logger to enable logging.
 
 So a more complicated example would be:
 
 ```ruby
 require 'faraday'
 require 'faraday-manual-cache'
-require 'redis-rails'
 
 connection = Faraday.new(url: 'http://example.com') do |builder|
-  builder.use :manual_cache, expires_in: 10, store: :redis_store, store_options: { host: 'my-redis-server', port: '1234' }
+  builder.use :manual_cache,
+              conditions: ->(env) { env.method == :get },
+              cache_key: ->(env) { "prefix-#{env.url}" },
+              expires_in: 10,
+              logger: Rails.logger
   builder.adapter Faraday.default_adapter
 end
 ```
 
 As with `faraday-http-cache` it's recommended that `faraday-manual-cache` be fairly low in the middleware stack.
 
-## TODO
-
-  * Additional cache key options.
-
 ## Contributing
 
 1. Fork it ( http://github.com/dobs/faraday-manual-cache/fork )
@@ -70,4 +80,4 @@ Some implementation details taken from [`faraday-http-cache`](https://github.com
 
 ## Contributors
 
-  * Maintainer: [Daniel O'Brien](http://github.com/dobs)
+  * Maintainer: [Daniel O'Brien](http://github.com/dobs)

data/faraday-manual-cache.gemspec

@@ -1,7 +1,10 @@
 # coding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+require 'faraday-manual-cache/version'
+
 Gem::Specification.new do |spec|
   spec.name          = 'faraday-manual-cache'
-  spec.version       = '0.1.1'
+  spec.version       = FaradayManualCache::VERSION
   spec.authors       = ['Daniel O\'Brien']
   spec.email         = ['dan@dobs.org']
   spec.summary       = %q(A super simple Faraday cache implementation.)
@@ -21,4 +24,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '~> 1.5'
   spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
 end

data/lib/faraday-manual-cache/configuration.rb

@@ -0,0 +1,18 @@
+module FaradayManualCache
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  class Configuration
+    attr_accessor :memory_store
+
+    def initialize
+      @memory_store = ActiveSupport::Cache::MemoryStore.new
+    end
+  end
+end

data/lib/faraday-manual-cache/version.rb

@@ -0,0 +1,3 @@
+module FaradayManualCache
+  VERSION = '0.4.0'.freeze
+end

data/lib/faraday/manual_cache.rb

@@ -1,3 +1,4 @@
+require 'faraday-manual-cache/configuration'
 require 'faraday'
 
 module Faraday
@@ -8,26 +9,22 @@ module Faraday
   #
   # Currently accepts four arguments:
   #
+  #   :conditions    - Conditional caching based on a lambda (default: GET/HEAD
+  #                    requests)
   #   :expires_in    - Cache expiry, in seconds (default: 30).
   #   :logger        - A logger object to send cache hit/miss/write messages.
-  #   :store         - An object (or lookup symbol) for an
-  #                    ActiveSupport::Cache::Store instance. (default:
-  #                    MemoryStore).
-  #   :store_options - Options to pass to the store when generated based on a
-  #                    lookup symvol (default: {}).
+
   class ManualCache < Faraday::Middleware
+    DEFAULT_CONDITIONS = ->(env) { env.method == :get || env.method == :head }
+    DEFAULT_CACHE_KEY = ->(env) { env.url }
+
     def initialize(app, *args)
       super(app)
       options = args.first || {}
+      @conditions    = options.fetch(:conditions, DEFAULT_CONDITIONS)
       @expires_in    = options.fetch(:expires_in, 30)
       @logger        = options.fetch(:logger, nil)
-      @namespace     = options.fetch(:namespace, 'faraday-manual-cache')
-      @store         = options.fetch(:store, :memory_store)
-      @store_options = options.fetch(:store_options, {})
-
-      @store_options[:namespace] ||= @namespace
-
-      initialize_store
+      @cache_key     = options.fetch(:cache_key, DEFAULT_CACHE_KEY)
     end
 
     def call(env)
@@ -41,7 +38,7 @@ module Faraday
 
       if response_env
         response_env.response_headers['x-faraday-manual-cache'] = 'HIT'
-        to_response(cached_response(env)) 
+        to_response(response_env)
       else
         @app.call(env).on_complete do |response_env|
           response_env.response_headers['x-faraday-manual-cache'] = 'MISS'
@@ -54,20 +51,28 @@ module Faraday
       return unless cacheable?(env) && !env.request_headers['x-faraday-manual-cache']
 
       info "Cache WRITE: #{key(env)}"
-      @store.write(key(env), env, expires_in: @expires_in)
+      store.write(
+        key(env),
+        env,
+        expires_in: expires_in(env)
+      )
     end
 
     def cacheable?(env)
-      env.method == :get || env.method == :head
+      @conditions.call(env)
     end
 
     def cached_response(env)
-      response_env = @store.fetch(key(env)) if cacheable?(env) && !env.request_headers['x-faraday-manual-cache']
+      if cacheable?(env) && !env.request_headers['x-faraday-manual-cache']
+        response_env = store.fetch(key(env))
+      end
+
       if response_env
         info "Cache HIT: #{key(env)}"
       else
         info "Cache MISS: #{key(env)}"
       end
+
       response_env
     end
 
@@ -76,14 +81,15 @@ module Faraday
     end
 
     def key(env)
-      env.url
+      @cache_key.call(env)
     end
 
-    def initialize_store
-      return unless @store.is_a? Symbol
+    def expires_in(env)
+      @expires_in.respond_to?(:call) ? @expires_in.call(env) : @expires_in
+    end
 
-      require 'active_support/cache'
-      @store = ActiveSupport::Cache.lookup_store(@store, @store_options)
+    def store
+      @store ||= FaradayManualCache.configuration.memory_store
     end
 
     def to_response(env)

data/spec/manual_cache_spec.rb

@@ -0,0 +1,126 @@
+require 'faraday'
+require 'faraday-manual-cache'
+require 'active_support'
+
+class MockStore
+  def fetch(*args) end
+  def write(*args) end
+end
+
+RSpec.describe Faraday::ManualCache do
+  let(:stubs) do
+    Faraday::Adapter::Test::Stubs.new do |stub|
+      stub.get('/') { |_| [200, {}, ''] }
+      stub.head('/') { |_| [200, {}, ''] }
+      stub.post('/') { |_| [200, {}, ''] }
+      stub.put('/') { |_| [200, {}, ''] }
+    end
+  end
+  let(:store) { ActiveSupport::Cache::MemoryStore.new }
+  let(:configuration_double) { double(:configuration_double, memory_store: store) }
+
+  before do
+    allow(FaradayManualCache).to receive(:configuration).and_return(configuration_double)
+  end
+
+  context 'basic configuration' do
+    subject do
+      Faraday.new(url: 'http://www.example.com') do |faraday|
+        faraday.use :manual_cache
+        faraday.adapter :test, stubs
+      end
+    end
+
+    it 'should cache on GET' do
+      expect(store).to receive(:fetch)
+      expect(store).to receive(:write)
+      subject.get('/')
+    end
+
+    it 'should cache on HEAD' do
+      expect(store).to receive(:fetch)
+      expect(store).to receive(:write)
+      subject.head('/')
+    end
+
+    it 'should not cache on POST' do
+      expect(store).not_to receive(:fetch)
+      expect(store).not_to receive(:write)
+      subject.post('/')
+    end
+
+    it 'should not cache on PUT' do
+      expect(store).not_to receive(:fetch)
+      expect(store).not_to receive(:write)
+      subject.put('/')
+    end
+  end
+
+  context 'conditional configuration' do
+    subject do
+      Faraday.new(url: 'http://www.example.com') do |faraday|
+        faraday.use :manual_cache, conditions: ->(_) { true }
+        faraday.adapter :test, stubs
+      end
+    end
+
+    it 'should cache on GET' do
+      expect(store).to receive(:fetch)
+      expect(store).to receive(:write)
+      subject.get('/')
+    end
+
+    it 'should cache on HEAD' do
+      expect(store).to receive(:fetch)
+      expect(store).to receive(:write)
+      subject.head('/')
+    end
+
+    it 'should cache on POST' do
+      expect(store).to receive(:fetch)
+      expect(store).to receive(:write)
+      subject.post('/')
+    end
+
+    it 'should cache on PUT' do
+      expect(store).to receive(:fetch)
+      expect(store).to receive(:write)
+      subject.put('/')
+    end
+  end
+
+  context 'conditional configuration with cache key' do
+    subject do
+      Faraday.new(url: 'http://www.example.com') do |faraday|
+        faraday.use :manual_cache,
+                    conditions: ->(_) { true },
+                    cache_key: ->(env) { "prefix-#{env.url}" }
+        faraday.adapter :test, stubs
+      end
+    end
+
+    it 'should cache based of cache_key' do
+      expect(store).to receive(:fetch)
+      expect(store).to receive(:write).with('prefix-http://www.example.com/', any_args)
+      subject.get('/')
+    end
+  end
+
+  context 'dynamic configuration with expires in' do
+    subject do
+      Faraday.new(url: 'http://www.example.com') do |faraday|
+        faraday.use :manual_cache,
+                    conditions: ->(_) { true },
+                    cache_key: ->(env) { "prefix-#{env.url}" },
+                    expires_in: ->(env) { env.status * 2 }
+        faraday.adapter :test, stubs
+      end
+    end
+
+    it 'should cache with ttl based on lambda' do
+      expect(store).to receive(:fetch)
+      expect(store).to receive(:write).with('prefix-http://www.example.com/', any_args, expires_in: 400)
+      subject.get('/')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+  config.disable_monkey_patching!
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.order = :random
+  Kernel.srand config.seed
+end

metadata

@@ -1,69 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: faraday-manual-cache
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Daniel O'Brien
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-25 00:00:00.000000000 Z
+date: 2019-02-28 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.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: A super simple Faraday cache implementation.
@@ -73,15 +87,21 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rubocop.yml
+- ".circleci/config.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - faraday-manual-cache.gemspec
 - lib/faraday-manual-cache.rb
+- lib/faraday-manual-cache/configuration.rb
+- lib/faraday-manual-cache/version.rb
 - lib/faraday/manual_cache.rb
+- spec/manual_cache_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/dobs/faraday-manual-cache
 licenses:
 - MIT
@@ -92,18 +112,20 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '1.9'
 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.7.8
 signing_key: 
 specification_version: 4
 summary: A super simple Faraday cache implementation.
-test_files: []
+test_files:
+- spec/manual_cache_spec.rb
+- spec/spec_helper.rb