cache 0.0.2 → 0.0.3

data/BENCHMARKS

@@ -0,0 +1,96 @@
+# sabshere 2/22/11 v0.0.2
+
+Darwin vidalia 9.8.0 Darwin Kernel Version 9.8.0: Wed Jul 15 16:55:01 PDT 2009; root:xnu-1228.15.4~1/RELEASE_I386 i386
+ruby 1.8.7 (2010-05-25 patchlevel 266) [i686-darwin9.8.0]
+RUBY_VERSION=ruby-1.8.7-head
+Ruby 1.8.7p266
+Loaded memcached 1.0.6
+Loaded remix-stash 1.1.3
+Loaded memcache-client 1.8.5
+Loaded cache 0.0.2
+Loaded kgio 2.3.2
+Loaded dalli 1.0.2
+Loops is 20000
+Stack depth is 0
+Small value size is: 13 bytes
+Large value size is: 4158 bytes
+No matching processes belonging to you were found
+                                          user     system      total        real
+set: cache:dalli:bin                  6.340000   1.880000   8.220000 ( 10.948888)
+set: cache:libm:bin                   5.730000   1.530000   7.260000 ( 10.640067)
+set: dalli:bin                        5.580000   1.860000   7.440000 ( 10.092303)
+set: libm:ascii                       0.840000   1.290000   2.130000 (  5.445700)
+set: libm:ascii:pipeline              0.340000   0.020000   0.360000 (  0.362669)
+set: libm:ascii:udp                   0.710000   0.710000   1.420000 (  3.642532)
+set: libm:bin                         0.710000   1.320000   2.030000 (  5.339189)
+set: libm:bin:buffer                  0.300000   0.110000   0.410000 (  1.107518)
+set: mclient:ascii                   10.700000   3.670000  14.370000 ( 14.945212)
+set: stash:bin                        3.710000   1.370000   5.080000 (  8.162312)
+
+get: cache:dalli:bin                  6.820000   2.080000   8.900000 ( 11.412364)
+get: cache:libm:bin                   5.670000   1.490000   7.160000 ( 10.392625)
+get: dalli:bin                        5.840000   2.090000   7.930000 ( 10.308551)
+get: libm:ascii                       0.970000   1.310000   2.280000 (  5.562719)
+get: libm:ascii:pipeline              1.060000   1.620000   2.680000 (  5.881988)
+get: libm:ascii:udp                   0.820000   0.720000   1.540000 (  3.585481)
+get: libm:bin                         0.810000   1.330000   2.140000 (  5.310565)
+get: libm:bin:buffer                  0.940000   1.630000   2.570000 (  5.677996)
+get: mclient:ascii                   12.680000   3.690000  16.370000 ( 16.930786)
+get: stash:bin                        3.390000   1.370000   4.760000 (  7.658067)
+
+delete: cache:dalli:bin               6.190000   2.080000   8.270000 ( 10.697357)
+delete: cache:libm:bin                6.080000   1.580000   7.660000 ( 10.938304)
+delete: dalli:bin                     5.190000   2.080000   7.270000 (  9.694417)
+delete: libm:ascii                    1.790000   1.400000   3.190000 (  6.452993)
+delete: libm:ascii:pipeline           0.550000   0.620000   1.170000 (  1.226934)
+delete: libm:ascii:udp                1.620000   0.870000   2.490000 (  4.440414)
+delete: libm:bin                      1.720000   1.400000   3.120000 (  6.322207)
+delete: libm:bin:buffer               0.460000   0.520000   0.980000 (  1.651911)
+delete: mclient:ascii                10.610000   3.700000  14.310000 ( 14.815498)
+delete:stash:bin => #<NoMethodError: undefined method `delete' for #<Remix::Stash:0x122e984>>
+
+get-missing: cache:dalli:bin          6.300000   2.110000   8.410000 ( 10.962403)
+get-missing: cache:libm:bin           7.090000   1.780000   8.870000 ( 12.435441)
+get-missing: dalli:bin                5.730000   2.260000   7.990000 ( 10.758698)
+get-missing: libm:ascii               2.070000   1.550000   3.620000 (  7.211442)
+get-missing: libm:ascii:pipeline      2.190000   1.920000   4.110000 (  7.549889)
+get-missing: libm:ascii:udp           1.820000   0.930000   2.750000 (  4.887171)
+get-missing: libm:bin                 1.990000   1.510000   3.500000 (  6.837518)
+get-missing: libm:bin:buffer          2.050000   1.830000   3.880000 (  7.134244)
+get-missing: mclient:ascii           11.160000   3.790000  14.950000 ( 15.550381)
+get-missing: stash:bin                3.240000   1.390000   4.630000 (  7.602964)
+
+set-large: cache:dalli:bin            8.160000   2.010000  10.170000 ( 13.146422)
+set-large: cache:libm:bin             6.490000   1.610000   8.100000 ( 11.726796)
+set-large: dalli:bin                  7.490000   2.030000   9.520000 ( 12.402519)
+set-large: libm:ascii                 0.920000   1.400000   2.320000 (  5.925636)
+set-large: libm:ascii:pipeline        0.630000   0.450000   1.080000 (  1.246708)
+set-large: libm:ascii:udp             0.790000   0.820000   1.610000 (  4.095793)
+set-large: libm:bin                   0.810000   1.440000   2.250000 (  5.770076)
+set-large: libm:bin:buffer            0.570000   0.640000   1.210000 (  2.286722)
+set-large: mclient:ascii             11.940000   3.910000  15.850000 ( 17.592266)
+set-large: stash:bin                  6.250000   1.510000   7.760000 ( 13.191809)
+
+get-large: cache:dalli:bin            8.320000   2.460000  10.780000 ( 13.958967)
+get-large: cache:libm:bin            10.740000   1.760000  12.500000 ( 16.610462)
+get-large: dalli:bin                  7.270000   2.460000   9.730000 ( 12.867557)
+get-large: libm:ascii                 1.590000   1.540000   3.130000 (  7.126347)
+get-large: libm:ascii:pipeline        1.700000   1.900000   3.600000 (  7.440423)
+get-large: libm:ascii:udp             1.420000   0.950000   2.370000 (  4.683143)
+get-large: libm:bin                   1.440000   1.580000   3.020000 (  6.955872)
+get-large: libm:bin:buffer            1.550000   1.920000   3.470000 (  7.199426)
+get-large: mclient:ascii             15.460000   4.560000  20.020000 ( 20.855362)
+get-large: stash:bin                  3.610000   1.450000   5.060000 (  8.103802)
+
+hash:jenkins                          0.660000   0.010000   0.670000 (  0.660554)
+hash:hsieh                            0.310000   0.000000   0.310000 (  0.323458)
+hash:default                          0.620000   0.000000   0.620000 (  0.616587)
+hash:fnv1_32                          0.620000   0.000000   0.620000 (  0.631255)
+hash:fnv1_64                          1.280000   0.010000   1.290000 (  1.291580)
+hash:none                             0.320000   0.000000   0.320000 (  0.324198)
+hash:md5                              1.030000   0.000000   1.030000 (  1.046663)
+hash:murmur                           0.560000   0.010000   0.570000 (  0.574408)
+hash:fnv1a_32                         0.660000   0.000000   0.660000 (  0.670788)
+hash:fnv1a_64                         0.690000   0.000000   0.690000 (  0.701477)
+hash:crc                              0.640000   0.010000   0.650000 (  0.646991)
+vidalia:~/github/memcached (master) $ 

data/lib/cache/storage.rb

@@ -10,60 +10,92 @@ class Cache
     end
     
     def get(k)
-      if defined?(::Memcached) and bare_client.is_a?(::Memcached)
+      reset_if_forked_or_threaded
+      if memcached?
         begin; bare_client.get(k); rescue ::Memcached::NotFound; nil; end
-      elsif defined?(::Redis) and bare_client.is_a?(::Redis)
+      elsif dalli? or memcached_rails? or mem_cache?
+        bare_client.get k
+      elsif redis?
         if cached_v = bare_client.get(k) and cached_v.is_a?(::String)
           ::Marshal.load cached_v
         end
-      elsif bare_client.respond_to?(:get)
-        bare_client.get k
-      elsif bare_client.respond_to?(:read)
+      elsif active_support_store?
         bare_client.read k
       else
-        raise "Don't know how to work with #{bare_client.inspect} because it doesn't define get"
+        raise "Don't know how to GET with #{bare_client.inspect}"
       end
     end
         
     def set(k, v, ttl)
       ttl ||= parent.config.default_ttl
-      if defined?(::Redis) and bare_client.is_a?(::Redis)
+      reset_if_forked_or_threaded
+      if memcached? or dalli? or memcached_rails? or mem_cache?
+        bare_client.set k, v, ttl
+      elsif redis?
         if ttl == 0
           bare_client.set k, ::Marshal.dump(v)
         else
           bare_client.setex k, ttl, ::Marshal.dump(v)
         end
-      elsif bare_client.respond_to?(:set)
-        bare_client.set k, v, ttl
-      elsif bare_client.respond_to?(:write)
+      elsif active_support_store?
         if ttl == 0
           bare_client.write k, v # never expire
         else
           bare_client.write k, v, :expires_in => ttl
         end
       else
-        raise "Don't know how to work with #{bare_client.inspect} because it doesn't define set"
+        raise "Don't know how to SET with #{bare_client.inspect}"
       end
     end
     
     def delete(k)
-      if defined?(::Memcached) and bare_client.is_a?(::Memcached)
+      reset_if_forked_or_threaded
+      if memcached?
         begin; bare_client.delete(k); rescue ::Memcached::NotFound; nil; end
-      elsif defined?(::Redis) and bare_client.is_a?(::Redis)
+      elsif redis?
         bare_client.del k
-      elsif bare_client.respond_to?(:delete)
+      elsif dalli? or memcached_rails? or mem_cache? or active_support_store?
         bare_client.delete k
       else
-        raise "Don't know how to work with #{bare_client.inspect} because it doesn't define delete"
+        raise "Don't know how to DELETE with #{bare_client.inspect}"
       end
     end
     
     def flush
+      reset_if_forked_or_threaded
       bare_client.send %w{ flush flushdb flush_all clear }.detect { |flush_cmd| bare_client.respond_to? flush_cmd }
     end
     
     private
     
+    def bare_client
+      @bare_client ||= parent.config.client
+    end
+    
+    def reset_if_forked_or_threaded
+      if fork_detected?
+        if dalli?
+          parent.config.client.close
+        elsif dalli_store?
+          parent.config.client.reset
+        elsif memcached? or memcached_rails?
+          cloned_client = parent.config.client.clone
+          parent.config.client = cloned_client
+          @bare_client = parent.config.client
+        elsif redis?
+          parent.config.client.client.connect
+        elsif mem_cache?
+          parent.config.client.reset
+        end
+      elsif new_thread_detected?
+        if memcached? or memcached_rails?
+          cloned_client = parent.config.client.clone
+          parent.config.client = cloned_client
+          @bare_client = parent.config.client
+        end
+      end
+    end
+    
     def fork_detected?
       if @pid != ::Process.pid
         @pid = ::Process.pid
@@ -75,24 +107,54 @@ class Cache
         @thread_object_id = ::Thread.current.object_id
       end
     end
+        
+    def dalli?
+      return @dalli_query[0] if @dalli_query.is_a?(::Array)
+      answer = (defined?(::Dalli) and bare_client.is_a?(::Dalli::Client))
+      @dalli_query = [answer]
+      answer
+    end
     
-    def bare_client
-      fork_detected = fork_detected?
-      new_thread_detected = new_thread_detected?
-      if defined?(::Dalli) and parent.config.client.is_a?(::Dalli::Client)
-        parent.config.client.close if fork_detected
-      elsif defined?(::ActiveSupport::Cache::DalliStore) and parent.config.client.is_a?(::ActiveSupport::Cache::DalliStore)
-        parent.config.client.reset if fork_detected
-      elsif defined?(::Memcached) and (parent.config.client.is_a?(::Memcached) or parent.config.client.is_a?(::Memcached::Rails))
-        parent.config.client = parent.config.client.clone if fork_detected or new_thread_detected
-      elsif defined?(::Redis) and parent.config.client.is_a?(::Redis)
-        parent.config.client.client.connect if fork_detected
-      elsif defined?(::MemCache) and parent.config.client.is_a?(::MemCache)
-        parent.config.client.reset if fork_detected
-      else
-        raise "Don't know how to thread/fork #{parent.config.client.inspect}"
-      end
-      parent.config.client
+    def active_support_store?
+      return @active_support_store_query[0] if @active_support_store_query.is_a?(::Array)
+      answer = (defined?(::ActiveSupport::Cache) and bare_client.is_a?(::ActiveSupport::Cache::Store))
+      @active_support_store_query = [answer]
+      answer
+    end
+    
+    def dalli_store?
+      return @dalli_store_query[0] if @dalli_store_query.is_a?(::Array)
+      answer = (defined?(::ActiveSupport::Cache::DalliStore) and bare_client.is_a?(::ActiveSupport::Cache::DalliStore))
+      @dalli_store_query = [answer]
+      answer
+    end
+    
+    def mem_cache?
+      return @mem_cache_query[0] if @mem_cache_query.is_a?(::Array)
+      answer = (defined?(::MemCache) and bare_client.is_a?(::MemCache))
+      @mem_cache_query = [answer]
+      answer
+    end
+
+    def memcached?
+      return @memcached_query[0] if @memcached_query.is_a?(::Array)
+      answer = (defined?(::Memcached) and bare_client.is_a?(::Memcached))
+      @memcached_query = [answer]
+      answer
+    end
+    
+    def memcached_rails?
+      return @memcached_rails_query[0] if @memcached_rails_query.is_a?(::Array)
+      answer = (defined?(::Memcached) and bare_client.is_a?(::Memcached::Rails))
+      @memcached_rails_query = [answer]
+      answer
+    end
+    
+    def redis?
+      return @redis_query[0] if @redis_query.is_a?(::Array)
+      answer = (defined?(::Redis) and bare_client.is_a?(::Redis))
+      @redis_query = [answer]
+      answer
     end
   end
 end

data/lib/cache/version.rb

@@ -1,3 +1,3 @@
 class Cache
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/test/helper.rb

@@ -2,7 +2,6 @@ require 'rubygems'
 require 'bundler'
 Bundler.setup
 require 'test/unit'
-# require 'ruby-debug'
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'cache'
@@ -11,7 +10,7 @@ require 'shared_tests'
 
 class Test::Unit::TestCase
   def setup
-    @cache = Cache.new @client
+    @cache = Cache.new raw_client
     @cache.flush
   end
 end

data/test/profile/benchmark.rb

@@ -0,0 +1,236 @@
+# sabshere 2/22/11 thanks to memcached
+HERE = File.dirname(__FILE__)
+$LOAD_PATH << "#{HERE}/../../lib/"
+UNIX_SOCKET_NAME = File.join(ENV['TMPDIR']||'/tmp','memcached') 
+
+require 'memcached'
+require 'benchmark'
+require 'rubygems'
+require 'ruby-debug' if ENV['DEBUG']
+begin; require 'memory'; rescue LoadError; end
+
+puts `uname -a`
+puts `ruby -v`
+puts `env | egrep '^RUBY'`
+puts "Ruby #{RUBY_VERSION}p#{RUBY_PATCHLEVEL}"
+
+[ ["memcached", "memcached"], 
+  ["remix-stash", "remix/stash"], 
+  # ["astro-remcached", "remcached"], # Clobbers the "Memcached" constant
+  ["memcache-client", "memcache"],
+  ["cache", "cache"],
+  ["kgio", "kgio"],
+  ["dalli","dalli"]].each do |gem_name, requirement|
+  require requirement
+  gem gem_name
+  puts "Loaded #{gem_name} #{Gem.loaded_specs[gem_name].version.to_s rescue nil}"
+end
+
+class Remix::Stash
+  # Remix::Stash API doesn't let you set servers
+  @@clusters = {:default => Remix::Stash::Cluster.new(['127.0.0.1:43042', '127.0.0.1:43043'])}
+end
+
+class Dalli::ClientCompat < Dalli::Client
+  def set(*args)
+    super(*args[0..2])
+  end
+  def get(*args)
+    super(args.first)
+  end
+  def get_multi(*args)
+    super(args.first)
+  end
+  def append(*args)
+    super
+  rescue Dalli::DalliError
+  end
+  def prepend(*args)
+    super
+  rescue Dalli::DalliError
+  end  
+end
+
+class Cache::Compat < Cache
+  def set(*args)
+    super(*args[0..2])
+  end
+  def get(*args)
+    super(args.first)
+  end
+end
+
+class Bench
+
+  def initialize(loops = nil, stack_depth = nil)
+    @loops = (loops || 20000).to_i
+    @stack_depth = (stack_depth || 0).to_i
+    
+    puts "Loops is #{@loops}"
+    puts "Stack depth is #{@stack_depth}"
+        
+    @m_value = Marshal.dump(
+      @small_value = ["testing"])    
+    @m_large_value = Marshal.dump(
+      @large_value = [{"test" => "1", "test2" => "2", Object.new => "3", 4 => 4, "test5" => 2**65}] * 2048)
+
+    puts "Small value size is: #{@m_value.size} bytes"
+    puts "Large value size is: #{@m_large_value.size} bytes"
+
+    @keys = [
+      @k1 = "Short",
+      @k2 = "Sym1-2-3::45" * 8,
+      @k3 = "Long" * 40,
+      @k4 = "Medium" * 8,
+      @k5 = "Medium2" * 8,
+      @k6 = "Long3" * 40]
+    
+    reset_servers
+    reset_clients
+    
+    Benchmark.bm(36) do |x| 
+      @benchmark = x 
+    end
+  end
+
+  def run(level = @stack_depth)
+    level > 0 ? run(level - 1) : run_without_recursion
+  end
+  
+  private
+  
+  def reset_servers
+    system("ruby #{HERE}/../setup.rb")
+    sleep(1)
+  end
+  
+  def reset_clients
+    @clients = {
+       "cache:libm:bin" => Cache::Compat.new(Memcached.new(['127.0.0.1:43042', '127.0.0.1:43043'], :buffer_requests => false, :no_block => false, :namespace => "namespace", :binary_protocol => true)),
+       "cache:dalli:bin" => Cache::Compat.new(Dalli::Client.new(['127.0.0.1:43042', '127.0.0.1:43043'], :marshal => false, :threadsafe => false)),
+       "libm:ascii" => Memcached::Rails.new(
+         ['127.0.0.1:43042', '127.0.0.1:43043'],
+         :buffer_requests => false, :no_block => false, :namespace => "namespace"),
+       "libm:ascii:pipeline" => Memcached::Rails.new(
+         ['127.0.0.1:43042', '127.0.0.1:43043'],
+         :no_block => true, :buffer_requests => true, :noreply => true, :namespace => "namespace"),
+       "libm:ascii:udp" => Memcached::Rails.new(
+         ["#{UNIX_SOCKET_NAME}0", "#{UNIX_SOCKET_NAME}1"],
+         :buffer_requests => false, :no_block => false, :namespace => "namespace"),
+       "libm:bin" => Memcached::Rails.new(
+          ['127.0.0.1:43042', '127.0.0.1:43043'],
+          :buffer_requests => false, :no_block => false, :namespace => "namespace", :binary_protocol => true),
+       "libm:bin:buffer" => Memcached::Rails.new(
+         ['127.0.0.1:43042', '127.0.0.1:43043'],
+         :no_block => true, :buffer_requests => true, :namespace => "namespace", :binary_protocol => true),
+       "mclient:ascii" => MemCache.new(['127.0.0.1:43042', '127.0.0.1:43043']),
+       "stash:bin" => Remix::Stash.new(:root),
+       "dalli:bin" => Dalli::ClientCompat.new(['127.0.0.1:43042', '127.0.0.1:43043'], :marshal => false, :threadsafe => false)}
+  end
+  
+  
+  def benchmark_clients(test_name, clients = @clients)
+    clients.keys.sort.each do |client_name|
+      next if client_name == "stash" and test_name == "set-large" # Don't let stash break the world
+      client = clients[client_name]
+      begin
+        yield client
+        @benchmark.report("#{test_name}: #{client_name}") { @loops.times { yield client } }
+      rescue Exception => e
+        puts "#{test_name}:#{client_name} => #{e.inspect}"
+        reset_clients
+      end
+    end
+    puts
+  end
+  
+  def benchmark_hashes(hashes, test_name)
+    hashes.each do |hash_name, int|
+      @m = Memcached::Rails.new(:hash => hash_name)
+      @benchmark.report("#{test_name}:#{hash_name}") do
+        (@loops * 5).times { yield int }
+      end
+    end  
+  end
+  
+  def run_without_recursion
+    benchmark_clients("set") do |c|
+      c.set @k1, @m_value, 0, true
+      c.set @k2, @m_value, 0, true
+      c.set @k3, @m_value, 0, true
+    end
+
+    benchmark_clients("get") do |c|
+      c.get @k1, true
+      c.get @k2, true
+      c.get @k3, true
+    end
+    
+    # benchmark_clients("get-multi") do |c|
+    #   c.get_multi @keys, true
+    # end
+    # 
+    # benchmark_clients("append") do |c|
+    #   c.append @k1, @m_value
+    #   c.append @k2, @m_value
+    #   c.append @k3, @m_value
+    # end    
+    # 
+    # benchmark_clients("prepend") do |c|
+    #   c.prepend @k1, @m_value
+    #   c.prepend @k2, @m_value
+    #   c.prepend @k3, @m_value
+    # end       
+  
+    benchmark_clients("delete") do |c|    
+      c.delete @k1
+      c.delete @k2
+      c.delete @k3
+    end
+    
+    benchmark_clients("get-missing") do |c|
+      c.get @k1
+      c.get @k2
+      c.get @k3
+    end
+
+    # benchmark_clients("append-missing") do |c|
+    #   c.append @k1, @m_value
+    #   c.append @k2, @m_value
+    #   c.append @k3, @m_value
+    # end
+    # 
+    # benchmark_clients("prepend-missing") do |c|
+    #   c.prepend @k1, @m_value
+    #   c.prepend @k2, @m_value
+    #   c.prepend @k3, @m_value
+    # end
+    
+    benchmark_clients("set-large") do |c|
+      c.set @k1, @m_large_value, 0, true
+      c.set @k2, @m_large_value, 0, true
+      c.set @k3, @m_large_value, 0, true
+    end
+
+    benchmark_clients("get-large") do |c|
+      c.get @k1, true
+      c.get @k2, true
+      c.get @k3, true
+    end
+     
+    benchmark_hashes(Memcached::HASH_VALUES, "hash") do |i|
+      Rlibmemcached.memcached_generate_hash_rvalue(@k1, i)
+      Rlibmemcached.memcached_generate_hash_rvalue(@k2, i)
+      Rlibmemcached.memcached_generate_hash_rvalue(@k3, i)
+      Rlibmemcached.memcached_generate_hash_rvalue(@k4, i)
+      Rlibmemcached.memcached_generate_hash_rvalue(@k5, i)
+      Rlibmemcached.memcached_generate_hash_rvalue(@k6, i)    
+    end
+  end
+end
+
+Bench.new(ENV["LOOPS"], ENV["STACK_DEPTH"]).run
+
+Process.memory.each do |key, value|
+  puts "#{key}: #{value/1024.0}M"
+end if Process.respond_to? :memory

data/test/test_dalli_storage.rb

@@ -3,9 +3,8 @@ require 'helper'
 require 'dalli'
 
 class TestDalliStorage < Test::Unit::TestCase
-  def setup
-    @client = Dalli::Client.new ['localhost:11211']
-    super
+  def raw_client
+    Dalli::Client.new ['localhost:11211']
   end
     
   include SharedTests

data/test/test_dalli_store_storage.rb

@@ -5,9 +5,8 @@ require 'active_support/all'
 require 'active_support/cache/dalli_store'
 
 class TestDalliStoreStorage < Test::Unit::TestCase
-  def setup
-    @client = ActiveSupport::Cache::DalliStore.new ['localhost:11211']
-    super
+  def raw_client
+    ActiveSupport::Cache::DalliStore.new ['localhost:11211']
   end
     
   include SharedTests

data/test/test_memcache_storage.rb

@@ -4,9 +4,8 @@ require 'helper'
 require 'memcache'
 
 class TestMemcacheStorage < Test::Unit::TestCase
-  def setup
-    @client = MemCache.new ['localhost:11211']
-    super
+  def raw_client
+    MemCache.new ['localhost:11211']
   end
     
   include SharedTests

data/test/test_memcached_rails_storage.rb

@@ -3,9 +3,8 @@ require 'helper'
 require 'memcached'
 
 class TestMemcachedRailsStorage < Test::Unit::TestCase
-  def setup
-    @client = Memcached::Rails.new 'localhost:11211'
-    super
+  def raw_client
+    Memcached::Rails.new 'localhost:11211'
   end
     
   include SharedTests

data/test/test_memcached_storage.rb

@@ -3,9 +3,8 @@ require 'helper'
 require 'memcached'
 
 class TestMemcachedStorage < Test::Unit::TestCase
-  def setup
-    @client = Memcached.new 'localhost:11211'
-    super
+  def raw_client
+    Memcached.new 'localhost:11211'
   end
     
   include SharedTests

data/test/test_redis_storage.rb

@@ -5,10 +5,9 @@ if ENV['REDIS_URL']
   require 'uri'
 
   class TestRedisStorage < Test::Unit::TestCase
-    def setup
+    def raw_client
       uri = URI.parse(ENV["REDIS_URL"])
-      @client = Redis.new(:host => uri.host, :port => uri.port, :password => uri.password)
-      super
+      Redis.new(:host => uri.host, :port => uri.port, :password => uri.password)
     end
     
     include SharedTests

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cache
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Seamus Abshere
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-17 00:00:00 -06:00
+date: 2011-02-22 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -129,6 +129,7 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
+- BENCHMARKS
 - Gemfile
 - README.rdoc
 - Rakefile
@@ -138,6 +139,7 @@ files:
 - lib/cache/storage.rb
 - lib/cache/version.rb
 - test/helper.rb
+- test/profile/benchmark.rb
 - test/shared_tests.rb
 - test/test_dalli_storage.rb
 - test/test_dalli_store_storage.rb
@@ -181,6 +183,7 @@ specification_version: 3
 summary: Wraps memcached, redis, memcache-client, dalli and handles their weirdnesses, including forking
 test_files: 
 - test/helper.rb
+- test/profile/benchmark.rb
 - test/shared_tests.rb
 - test/test_dalli_storage.rb
 - test/test_dalli_store_storage.rb