rtomayko-rack-cache 0.5 → 0.5.1

data/CHANGES

@@ -1,3 +1,18 @@
+## 0.6.0 / Unreleased
+
+  * Added support for memcached clusters and other advanced
+    configuration provided by the memcache-client and memcached
+    libraries. The "metastore" and "entitystore" options can now be
+    set to a MemCache object or Memcached object:
+
+    memcache = MemCache.new(['127.1.1.1', '127.1.1.2'], :namespace => "/foo")
+    use Rack::Cache,
+      :metastore => memcache,
+      :entitystore => memcache
+
+  * Fix "memcached://" metastore URL handling. The "memcached" variation
+    blew up, the "memcache" version was fine.
+
 ## 0.5.0 / May 2009
 
   * Added meta and entity store implementations based on the

data/doc/storage.markdown

@@ -62,10 +62,9 @@ deployments so explicit configuration is advised.
 The default metastore and entitystore values can be specified when the
 __Rack::Cache__ object is added to the Rack middleware pipeline as follows:
 
-    use Rack::Cache do
-      set :metastore, 'file:/var/cache/rack/meta'
-      set :entitystore, 'file:/var/cache/rack/body'
-    end
+    use Rack::Cache,
+      :metastore => 'file:/var/cache/rack/meta',
+      :entitystore => 'file:/var/cache/rack/body'
 
 Alternatively, the `rack-cache.metastore` and `rack-cache.entitystore`
 variables may be set in the Rack environment by an upstream component.
@@ -82,8 +81,9 @@ use a specific storage implementation as well as pros and cons of each.
 
 Uses local process memory to store cached entries.
 
-    set :metastore,   'heap:/'
-    set :entitystore, 'heap:/'
+    use Rack::Cache,
+      :metastore   => 'heap:/',
+      :entitystore => 'heap:/'
 
 The heap storage backend is simple, fast, and mostly useless. All cache
 information is stored in each backend application's local process memory (using
@@ -102,8 +102,9 @@ is small and well understood.
 
 Stores cached entries on the filesystem.
 
-    set :metastore,   'file:/var/cache/rack/meta'
-    set :entitystore, 'file:/var/cache/rack/body'
+    use Rack::Cache,
+      :metastore   => 'file:/var/cache/rack/meta',
+      :entitystore => 'file:/var/cache/rack/body'
 
 The URI may specify an absolute, relative, or home-rooted path:
 
@@ -132,18 +133,19 @@ collision.
 Stores cached entries in a remote [memcached](http://www.danga.com/memcached/)
 instance.
 
-    set :metastore,   'memcached://localhost:11211/meta'
-    set :entitystore, 'memcached://localhost:11211/body'
+    use Rack::Cache,
+      :metastore   => 'memcached://localhost:11211/meta',
+      :entitystore => 'memcached://localhost:11211/body'
 
 The URI must specify the host and port of a remote memcached daemon. The path
 portion is an optional (but recommended) namespace that is prepended to each
 cache key.
 
-The memcached storage backend requires [Evan Weaver's memcached client library][e].
-This is a [fast][f] client implementation built on the SWIG/[libmemcached][l] C
-library. The library may be installed from Gem as follows:
+The memcached storage backend requires either the `memcache-client` or
+`memcached` libraries. By default, the `memcache-client` library is used;
+require the `memcached` library explicitly to use it instead.
 
-    sudo gem install memcached --no-rdoc --no-ri
+    gem install memcache-client
 
 Memcached storage is reasonably fast and allows multiple backends to share a
 single cache. It is also the only storage implementation that allows the cache

data/lib/rack/cache/entitystore.rb

@@ -182,19 +182,25 @@ module Rack::Cache
       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
+        if uri.respond_to?(:scheme)
+          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
+        else
+          # if the object provided is not a URI, pass it straight through
+          # to the underlying implementation.
+          new uri
         end
-        options[:namespace] = uri.path.sub(/^\//, '')
-        new server, options
       end
     end
 

data/lib/rack/cache/metastore.rb

@@ -274,19 +274,27 @@ module Rack::Cache
       # 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
+        if uri.respond_to?(:scheme)
+          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.to_s.sub(/^\//, '')
+
+          new server, options
+        else
+          # if the object provided is not a URI, pass it straight through
+          # to the underlying implementation.
+          new uri
         end
-        options[:namespace] = uri.path.sub(/^\//, '')
-        new server, options
       end
     end
 
@@ -359,7 +367,7 @@ module Rack::Cache
       else
         MemCache
       end
-    MEMCACHED = MemCache
+    MEMCACHED = MEMCACHE
 
     class GAEStore < MetaStore
       attr_reader :cache

data/lib/rack/cache/storage.rb

@@ -30,12 +30,25 @@ module Rack::Cache
 
   private
     def create_store(type, uri)
-      uri = URI.parse(uri) unless uri.respond_to?(:scheme)
-      if type.const_defined?(uri.scheme.upcase)
-        klass = type.const_get(uri.scheme.upcase)
-        klass.resolve(uri)
+      if uri.respond_to?(:scheme) || uri.respond_to?(:to_str)
+        uri = URI.parse(uri) unless uri.respond_to?(:scheme)
+        if type.const_defined?(uri.scheme.upcase)
+          klass = type.const_get(uri.scheme.upcase)
+          klass.resolve(uri)
+        else
+          fail "Unknown storage provider: #{uri.to_s}"
+        end
       else
-        fail "Unknown storage provider: #{uri.to_s}"
+        # hack in support for passing a MemCache or Memcached object
+        # as the storage URI.
+        case
+        when defined?(::MemCache) && uri.kind_of?(::MemCache)
+          type.const_get(:MemCache).resolve(uri)
+        when defined?(::Memcached) && uri.respond_to?(:stats)
+          type.const_get(:MemCached).resolve(uri)
+        else
+          fail "Unknown storage provider: #{uri.to_s}"
+        end
       end
     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.5'
-  s.date = '2009-05-25'
+  s.version = '0.5.1'
+  s.date = '2009-06-06'
 
   s.description = "HTTP Caching for Rack"
   s.summary     = "HTTP Caching for Rack"

data/test/metastore_test.rb

@@ -272,7 +272,7 @@ describe 'Rack::Cache::MetaStore' do
       end
     end
   end
-  
+
   need_java 'entity store testing' do
     module Rack::Cache::AppEngine
       module MC
@@ -282,12 +282,12 @@ describe 'Rack::Cache::MetaStore' do
           def get(key); self[key]; end;
           def put(key, value, ttl = nil)
             self[key] = value
-          end  
+          end
 
         end
       end
     end
-  
+
     describe 'GAEStore' do
       it_should_behave_like 'A Rack::Cache::MetaStore Implementation'
       before :each do
@@ -296,7 +296,7 @@ describe 'Rack::Cache::MetaStore' do
         @entity_store = Rack::Cache::EntityStore::Heap.new
       end
     end
-  
+
   end
 
 end

data/test/options_test.rb

@@ -74,5 +74,4 @@ describe 'Rack::Cache::Options' do
     @options.should.respond_to :verbose?
     @options.verbose.should.not.be.nil
   end
-
 end

data/test/spec_setup.rb

@@ -13,7 +13,7 @@ end
 
 # Set the MEMCACHED environment variable as follows to enable testing
 # of the MemCached meta and entity stores.
-ENV['MEMCACHED'] ||= 'localhost:11215'
+ENV['MEMCACHED'] ||= 'localhost:11211'
 $memcached = nil
 $memcache = nil
 
@@ -70,7 +70,6 @@ def need_memcache(forwhat)
 end
 
 def need_java(forwhat)
-  
   if RUBY_PLATFORM =~ /java/
     yield
   else

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rtomayko-rack-cache
 version: !ruby/object:Gem::Version 
-  version: "0.5"
+  version: 0.5.1
 platform: ruby
 authors: 
 - Ryan Tomayko
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-25 00:00:00 -07:00
+date: 2009-06-06 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency