rack-cache 0.4 → 0.5

data/CHANGES

@@ -1,3 +1,27 @@
+## 0.5.0 / May 2009
+
+  * Added meta and entity store implementations based on the
+    memcache-client library. These are the default unless the memcached
+    library has already been required.
+
+  * The "allow_reload" and "allow_revalidate" options now default to
+    false instead of true. This means we break with RFC 2616 out of
+    the box but this is the expected configuration in a huge majority
+    of gateway cache scenarios. See the docs on configuration
+    options for more information on these options:
+    http://tomayko.com/src/rack-cache/configuration
+
+  * Added Google AppEngine memcache entity store and metastore
+    implementations. To use GAE's memcache with rack-cache, set the
+    "metastore" and "entitystore" options as follows:
+
+        use Rack::Cache,
+          :metastore   => 'gae://cache-meta',
+          :entitystore => 'gae://cache-body'
+
+    The 'cache-meta' and 'cache-body' parts are memcache namespace
+    prefixes and should be set to different values.
+
 ## 0.4.0 / March 2009
 
   * Ruby 1.9.1 / Rack 1.0 compatible.

data/TODO

@@ -1,31 +1,27 @@
-## Backlog
+## 0.5
 
-  - Move breakers.rb configuration file into rack-contrib as a middleware
-    component.
+  - Document allow_revalidate and allow_reload options.
+  - Support multiple memcache servers.
+  - Purge/invalidate everything
+  - Explicit expiration/invalidation based on response headers or via an
+    object interface passed in the rack env.
   - Sample apps: Rack, Rails, Sinatra, Merb, etc.
+  - Move old breakers.rb configuration file into rack-contrib as a
+    middleware component.
+
+## Backlog
+
   - Use Bacon instead of test/spec
-  - Work with both memcache and memcached gems (memcached hasn't built on MacOS
-    for some time now).
   - Fast path pass processing. We do a lot more than necessary just to determine
     that the response should be passed through untouched.
-  - Don't purge/remove cache entries when invalidating. The entries should be
-    marked as stale and be forced revalidated on the next request instead of
-    being removed entirely.
-  - Add missing Expires header if we have a max-age.
-  - Purge/invalidate everything
   - Invalidate at the URI of the Location or Content-Location response header
     on POST, PUT, or DELETE that results in a redirect.
   - Maximum size of cached entity
   - Last-Modified factor: requests that have a Last-Modified header but no Expires
     header have a TTL assigned based on the last modified age of the response:
     TTL = (Age * Factor), or, 1h  = (10h * 0.1)
-  - Run under multiple-threads with an option to lock before making requests
-    to the backend. The idea is to be able to serve requests from cache in
-    separate threads. This should probably be implemented as a separate
-    middleware component.
   - Consider implementing ESI (http://www.w3.org/TR/esi-lang). This should
     probably be implemented as a separate middleware component.
-  - Sqlite3 (meta store)
   - stale-while-revalidate
   - Serve cached copies when down (see: stale-if-error) - e.g., database
     connection drops and the cache takes over what it can. 

data/doc/configuration.markdown

@@ -16,8 +16,8 @@ __Environment__.
 When the __Rack::Cache__ object is instantiated:
 
     use Rack::Cache,
-      :verbose => true,
-      :metastore => 'memcached://localhost:11211/',
+      :verbose     => true,
+      :metastore   => 'memcached://localhost:11211/',
       :entitystore => 'file:/var/cache/rack'
 
 Using __Rack__'s __Environment__:
@@ -81,6 +81,32 @@ If any of these headers are present in the request, the response is considered
 private and will not be cached _unless_ the response is explicitly marked public
 (e.g., `Cache-Control: public`).
 
+### `allow_reload`
+
+A boolean specifying whether reload requests sent by the client should be
+honored by the cache. When this option is enabled (`rack-cache.allow_reload`
+is `true`), requests that include a `Cache-Control: no-cache` header cause
+the cache to discard anything it has stored for the request and ask that the
+response be fully generated.
+
+Most browsers include a `Cache-Control: no-cache` header when the user performs
+a "hard refresh" (e.g., holding `Shift` while clicking the "Refresh" button).
+
+*IMPORTANT: Enabling this option globally allows all clients to break your cache.*
+
+### `allow_revalidate`
+
+A boolean specifying whether revalidate requests sent by the client should be
+honored by the cache. When this option is enabled (`rack-cache.allow_revalidate`
+is `true`), requests that include a `Cache-Control: max-age=0` header cause the
+cache to assume its copy of the response is stale, resulting in a conditional
+GET / validation request to be sent to the server.
+
+Most browsers include a `Cache-Control: max-age=0` header when the user performs
+a refresh (e.g., clicking the "Refresh" button).
+
+*IMPORTANT: Enabling this option globally allows all clients to break your cache.*
+
 ### `cache_key`
 
 TODO: Document custom cache keys

data/doc/index.markdown

@@ -12,6 +12,9 @@ for [Rack][]-based applications that produce freshness (`Expires`,
 News
 ----
 
+  * Rack::Cache 0.5 was released on May 25, 2009. See the
+    [`CHANGES`](http://github.com/rtomayko/rack-cache/blob/0.5.0/CHANGES) file
+    for details.
   * [How to use Rack::Cache with Rails 2.3](http://snippets.aktagon.com/snippets/302-How-to-setup-and-use-Rack-Cache-with-Rails-2-3-0-RC-1) - it's really easy.
   * [RailsLab's Advanced HTTP Caching Screencast](http://railslab.newrelic.com/2009/02/26/episode-11-advanced-http-caching)
     is a really great review of HTTP caching concepts and shows how to

data/lib/rack/cache/appengine.rb

@@ -0,0 +1,52 @@
+require 'base64'
+
+module Rack::Cache::AppEngine
+
+  module MC
+    require 'java'
+
+    import com.google.appengine.api.memcache.Expiration;
+    import com.google.appengine.api.memcache.MemcacheService;
+    import com.google.appengine.api.memcache.MemcacheServiceFactory;
+    import com.google.appengine.api.memcache.Stats;
+
+    Service = MemcacheServiceFactory.getMemcacheService
+  end unless defined?(Rack::Cache::AppEngine::MC)
+
+  class MemCache
+
+      def initialize(options = {})
+        @cache = MC::Service
+        @cache.namespace = options[:namespace] if options[:namespace]
+      end
+
+      def contains?(key)
+        MC::Service.contains(key)
+      end
+
+      def get(key)
+        value = MC::Service.get(key)
+        Marshal.load(Base64.decode64(value)) if value
+      end
+
+      def put(key, value, ttl = nil)
+        expiration = ttl ? MC::Expiration.byDeltaSeconds(ttl) : nil
+        value = Base64.encode64(Marshal.dump(value)).gsub(/\n/, '')
+        MC::Service.put(key, value, expiration)
+      end
+
+      def namespace
+        MC::Service.getNamespace
+      end
+
+      def namespace=(value)
+        MC::Service.setNamespace(value.to_s)
+      end
+
+      def delete(key)
+        MC::Service.delete(key)
+      end
+
+  end
+
+end

data/lib/rack/cache/entitystore.rb

@@ -19,7 +19,7 @@ module Rack::Cache
         yield part
       end
       body.close if body.respond_to? :close
-      [ digest.hexdigest, size ]
+      [digest.hexdigest, size]
     end
 
     if ''.respond_to?(:bytesize)
@@ -168,35 +168,136 @@ module Rack::Cache
     DISK = Disk
     FILE = Disk
 
-    # Stores entity bodies in memcached.
-    class MemCache < EntityStore
-
+    # Base class for memcached entity stores.
+    class MemCacheBase < EntityStore
       # The underlying Memcached instance used to communicate with the
-      # memcahced daemon.
+      # memcached daemon.
       attr_reader :cache
 
+      extend Rack::Utils
+
+      def open(key)
+        data = read(key)
+        data && [data]
+      end
+
+      def self.resolve(uri)
+        server = "#{uri.host}:#{uri.port || '11211'}"
+        options = parse_query(uri.query)
+        options.keys.each do |key|
+          value =
+            case value = options.delete(key)
+            when 'true' ; true
+            when 'false' ; false
+            else value.to_sym
+            end
+          options[k.to_sym] = value
+        end
+        options[:namespace] = uri.path.sub(/^\//, '')
+        new server, options
+      end
+    end
+
+    # Uses the memcache-client ruby library. This is the default unless
+    # the memcached library has already been required.
+    class MemCache < MemCacheBase
+      def initialize(server="localhost:11211", options={})
+        @cache =
+          if server.respond_to?(:stats)
+            server
+          else
+            require 'memcache'
+            ::MemCache.new(server, options)
+          end
+      end
+
+      def exist?(key)
+        !cache.get(key).nil?
+      end
+
+      def read(key)
+        cache.get(key)
+      end
+
+      def write(body)
+        buf = StringIO.new
+        key, size = slurp(body){|part| buf.write(part) }
+        [key, size] if cache.set(key, buf.string)
+      end
+
+      def purge(key)
+        cache.delete(key)
+        nil
+      end
+    end
+
+    # Uses the memcached client library. The ruby based memcache-client is used
+    # in preference to this store unless the memcached library has already been
+    # required.
+    class MemCached < MemCacheBase
       def initialize(server="localhost:11211", options={})
+        options[:prefix_key] ||= options.delete(:namespace) if options.key?(:namespace)
         @cache =
           if server.respond_to?(:stats)
             server
           else
             require 'memcached'
-            Memcached.new(server, options)
+            ::Memcached.new(server, options)
           end
       end
 
       def exist?(key)
         cache.append(key, '')
         true
-      rescue Memcached::NotStored
+      rescue ::Memcached::NotStored
         false
       end
 
       def read(key)
         cache.get(key, false)
-      rescue Memcached::NotFound
+      rescue ::Memcached::NotFound
+        nil
+      end
+
+      def write(body)
+        buf = StringIO.new
+        key, size = slurp(body){|part| buf.write(part) }
+        cache.set(key, buf.string, 0, false)
+        [key, size]
+      end
+
+      def purge(key)
+        cache.delete(key)
+        nil
+      rescue ::Memcached::NotFound
         nil
       end
+    end
+
+    MEMCACHE =
+      if defined?(::Memcached)
+        MemCached
+      else
+        MemCache
+      end
+
+    MEMCACHED = MEMCACHE
+
+    class GAEStore < EntityStore
+      attr_reader :cache
+
+      def initialize(options = {})
+        require 'rack/cache/appengine'
+        @cache = Rack::Cache::AppEngine::MemCache.new(options)
+      end
+
+      def exist?(key)
+        cache.contains?(key)
+      end
+
+      def read(key)
+        cache.get(key)
+      end
 
       def open(key)
         if data = read(key)
@@ -209,45 +310,24 @@ module Rack::Cache
       def write(body)
         buf = StringIO.new
         key, size = slurp(body){|part| buf.write(part) }
-        cache.set(key, buf.string, 0, false)
+        cache.put(key, buf.string)
         [key, size]
       end
 
       def purge(key)
         cache.delete(key)
         nil
-      rescue Memcached::NotFound
-        nil
       end
 
-      extend Rack::Utils
-
-      # Create MemCache store for the given URI. The URI must specify
-      # a host and may specify a port, namespace, and options:
-      #
-      # memcached://example.com:11211/namespace?opt1=val1&opt2=val2
-      #
-      # Query parameter names and values are documented with the memcached
-      # library: http://tinyurl.com/4upqnd
       def self.resolve(uri)
-        server = "#{uri.host}:#{uri.port || '11211'}"
-        options = parse_query(uri.query)
-        options.keys.each do |key|
-          value =
-            case value = options.delete(key)
-            when 'true' ; true
-            when 'false' ; false
-            else value.to_sym
-            end
-          options[k.to_sym] = value
-        end
-        options[:namespace] = uri.path.sub(/^\//, '')
-        new server, options
+        self.new(:namespace => uri.host)
       end
+
     end
 
-    MEMCACHE = MemCache
-    MEMCACHED = MemCache
+    GAECACHE = GAEStore
+    GAE = GAEStore
+
   end
 
 end

data/lib/rack/cache/metastore.rb

@@ -259,8 +259,65 @@ module Rack::Cache
     # Stores request/response pairs in memcached. Keys are not stored
     # directly since memcached has a 250-byte limit on key names. Instead,
     # the SHA1 hexdigest of the key is used.
-    class MemCache < MetaStore
+    class MemCacheBase < MetaStore
+      extend Rack::Utils
+
+      # The MemCache object used to communicated with the memcached
+      # daemon.
+      attr_reader :cache
+
+      # Create MemCache store for the given URI. The URI must specify
+      # a host and may specify a port, namespace, and options:
+      #
+      # memcached://example.com:11211/namespace?opt1=val1&opt2=val2
+      #
+      # Query parameter names and values are documented with the memcached
+      # library: http://tinyurl.com/4upqnd
+      def self.resolve(uri)
+        server = "#{uri.host}:#{uri.port || '11211'}"
+        options = parse_query(uri.query)
+        options.keys.each do |key|
+          value =
+            case value = options.delete(key)
+            when 'true' ; true
+            when 'false' ; false
+            else value.to_sym
+            end
+          options[k.to_sym] = value
+        end
+        options[:namespace] = uri.path.sub(/^\//, '')
+        new server, options
+      end
+    end
+
+    class MemCache < MemCacheBase
+      def initialize(server="localhost:11211", options={})
+        @cache =
+          if server.respond_to?(:stats)
+            server
+          else
+            require 'memcache'
+            ::MemCache.new(server, options)
+          end
+      end
+
+      def read(key)
+        key = hexdigest(key)
+        cache.get(key) || []
+      end
+
+      def write(key, entries)
+        key = hexdigest(key)
+        cache.set(key, entries)
+      end
+
+      def purge(key)
+        cache.delete(hexdigest(key))
+        nil
+      end
+    end
 
+    class MemCached < MemCacheBase
       # The Memcached instance used to communicated with the memcached
       # daemon.
       attr_reader :cache
@@ -294,35 +351,49 @@ module Rack::Cache
       rescue Memcached::NotFound
         nil
       end
+    end
 
-      extend Rack::Utils
+    MEMCACHE =
+      if defined?(::Memcached)
+        MemCached
+      else
+        MemCache
+      end
+    MEMCACHED = MemCache
+
+    class GAEStore < MetaStore
+      attr_reader :cache
+
+      def initialize(options = {})
+        require 'rack/cache/appengine'
+        @cache = Rack::Cache::AppEngine::MemCache.new(options)
+      end
+
+      def read(key)
+        key = hexdigest(key)
+        cache.get(key) || []
+      end
+
+      def write(key, entries)
+        key = hexdigest(key)
+        cache.put(key, entries)
+      end
+
+      def purge(key)
+        key = hexdigest(key)
+        cache.delete(key)
+        nil
+      end
 
-      # Create MemCache store for the given URI. The URI must specify
-      # a host and may specify a port, namespace, and options:
-      #
-      # memcached://example.com:11211/namespace?opt1=val1&opt2=val2
-      #
-      # Query parameter names and values are documented with the memcached
-      # library: http://tinyurl.com/4upqnd
       def self.resolve(uri)
-        server = "#{uri.host}:#{uri.port || '11211'}"
-        options = parse_query(uri.query)
-        options.keys.each do |key|
-          value =
-            case value = options.delete(key)
-            when 'true' ; true
-            when 'false' ; false
-            else value.to_sym
-            end
-          options[k.to_sym] = value
-        end
-        options[:namespace] = uri.path.sub(/^\//, '')
-        new server, options
+        self.new(:namespace => uri.host)
       end
+
     end
 
-    MEMCACHE = MemCache
-    MEMCACHED = MemCache
+    GAECACHE = GAEStore
+    GAE = GAEStore
+
   end
 
 end

data/lib/rack/cache/options.rb

@@ -133,8 +133,8 @@ module Rack::Cache
         'rack-cache.entitystore'      => 'heap:/',
         'rack-cache.default_ttl'      => 0,
         'rack-cache.private_headers'  => ['Authorization', 'Cookie'],
-        'rack-cache.allow_reload'     => true,
-        'rack-cache.allow_revalidate' => true
+        'rack-cache.allow_reload'     => false,
+        'rack-cache.allow_revalidate' => false
       }
       self.options = options
     end

data/rack-cache.gemspec

@@ -3,8 +3,8 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
 
   s.name = 'rack-cache'
-  s.version = '0.4'
-  s.date = '2009-03-16'
+  s.version = '0.5'
+  s.date = '2009-05-25'
 
   s.description = "HTTP Caching for Rack"
   s.summary     = "HTTP Caching for Rack"
@@ -30,6 +30,7 @@ Gem::Specification.new do |s|
     example/sinatra/app.rb
     example/sinatra/views/index.erb
     lib/rack/cache.rb
+    lib/rack/cache/appengine.rb
     lib/rack/cache/cachecontrol.rb
     lib/rack/cache/context.rb
     lib/rack/cache/entitystore.rb
@@ -58,7 +59,7 @@ Gem::Specification.new do |s|
   s.test_files = s.files.select {|path| path =~ /^test\/.*_test.rb/}
 
   s.extra_rdoc_files = %w[README COPYING TODO CHANGES]
-  s.add_dependency 'rack', '~> 0.4'
+  s.add_dependency 'rack', '>= 0.4'
 
   s.has_rdoc = true
   s.homepage = "http://tomayko.com/src/rack-cache/"

data/test/context_test.rb

@@ -124,7 +124,8 @@ describe 'Rack::Cache::Context' do
     response.headers.should.include 'Age'
   end
 
-  it 'reloads responses when cache hits but no-cache request directive present' do
+  it 'reloads responses when cache hits but no-cache request directive present ' +
+     'when allow_reload is set true' do
     count = 0
     respond_with 200, 'Cache-Control' => 'max-age=10000' do |req,res|
       count+= 1
@@ -141,14 +142,16 @@ describe 'Rack::Cache::Context' do
     response.body.should.equal 'Hello World'
     cache.trace.should.include :fresh
 
-    get '/', 'HTTP_CACHE_CONTROL' => 'no-cache'
+    get '/',
+      'rack-cache.allow_reload' => true,
+      'HTTP_CACHE_CONTROL' => 'no-cache'
     response.should.be.ok
     response.body.should.equal 'Goodbye World'
     cache.trace.should.include :reload
     cache.trace.should.include :store
   end
 
-  it 'does not reload responses when allow_reload is set false' do
+  it 'does not reload responses when allow_reload is set false (default)' do
     count = 0
     respond_with 200, 'Cache-Control' => 'max-age=10000' do |req,res|
       count+= 1
@@ -171,9 +174,17 @@ describe 'Rack::Cache::Context' do
     response.should.be.ok
     response.body.should.equal 'Hello World'
     cache.trace.should.not.include :reload
+
+    # test again without explicitly setting the allow_reload option to false
+    get '/',
+      'HTTP_CACHE_CONTROL' => 'no-cache'
+    response.should.be.ok
+    response.body.should.equal 'Hello World'
+    cache.trace.should.not.include :reload
   end
 
-  it 'revalidates fresh cache entry when max-age request directive is exceeded' do
+  it 'revalidates fresh cache entry when max-age request directive is exceeded ' +
+     'when allow_revalidate option is set true' do
     count = 0
     respond_with do |req,res|
       count+= 1
@@ -192,7 +203,9 @@ describe 'Rack::Cache::Context' do
     response.body.should.equal 'Hello World'
     cache.trace.should.include :fresh
 
-    get '/', 'HTTP_CACHE_CONTROL' => 'max-age=0'
+    get '/',
+      'rack-cache.allow_revalidate' => true,
+      'HTTP_CACHE_CONTROL' => 'max-age=0'
     response.should.be.ok
     response.body.should.equal 'Goodbye World'
     cache.trace.should.include :stale
@@ -200,7 +213,7 @@ describe 'Rack::Cache::Context' do
     cache.trace.should.include :store
   end
 
-  it 'does not revalidate fresh cache entry when enable_revalidate option is set false' do
+  it 'does not revalidate fresh cache entry when enable_revalidate option is set false (default)' do
     count = 0
     respond_with do |req,res|
       count+= 1
@@ -227,6 +240,15 @@ describe 'Rack::Cache::Context' do
     cache.trace.should.not.include :stale
     cache.trace.should.not.include :invalid
     cache.trace.should.include :fresh
+
+    # test again without explicitly setting the allow_revalidate option to false
+    get '/',
+      'HTTP_CACHE_CONTROL' => 'max-age=0'
+    response.should.be.ok
+    response.body.should.equal 'Hello World'
+    cache.trace.should.not.include :stale
+    cache.trace.should.not.include :invalid
+    cache.trace.should.include :fresh
   end
   it 'fetches response from backend when cache misses' do
     respond_with 200, 'Expires' => (Time.now + 5).httpdate

data/test/entitystore_test.rb

@@ -176,10 +176,51 @@ describe 'Rack::Cache::EntityStore' do
   end
 
   need_memcached 'entity store tests' do
+    describe 'MemCached' do
+      it_should_behave_like 'A Rack::Cache::EntityStore Implementation'
+      before do
+        @store = Rack::Cache::EntityStore::MemCached.new($memcached)
+      end
+      after do
+        @store = nil
+      end
+    end
+  end
+
+
+  need_memcache 'entity store tests' do
     describe 'MemCache' do
       it_should_behave_like 'A Rack::Cache::EntityStore Implementation'
       before do
-        @store = Rack::Cache::EntityStore::MemCache.new($memcached)
+        $memcache.flush_all
+        @store = Rack::Cache::EntityStore::MemCache.new($memcache)
+      end
+      after do
+        @store = nil
+      end
+    end
+  end
+  
+  need_java 'entity store testing' do
+    module Rack::Cache::AppEngine
+      module MC
+        class << (Service = {})
+ 
+          def contains(key); include?(key); end
+          def get(key); self[key]; end;
+          def put(key, value, ttl = nil)
+            self[key] = value
+          end  
+        end
+        
+      end
+    end
+    
+    describe 'GAEStore' do
+      it_should_behave_like 'A Rack::Cache::EntityStore Implementation'
+      before do
+        puts Rack::Cache::AppEngine::MC::Service.inspect
+        @store = Rack::Cache::EntityStore::GAEStore.new
       end
       after do
         @store = nil

data/test/metastore_test.rb

@@ -250,14 +250,53 @@ describe 'Rack::Cache::MetaStore' do
   end
 
   need_memcached 'metastore tests' do
-    describe 'MemCache' do
+    describe 'MemCached' do
       it_should_behave_like 'A Rack::Cache::MetaStore Implementation'
       before :each do
         @temp_dir = create_temp_directory
         $memcached.flush
-        @store = Rack::Cache::MetaStore::MemCache.new($memcached)
+        @store = Rack::Cache::MetaStore::MemCached.new($memcached)
         @entity_store = Rack::Cache::EntityStore::Heap.new
       end
     end
   end
+
+  need_memcache 'metastore tests' do
+    describe 'MemCache' do
+      it_should_behave_like 'A Rack::Cache::MetaStore Implementation'
+      before :each do
+        @temp_dir = create_temp_directory
+        $memcache.flush_all
+        @store = Rack::Cache::MetaStore::MemCache.new($memcache)
+        @entity_store = Rack::Cache::EntityStore::Heap.new
+      end
+    end
+  end
+  
+  need_java 'entity store testing' do
+    module Rack::Cache::AppEngine
+      module MC
+        class << (Service = {})
+
+          def contains(key); include?(key); end
+          def get(key); self[key]; end;
+          def put(key, value, ttl = nil)
+            self[key] = value
+          end  
+
+        end
+      end
+    end
+  
+    describe 'GAEStore' do
+      it_should_behave_like 'A Rack::Cache::MetaStore Implementation'
+      before :each do
+        Rack::Cache::AppEngine::MC::Service.clear
+        @store = Rack::Cache::MetaStore::GAEStore.new
+        @entity_store = Rack::Cache::EntityStore::Heap.new
+      end
+    end
+  
+  end
+
 end

data/test/spec_setup.rb

@@ -15,6 +15,7 @@ end
 # of the MemCached meta and entity stores.
 ENV['MEMCACHED'] ||= 'localhost:11215'
 $memcached = nil
+$memcache = nil
 
 def have_memcached?(server=ENV['MEMCACHED'])
   return $memcached unless $memcached.nil?
@@ -35,14 +36,49 @@ end
 
 have_memcached?
 
+def have_memcache?(server=ENV['MEMCACHED'])
+  return $memcache unless $memcache.nil?
+  require 'memcache'
+  $memcache = MemCache.new(server)
+  $memcache.set('ping', '')
+  true
+rescue LoadError => boom
+  $memcache = false
+  false
+rescue => boom
+  STDERR.puts "memcache not working. related tests will be skipped."
+  $memcache = false
+  false
+end
+
+have_memcache?
+
 def need_memcached(forwhat)
   if have_memcached?
     yield
   else
-    STDERR.puts "skipping memcached #{forwhat} (MEMCACHED environment variable not set)"
+    STDERR.puts "skipping memcached #{forwhat}"
   end
 end
 
+def need_memcache(forwhat)
+  if have_memcache?
+    yield
+  else
+    STDERR.puts "skipping memcache #{forwhat}"
+  end
+end
+
+def need_java(forwhat)
+  
+  if RUBY_PLATFORM =~ /java/
+    yield
+  else
+    STDERR.puts "skipping app engine #{forwhat}"
+  end
+end
+
+
 # Setup the load path ..
 $LOAD_PATH.unshift File.dirname(File.dirname(__FILE__)) + '/lib'
 $LOAD_PATH.unshift File.dirname(__FILE__)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rack-cache
 version: !ruby/object:Gem::Version 
-  version: "0.4"
+  version: "0.5"
 platform: ruby
 authors: 
 - Ryan Tomayko
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-16 00:00:00 -07:00
+date: 2009-05-25 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -18,7 +18,7 @@ dependencies:
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
         version: "0.4"
     version: 
@@ -50,6 +50,7 @@ files:
 - example/sinatra/app.rb
 - example/sinatra/views/index.erb
 - lib/rack/cache.rb
+- lib/rack/cache/appengine.rb
 - lib/rack/cache/cachecontrol.rb
 - lib/rack/cache/context.rb
 - lib/rack/cache/entitystore.rb