api_cache 0.2.3 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 04d4fca20574868e21c48d50e07ae2d6cc78f493
+  data.tar.gz: a8b1f69f0a0fe9d9c5ee30a6fa5becffe3bcb4e7
+SHA512:
+  metadata.gz: 9df4d242de81e51b02398ca4781a18ae83460e3b059f14410d438334423928a533c7025fea819258d5a3fc1338b928ef3085092826cc6ea521b47d9645fc8189
+  data.tar.gz: 23e2d15510a671df5f6ca4d488890165785cce3df10ab67b12b4502d0f85bb456d17c9e706c717c3ae7db47226b4e9f4f726231c296c95ded2baab99a16b27d4

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## 0.3.0 – 2014-07-16
+
+* [NEW] Allow keys to be deleted [Doug Puchalski]
+* [UPDATED] Updated Moneta dependency - works with 0.7.x & 0.8.x
+* [FIX] Fixed long standing bug in the case that the `created_at` key was evicted before the data key (for example when using memcached)

data/README.md

@@ -16,8 +16,7 @@ APICache allows any API client library to be easily wrapped with a robust cachin
     
     # Use a proper store
     require 'moneta'
-    require 'moneta/memcache'
-    APICache.store = Moneta::Memcache.new(:server => "localhost")
+    APICache.store = Moneta.new(:Memcached)
     
     # Wrap an API, and handle the failure case
     
@@ -94,8 +93,7 @@ You can send any of the following options to `APICache.get(url, options = {}, &b
 
 Before using the APICache you should set the cache to use. By default an in memory hash is used - obviously not a great idea. Thankfully APICache can use any moneta store, so for example if you wanted to use memcache you'd do this:
 
-    require 'moneta/memcache'
-    APICache.store = Moneta::Memcache.new(:server => "localhost")
+    APICache.store = Moneta.new(:Memcached)
 
 Please be liberal with the github issue tracker, more so with pull requests, or drop me a mail to me [at] mloughran [dot] com. I'd love to hear from you.
 

data/Rakefile

@@ -1,10 +1,7 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |t|
-  t.libs << 'lib' << 'spec'
-  t.spec_files = FileList['spec/**/*_spec.rb']
-end
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
 
 task :default => :spec

data/api_cache.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "api_cache"
-  s.version     = "0.2.3"
+  s.version     = "0.3.0"
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Martyn Loughran"]
   s.email       = ["me@mloughran.com"]
@@ -16,10 +16,9 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency('rspec', "~> 1.0")
+  s.add_development_dependency('rspec', "~> 2.7")
   s.add_development_dependency('webmock')
   s.add_development_dependency('rake')
-  s.add_development_dependency('moneta', "~> 0.6.0")
+  s.add_development_dependency('moneta', "~> 0.7")
   s.add_development_dependency('dalli')
-  s.add_development_dependency('memcache-client')
 end

data/lib/api_cache.rb

@@ -128,6 +128,13 @@ class APICache
       end
     end
   end
+
+  # Manually delete data from the cache.
+  #
+  def self.delete(key)
+    APICache::Cache.new(key, {}).delete
+  end
+
 end
 
 require 'api_cache/cache'

data/lib/api_cache/abstract_store.rb

@@ -14,14 +14,30 @@ class APICache
       raise "Method not implemented. Called abstract class."
     end
 
+    # Delete the given key. The return value is not used.
+    def delete(key)
+      raise "Method not implemented. Called abstract class."
+    end
+
     # Does a given key exist in the cache?
     def exists?(key)
       raise "Method not implemented. Called abstract class."
     end
 
-    # Has a given time passed since the key was set?
-    def expired?(key, timeout)
+    # created_at returns the time when the key was last set
+    def created_at(key)
       raise "Method not implemented. Called abstract class."
     end
+
+    # expired? returns true if the given timeout has passed since the key was
+    # set. It has nothing to say about the existence or otherwise of said key.
+    def expired?(key, timeout)
+      if (created_at = created_at(key))
+        Time.now - created_at > timeout
+      else
+        # If the created_at data is missing assume expired
+        true
+      end
+    end
   end
 end

data/lib/api_cache/cache.rb

@@ -47,6 +47,11 @@ class APICache
       true
     end
 
+    def delete
+      store.delete(hash)
+      return nil
+    end
+
     private
 
     def hash

data/lib/api_cache/dalli_store.rb

@@ -16,14 +16,18 @@ class APICache
       @dalli.get(key)
     end
 
+    # Delete value.
+    def delete(key)
+      @dalli.delete(key)
+    end
+
     # Does a given key exist in the cache?
     def exists?(key)
       !get(key).nil?
     end
 
-    # Has a given time passed since the key was set?
-    def expired?(key, timeout)
-      Time.now - @dalli.get("#{key}_created_at") > timeout
+    def created_at(key)
+      @dalli.get("#{key}_created_at")
     end
   end
 end

data/lib/api_cache/memory_store.rb

@@ -1,8 +1,8 @@
 class APICache
   class MemoryStore < APICache::AbstractStore
-    def initialize
+    def initialize(cache = {})
       APICache.logger.debug "Using memory store"
-      @cache = {}
+      @cache = cache
       true
     end
 
@@ -13,23 +13,21 @@ class APICache
     end
 
     def get(key)
-      data = @cache[key][1]
+      data = exists?(key) ? @cache[key][1] : nil
       APICache.logger.debug("cache: #{data.nil? ? "miss" : "hit"} (#{key})")
       data
     end
 
-    def exists?(key)
-      !@cache[key].nil?
+    def delete(key)
+      @cache.delete(key)
     end
 
-    def expired?(key, timeout)
-      Time.now - created(key) > timeout
+    def exists?(key)
+      !@cache[key].nil?
     end
 
-    private
-
-    def created(key)
-      @cache[key][0]
+    def created_at(key)
+      @cache[key] && @cache[key][0]
     end
   end
 end

data/lib/api_cache/moneta_store.rb

@@ -16,14 +16,18 @@ class APICache
       @moneta[key]
     end
 
+    # Delete value.
+    def delete(key)
+      @moneta.delete(key)
+    end
+
     # Does a given key exist in the cache?
     def exists?(key)
       @moneta.key?(key)
     end
 
-    # Has a given time passed since the key was set?
-    def expired?(key, timeout)
-      Time.now - @moneta["#{key}_created_at"] > timeout
+    def created_at(key)
+      @moneta["#{key}_created_at"]
     end
   end
 end

data/lib/api_cache/null_store.rb

@@ -4,17 +4,24 @@ class APICache
   class NullStore < APICache::AbstractStore
     def initialize
     end
-    
-    def exists?(key)
-      false
-    end
 
     def set(key, value)
       true
     end
 
-    def expired?(key, timeout)
-      true
+    def get(key)
+      nil
+    end
+
+    def delete(key)
+    end
+
+    def exists?(key)
+      false
+    end
+
+    def created_at(key)
+      nil
     end
   end
 end

data/spec/api_cache_spec.rb

@@ -23,8 +23,7 @@ describe APICache do
 
     it "should allow moneta instances to be passed" do
       require 'moneta'
-      require 'moneta/memory'
-      APICache.store = Moneta::Memory.new
+      APICache.store = Moneta.new(:Memory)
       APICache.store.should be_kind_of(APICache::MonetaStore)
     end
 
@@ -40,62 +39,96 @@ describe APICache do
   end
 
   describe "get method" do
-    before :each do
-      @api = mock(APICache::API, :get => @api_data)
-      @cache = mock(APICache::Cache, :get => @cache_data, :set => true)
-      
-      APICache::API.stub!(:new).and_return(@api)
-      APICache::Cache.stub!(:new).and_return(@cache)
-    end
-    
-    it "should fetch data from the cache if the state is :current" do
-      @cache.stub!(:state).and_return(:current)
-      
-      APICache.get(@key).should == @cache_data
-    end
-    
-    it "should make new request to API if the state is :refetch and store result in cache" do
-      @cache.stub!(:state).and_return(:refetch)
-      @cache.should_receive(:set).with(@api_data)
-      
-      APICache.get(@key).should == @api_data
-    end
-    
-    it "should return the cached value if the state is :refetch but the api is not accessible" do
-      @cache.stub!(:state).and_return(:refetch)
-      @api.should_receive(:get).with.and_raise(APICache::CannotFetch)
-      
-      APICache.get(@key).should == @cache_data
-    end
-    
-    it "should make new request to API if the state is :invalid" do
-      @cache.stub!(:state).and_return(:invalid)
-      
-      APICache.get(@key).should == @api_data
-    end
-    
-    it "should raise CannotFetch if the api cannot fetch data and the cache state is :invalid" do
-      @cache.stub!(:state).and_return(:invalid)
-      @api.should_receive(:get).with.and_raise(APICache::CannotFetch)
-      
-      lambda {
-        APICache.get(@key).should
-      }.should raise_error(APICache::CannotFetch)
-    end
-    
-    it "should make new request to API if the state is :missing" do
-      @cache.stub!(:state).and_return(:missing)
-      
-      APICache.get(@key).should == @api_data
+
+    context "when cache is mocked" do
+      before :each do
+        @api = mock(APICache::API, :get => @api_data)
+        @cache = mock(APICache::Cache, :get => @cache_data, :set => true)
+
+        APICache::API.stub!(:new).and_return(@api)
+        APICache::Cache.stub!(:new).and_return(@cache)
+      end
+
+      it "should fetch data from the cache if the state is :current" do
+        @cache.stub!(:state).and_return(:current)
+
+        APICache.get(@key).should == @cache_data
+      end
+
+      it "should make new request to API if the state is :refetch and store result in cache" do
+        @cache.stub!(:state).and_return(:refetch)
+        @cache.should_receive(:set).with(@api_data)
+
+        APICache.get(@key).should == @api_data
+      end
+
+      it "should return the cached value if the state is :refetch but the api is not accessible" do
+        @cache.stub!(:state).and_return(:refetch)
+        @api.should_receive(:get).with.and_raise(APICache::CannotFetch)
+
+        APICache.get(@key).should == @cache_data
+      end
+
+      it "should make new request to API if the state is :invalid" do
+        @cache.stub!(:state).and_return(:invalid)
+
+        APICache.get(@key).should == @api_data
+      end
+
+      it "should raise CannotFetch if the api cannot fetch data and the cache state is :invalid" do
+        @cache.stub!(:state).and_return(:invalid)
+        @api.should_receive(:get).with.and_raise(APICache::CannotFetch)
+
+        lambda {
+          APICache.get(@key).should
+        }.should raise_error(APICache::CannotFetch)
+      end
+
+      it "should make new request to API if the state is :missing" do
+        @cache.stub!(:state).and_return(:missing)
+
+        APICache.get(@key).should == @api_data
+      end
+
+      it "should raise an exception if the api cannot fetch data and the cache state is :missing" do
+        @cache.stub!(:state).and_return(:missing)
+        @api.should_receive(:get).with.and_raise(APICache::CannotFetch)
+
+        lambda {
+          APICache.get(@key).should
+        }.should raise_error(APICache::CannotFetch)
+      end
     end
-    
-    it "should raise an exception if the api cannot fetch data and the cache state is :missing" do
-      @cache.stub!(:state).and_return(:missing)
-      @api.should_receive(:get).with.and_raise(APICache::CannotFetch)
-      
-      lambda {
-        APICache.get(@key).should
-      }.should raise_error(APICache::CannotFetch)
+
+
+    context "when cache is not mocked" do
+
+      before :each do
+        APICache.store = APICache::MemoryStore.new
+        @api = mock(APICache::API, :get => @api_data)
+        APICache::API.stub!(:new).and_return(@api)
+      end
+
+      #it "should initially fetch" do
+      #  @api.should_receive(:get)
+      #  APICache.get(@key)
+      #end
+
+      it "should only fetch once" do
+        @api.should_receive(:get).once
+        APICache.get(@key)
+        APICache.get(@key)
+      end
+
+      it "should refetch if deleted" do
+        @api.should_receive(:get).twice
+        APICache.get(@key)
+        APICache.delete(@key)
+        APICache.get(@key)
+      end
+
     end
+
   end
+
 end

data/spec/cache_spec.rb

@@ -33,4 +33,10 @@ describe APICache::Cache do
     sleep 1
     cache.state.should == :invalid
   end
+
+  it "should initially have invalid state" do
+    cache = APICache::Cache.new('foo', @options)
+    cache.state.should == :invalid
+  end
+
 end

data/spec/dalli_store_spec.rb

@@ -3,28 +3,8 @@ require 'spec_helper'
 require 'dalli'
 
 describe APICache::DalliStore do
-  before :each do
-    @dalli = Dalli::Client.new('localhost:11211')
-    @dalli.delete('foo')
-    @store = APICache::DalliStore.new(@dalli)
-  end
+  let(:cache) { Dalli::Client.new("localhost:11211") }
+  let(:store) { APICache::DalliStore.new(cache) }
 
-  it 'should set and get' do
-    @store.set('key', 'value')
-    @store.get('key').should == 'value'
-  end
-
-  it 'should allow checking whether a key exists' do
-    @store.exists?('foo').should be_false
-    @store.set('foo', 'bar')
-    @store.exists?('foo').should be_true
-  end
-
-  it 'should allow checking whether a given amount of time has passed since the key was set' do
-    @store.expired?('foo', 1).should be_false
-    @store.set('foo', 'bar')
-    @store.expired?('foo', 1).should be_false
-    sleep 1
-    @store.expired?('foo', 1).should be_true
-  end
+  include_examples "generic store"
 end

data/spec/memory_store_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe APICache::MemoryStore do
+  let(:cache) { {} }
+  let(:store) { APICache::MemoryStore.new(cache) }
+
+  # Deleting created_at makes no sense given the way MemoryStore stores data
+  @skip_created_at_deletion = true
+  include_examples "generic store"
+end

data/spec/monteta_store_spec.rb

@@ -1,31 +1,10 @@
 require 'spec_helper'
 
 require 'moneta'
-require 'moneta/memcache'
 
 describe APICache::MonetaStore do
-  before :each do
-    @moneta = Moneta::Memcache.new(:server => "localhost")
-    @moneta.delete('foo')
-    @store = APICache::MonetaStore.new(@moneta)
-  end
+  let(:cache) { Moneta.new(:Memcached) }
+  let(:store) { APICache::MonetaStore.new(cache) }
 
-  it "should set and get" do
-    @store.set("key", "value")
-    @store.get("key").should == "value"
-  end
-
-  it "should allow checking whether a key exists" do
-    @store.exists?('foo').should be_false
-    @store.set('foo', 'bar')
-    @store.exists?('foo').should be_true
-  end
-
-  it "should allow checking whether a given amount of time has passed since the key was set" do
-    @store.expired?('foo', 1).should be_false
-    @store.set('foo', 'bar')
-    @store.expired?('foo', 1).should be_false
-    sleep 1
-    @store.expired?('foo', 1).should be_true
-  end
+  include_examples "generic store"
 end

data/spec/null_store_spec.rb

@@ -11,7 +11,7 @@ describe APICache::NullStore do
     @store.exists?('foo').should be_false
   end
 
-  it "should allows say keys are expired" do
+  it "should always say keys are expired" do
     @store.expired?('foo', 1).should be_true
     @store.set('foo', 'bar')
     @store.expired?('foo', 1).should be_true

data/spec/shared_store_specs.rb

@@ -0,0 +1,42 @@
+shared_examples "generic store" do
+  before :each do
+    cache.delete("foo")
+  end
+
+  it "should allow set and get" do
+    store.set("foo", "bar")
+    store.get("foo").should == "bar"
+  end
+
+  it "should report existence" do
+    store.exists?("foo").should == false
+    store.set("foo", "bar")
+    store.exists?("foo").should == true
+  end
+
+  it "should allow checking expiration" do
+    store.set("foo", "bar")
+    store.expired?("foo", 1).should == false
+    store.expired?("foo", 0).should == true
+  end
+
+  it "should return nil if not found" do
+    store.get("nothing").should == nil
+  end
+
+  it "should be possible to delete" do
+    store.set("foo", "bar")
+    store.delete("key")
+    store.exists?("key").should == false
+    store.get("key").should == nil
+  end
+
+  unless @skip_created_at_deletion
+    it "should claim that key has expired if _created_at key is missing" do
+      store.set("key", "bar")
+      store.expired?("foo", 10).should == false
+      cache.delete("foo_created_at")
+      store.expired?("foo", 10).should == true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,9 @@
-require "spec"
+require "rspec"
 require 'webmock/rspec'
 
 $:.push File.join(File.dirname(__FILE__), '..', 'lib')
 require "api_cache"
 
 APICache.logger.level = Logger::FATAL
+
+require "shared_store_specs"

metadata

@@ -1,95 +1,97 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: api_cache
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.2.3
+version: !ruby/object:Gem::Version
+  version: 0.3.0
 platform: ruby
-authors: 
+authors:
 - Martyn Loughran
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-03-28 00:00:00 +01:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2014-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: "1.0"
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: webmock
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rake
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: moneta
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: 0.6.0
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: moneta
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
   type: :development
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: dalli
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: dalli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: memcache-client
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-  type: :development
-  version_requirements: *id006
-description: APICache allows any API client library to be easily wrapped with a robust caching layer. It supports caching (obviously), serving stale data and limits on the number of API calls. It's also got a handy syntax if all you want to do is cache a bothersome url.
-email: 
+      - !ruby/object:Gem::Version
+        version: '0'
+description: APICache allows any API client library to be easily wrapped with a robust
+  caching layer. It supports caching (obviously), serving stale data and limits on
+  the number of API calls. It's also got a handy syntax if all you want to do is cache
+  a bothersome url.
+email:
 - me@mloughran.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
+files:
+- ".gitignore"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -110,43 +112,42 @@ files:
 - spec/cache_spec.rb
 - spec/dalli_store_spec.rb
 - spec/integration_spec.rb
+- spec/memory_store_spec.rb
 - spec/monteta_store_spec.rb
 - spec/null_store_spec.rb
+- spec/shared_store_specs.rb
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: http://mloughran.github.com/api_cache/
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.5.3
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: API Cache allows advanced caching of APIs
-test_files: 
+test_files:
 - spec/api_cache_spec.rb
 - spec/api_spec.rb
 - spec/cache_spec.rb
 - spec/dalli_store_spec.rb
 - spec/integration_spec.rb
+- spec/memory_store_spec.rb
 - spec/monteta_store_spec.rb
 - spec/null_store_spec.rb
+- spec/shared_store_specs.rb
 - spec/spec_helper.rb