cache 0.0.1 → 0.0.2

data/README.rdoc

@@ -2,12 +2,40 @@
 
 A unified cache handling interface, inspired (but simpler than) Perl's Cache::Cache[http://cpan.uwinnipeg.ca/module/Cache::Cache] and CHI[http://cpan.uwinnipeg.ca/module/CHI].
 
+Takes care of exceptions like Memcached::NotFound and also forking/threading.
+
+== Example
+
+    require 'memcached' # a really fast memcached client gem
+    require 'client'    # this gem, which provides a standard interface
+    raw_client = Memcached.new '127.0.0.1:11211'
+    cache = Cache.new raw_client
+
+or
+
+    require 'redis'     # the redis key-value store
+    require 'client'    # this gem, which provides a standard interface
+    raw_client = Redis.new
+    cache = Cache.new raw_client
+
+or
+
+    require 'dalli'     # the dalli memcached client used by heroku
+    require 'client'    # this gem, which provides a standard interface
+    raw_client = Dalli::Client.new
+    cache = Cache.new raw_client
+
+Maybe this will even work:
+
+    # Piggyback off the default rails cache
+    cache = Cache.new Rails.cache
+
 == Methods
 
-* get
-* set
-* delete
-* flush
+    cache.get 'hello'
+    cache.set 'hello', 'world'
+    cache.delete 'hello'
+    cache.flush
 
 == Supported clients
 
@@ -21,29 +49,24 @@ Supported Redis clients:
 
 * redis[https://github.com/ezmobius/redis-rb]
 
-== Configuration
-
-You set your preferred cache client:
-
-    Cache.config.client = Memcached.new '127.0.0.1:11211'
-
-or
-
-    Cache.config.client = Redis.new
+== TTL
 
-or this might even work...
+0 means don't expire.
 
-    Cache.config.client = Rails.cache
+== Forking/threading
 
-== TTL
+When you use a Cache object to wrap Memcached or Redis, you don't have to worry about forking or threading.
 
-0 means don't expire.
+For example, you don't have to set up unicorn or PhusionPassenger's <tt>after_fork</tt>.
 
 == Rationale
 
+I wanted a common interface to a bunch of great Ruby cache clients so I can develop gems (lock_method, cache_method) that accept any of them.
+
 * I am so tired of rescuing from Memcached::NotFound
 * I am so tired of forgetting whether it's :expires_in or :ttl
 * I don't know why we ever started using read/write instead of get/set.
+* I don't like how you have to manually handle after_fork for Redis, Memcached, etc.
 
 == Currently unsupported
 

data/lib/cache.rb

@@ -1,42 +1,63 @@
 require 'cache/version'
-module Cache
+class Cache
   autoload :Config, 'cache/config'
   autoload :Storage, 'cache/storage'
-  
-  def self.config #:nodoc:
-    Config.instance
+
+  # Create a new Cache object by passing it a client of your choice.
+  #
+  # Supported memcached clients:
+  # * memcached[https://github.com/fauna/memcached] (either a Memcached or a Memcached::Rails)
+  # * dalli[https://github.com/mperham/dalli] (either a Dalli::Client or an ActiveSupport::Cache::DalliStore)
+  # * memcache-client[https://github.com/mperham/memcache-client] (MemCache, the one commonly used by Rails)
+  #
+  # Supported Redis clients:
+  # * redis[https://github.com/ezmobius/redis-rb]
+  #
+  # Example:
+  #     raw_client = Memcached.new('127.0.0.1:11211')
+  #     cache = Cache.new raw_client
+  def initialize(client)
+    config.client = client
+  end
+
+  def config #:nodoc:
+    @config ||= Config.new self
+  end
+
+  def storage #:nodoc:
+    @storage ||= Storage.new self
   end
 
   # Get a value.
   #
   # Example:
-  #     Cache.get 'hello'
-  def self.get(k)
-    Storage.instance.get k
+  #     cache.get 'hello'
+  def get(k)
+    storage.get k
   end
   
   # Store a value. Note that this will Marshal it.
   #
   # Example:
-  #     Cache.set 'hello', 'world'
-  #     Cache.set 'hello', 'world', 80 # seconds til it expires
-  def self.set(k, v, ttl = nil)
-    Storage.instance.set k, v, ttl
+  #     cache.set 'hello', 'world'
+  #     cache.set 'hello', 'world', 80 # seconds til it expires
+  def set(k, v, ttl = nil)
+    storage.set k, v, ttl
   end
   
   # Delete a value.
   #
   # Example:
-  #     Cache.delete 'hello'
-  def self.delete(k)
-    Storage.instance.delete k
+  #     cache.delete 'hello'
+  def delete(k)
+    storage.delete k
   end
   
   # Flush the cache.
   #
   # Example:
-  #     Cache.flush
-  def self.flush
-    Storage.instance.flush
+  #     cache.flush
+  def flush
+    storage.flush
   end
 end

data/lib/cache/config.rb

@@ -1,39 +1,34 @@
-require 'singleton'
-module Cache
-  # Here's where you set config options.
+class Cache
+  # Here's where config options are kept.
   #
   # Example:
-  #     Cache.config.client = Memcached.new '127.0.0.1:11211'
-  #     Cache.config.default_ttl = 120 # seconds
-  #
-  # You'd probably put this in your Rails config/initializers, for example.
+  #     cache.config.default_ttl = 120 # seconds
   class Config
-    include ::Singleton
+    
+    attr_reader :parent
+    
+    def initialize(parent) #:nodoc:
+      @parent = parent
+    end
     
     # The cache client to use.
     #
-    # Supported memcached clients:
-    # * memcached[https://github.com/fauna/memcached] (either a Memcached or a Memcached::Rails)
-    # * dalli[https://github.com/mperham/dalli] (either a Dalli::Client or an ActiveSupport::Cache::DalliStore)
-    # * memcache-client[https://github.com/mperham/memcache-client] (MemCache, the one commonly used by Rails)
-    #
-    # Supported Redis clients:
-    # * redis[https://github.com/ezmobius/redis-rb]
+    # Note that you normally just set this when you initialize a Cache object.
     #
     # Example:
-    #     Cache.config.storage = Memcached.new '127.0.0.1:11211'
-    def client=(client)
+    #     cache.config.client = Memcached.new '127.0.0.1:11211'
+    def client=(client) #:nodoc:
       @client = client
     end
 
     def client #:nodoc:
-      @client 
+      @client || raise("You didn't select a cache client")
     end
     
     # TTL for method caches. Defaults to 60 seconds.
     #
     # Example:
-    #     Cache.config.default_ttl = 120 # seconds
+    #     cache.config.default_ttl = 120 # seconds
     def default_ttl=(seconds)
       @default_ttl = seconds
     end

data/lib/cache/storage.rb

@@ -1,8 +1,14 @@
-require 'singleton'
-module Cache
+class Cache
   class Storage #:nodoc: all
-    include ::Singleton
-        
+
+    attr_reader :parent
+
+    def initialize(parent)
+      @parent = parent
+      @pid = ::Process.pid
+      @thread_object_id = ::Thread.current.object_id
+    end
+    
     def get(k)
       if defined?(::Memcached) and bare_client.is_a?(::Memcached)
         begin; bare_client.get(k); rescue ::Memcached::NotFound; nil; end
@@ -20,7 +26,7 @@ module Cache
     end
         
     def set(k, v, ttl)
-      ttl ||= Config.instance.default_ttl
+      ttl ||= parent.config.default_ttl
       if defined?(::Redis) and bare_client.is_a?(::Redis)
         if ttl == 0
           bare_client.set k, ::Marshal.dump(v)
@@ -56,35 +62,37 @@ module Cache
       bare_client.send %w{ flush flushdb flush_all clear }.detect { |flush_cmd| bare_client.respond_to? flush_cmd }
     end
     
-    def bare_client
-      if @pid == ::Process.pid
-        fork_detected = false
-      else
-        fork_detected = true
-        ::Thread.current[:cache_storage_bare_client] = nil
+    private
+    
+    def fork_detected?
+      if @pid != ::Process.pid
         @pid = ::Process.pid
       end
-      ::Thread.current[:cache_storage_bare_client] ||= fresh_bare_client(fork_detected)
     end
     
-    def fresh_bare_client(fork_detected)
-      if defined?(::Dalli) and Config.instance.client.is_a?(::Dalli::Client)
-        Config.instance.client.close if fork_detected
-        Config.instance.client
-      elsif defined?(::ActiveSupport::Cache::DalliStore) and Config.instance.client.is_a?(::ActiveSupport::Cache::DalliStore)
-        Config.instance.client.reset if fork_detected
-        Config.instance.client
-      elsif defined?(::Memcached) and (Config.instance.client.is_a?(::Memcached) or Config.instance.client.is_a?(::Memcached::Rails))
-        Config.instance.client.clone
-      elsif defined?(::Redis) and Config.instance.client.is_a?(::Redis)
-        Config.instance.client.client.connect if fork_detected
-        Config.instance.client
-      elsif defined?(::MemCache) and Config.instance.client.is_a?(::MemCache)
-        Config.instance.client.reset if fork_detected
-        Config.instance.client
+    def new_thread_detected?
+      if @thread_object_id != ::Thread.current.object_id
+        @thread_object_id = ::Thread.current.object_id
+      end
+    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 #{Config.instance.client.inspect}"
+        raise "Don't know how to thread/fork #{parent.config.client.inspect}"
       end
+      parent.config.client
     end
   end
 end

data/lib/cache/version.rb

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

data/test/helper.rb

@@ -10,4 +10,8 @@ require 'cache'
 require 'shared_tests'
 
 class Test::Unit::TestCase
+  def setup
+    @cache = Cache.new @client
+    @cache.flush
+  end
 end

data/test/shared_tests.rb

@@ -1,41 +1,41 @@
 module SharedTests
   def test_get
-    assert_equal nil, Cache.get('hello')
-    Cache.set 'hello', 'world'
-    assert_equal 'world', Cache.get('hello')
+    assert_equal nil, @cache.get('hello')
+    @cache.set 'hello', 'world'
+    assert_equal 'world', @cache.get('hello')
   end
   
   def test_set
     assert_nothing_raised do
-      Cache.set 'hello', 'world'
+      @cache.set 'hello', 'world'
     end
   end
   
   def test_set_with_ttl
-    Cache.set 'hello', 'world', 1
-    assert_equal 'world', Cache.get('hello')
+    @cache.set 'hello', 'world', 1
+    assert_equal 'world', @cache.get('hello')
     sleep 2
-    assert_equal nil, Cache.get('hello')
+    assert_equal nil, @cache.get('hello')
   end
   
   def test_set_with_zero_ttl_meaning_eternal
-    Cache.set 'hello', 'world', 0
-    assert_equal 'world', Cache.get('hello')
+    @cache.set 'hello', 'world', 0
+    assert_equal 'world', @cache.get('hello')
     sleep 1
-    assert_equal 'world', Cache.get('hello')
+    assert_equal 'world', @cache.get('hello')
   end
   
   def test_delete
-    Cache.set 'hello', 'world'
-    assert_equal 'world', Cache.get('hello')
-    Cache.delete 'hello'
-    assert_equal nil, Cache.get('hello')
+    @cache.set 'hello', 'world'
+    assert_equal 'world', @cache.get('hello')
+    @cache.delete 'hello'
+    assert_equal nil, @cache.get('hello')
   end
   
   def test_flush
-    Cache.set 'hello', 'world'
-    assert_equal 'world', Cache.get('hello')
-    Cache.flush
-    assert_equal nil, Cache.get('hello')
+    @cache.set 'hello', 'world'
+    assert_equal 'world', @cache.get('hello')
+    @cache.flush
+    assert_equal nil, @cache.get('hello')
   end
 end

data/test/test_dalli_storage.rb

@@ -4,31 +4,29 @@ require 'dalli'
 
 class TestDalliStorage < Test::Unit::TestCase
   def setup
+    @client = Dalli::Client.new ['localhost:11211']
     super
-    client = Dalli::Client.new ['localhost:11211']
-    client.flush
-    Cache.config.client = client
   end
     
   include SharedTests
   
   def get_ring_object_id
-    Cache.config.client.instance_variable_get(:@ring).object_id
+    @cache.config.client.instance_variable_get(:@ring).object_id
   end
   
   def test_treats_as_thread_safe
     # make sure ring is initialized
-    Cache.get 'hi'
+    @cache.get 'hi'
     
     # get the main thread's ring
     main_thread_ring_id = get_ring_object_id
     
     # sanity check that it's not changing every time
-    Cache.get 'hi'
+    @cache.get 'hi'
     assert_equal main_thread_ring_id, get_ring_object_id
     
     # create a new thread and get its ring
-    new_thread_ring_id = Thread.new { Cache.get 'hi'; get_ring_object_id }.value
+    new_thread_ring_id = Thread.new { @cache.get 'hi'; get_ring_object_id }.value
     
     # make sure the ring was reinitialized
     assert_equal main_thread_ring_id, new_thread_ring_id
@@ -36,18 +34,18 @@ class TestDalliStorage < Test::Unit::TestCase
   
   def test_treats_as_not_fork_safe
     # make sure ring is initialized
-    Cache.get 'hi'
+    @cache.get 'hi'
     
     # get the main thread's ring
     parent_process_ring_id = get_ring_object_id
     
     # sanity check that it's not changing every time
-    Cache.get 'hi'
+    @cache.get 'hi'
     assert_equal parent_process_ring_id, get_ring_object_id
     
     # fork a new process
     pid = Kernel.fork do
-      Cache.get 'hi'
+      @cache.get 'hi'
       raise "Didn't split!" if parent_process_ring_id == get_ring_object_id
     end
     Process.wait pid

data/test/test_dalli_store_storage.rb

@@ -6,32 +6,30 @@ require 'active_support/cache/dalli_store'
 
 class TestDalliStoreStorage < Test::Unit::TestCase
   def setup
+    @client = ActiveSupport::Cache::DalliStore.new ['localhost:11211']
     super
-    client = ActiveSupport::Cache::DalliStore.new ['localhost:11211']
-    client.clear
-    Cache.config.client = client
   end
     
   include SharedTests
   
   def get_ring_object_id
-    hidden_dalli_client = Cache.config.client.instance_variable_get :@data
+    hidden_dalli_client = @cache.config.client.instance_variable_get :@data
     hidden_dalli_client.instance_variable_get(:@ring).object_id
   end
   
   def test_treats_as_thread_safe
     # make sure ring is initialized
-    Cache.get 'hi'
+    @cache.get 'hi'
     
     # get the main thread's ring
     main_thread_ring_id = get_ring_object_id
     
     # sanity check that it's not changing every time
-    Cache.get 'hi'
+    @cache.get 'hi'
     assert_equal main_thread_ring_id, get_ring_object_id
     
     # create a new thread and get its ring
-    new_thread_ring_id = Thread.new { Cache.get 'hi'; get_ring_object_id }.value
+    new_thread_ring_id = Thread.new { @cache.get 'hi'; get_ring_object_id }.value
     
     # make sure the ring was reinitialized
     assert_equal main_thread_ring_id, new_thread_ring_id
@@ -39,18 +37,18 @@ class TestDalliStoreStorage < Test::Unit::TestCase
   
   def test_treats_as_not_fork_safe
     # make sure ring is initialized
-    Cache.get 'hi'
+    @cache.get 'hi'
     
     # get the main thread's ring
     parent_process_ring_id = get_ring_object_id
     
     # sanity check that it's not changing every time
-    Cache.get 'hi'
+    @cache.get 'hi'
     assert_equal parent_process_ring_id, get_ring_object_id
     
     # fork a new process
     pid = Kernel.fork do
-      Cache.get 'hi'
+      @cache.get 'hi'
       raise "Didn't split!" if parent_process_ring_id == get_ring_object_id
     end
     Process.wait pid

data/test/test_memcache_storage.rb

@@ -5,31 +5,29 @@ require 'memcache'
 
 class TestMemcacheStorage < Test::Unit::TestCase
   def setup
+    @client = MemCache.new ['localhost:11211']
     super
-    client = MemCache.new ['localhost:11211']
-    client.flush_all
-    Cache.config.client = client
   end
     
   include SharedTests
   
   def get_server_status_ids
-    Cache.config.client.instance_variable_get(:@servers).map { |s| s.status.object_id }
+    @cache.config.client.instance_variable_get(:@servers).map { |s| s.status.object_id }
   end
   
   def test_treats_as_thread_safe
     # make sure servers are connected
-    Cache.get 'hi'
+    @cache.get 'hi'
     
     # get the object ids
     main_thread_server_status_ids = get_server_status_ids
     
     # sanity check that it's not changing every time
-    Cache.get 'hi'
+    @cache.get 'hi'
     assert_equal main_thread_server_status_ids, get_server_status_ids
     
     # create a new thread and get its server ids
-    new_thread_server_status_ids = Thread.new { Cache.get 'hi'; get_server_status_ids }.value
+    new_thread_server_status_ids = Thread.new { @cache.get 'hi'; get_server_status_ids }.value
     
     # make sure the server ids was reinitialized
     assert_equal main_thread_server_status_ids, new_thread_server_status_ids
@@ -37,18 +35,18 @@ class TestMemcacheStorage < Test::Unit::TestCase
   
   def test_treats_as_not_fork_safe
     # make sure server ids is initialized
-    Cache.get 'hi'
+    @cache.get 'hi'
     
     # get the main thread's server ids
     parent_process_server_status_ids = get_server_status_ids
     
     # sanity check that it's not changing every time
-    Cache.get 'hi'
+    @cache.get 'hi'
     assert_equal parent_process_server_status_ids, get_server_status_ids
     
     # fork a new process
     pid = Kernel.fork do
-      Cache.get 'hi'
+      @cache.get 'hi'
       raise "Didn't split!" if parent_process_server_status_ids == get_server_status_ids
     end
     Process.wait pid

data/test/test_memcached_rails_storage.rb

@@ -4,31 +4,29 @@ require 'memcached'
 
 class TestMemcachedRailsStorage < Test::Unit::TestCase
   def setup
+    @client = Memcached::Rails.new 'localhost:11211'
     super
-    client = Memcached::Rails.new 'localhost:11211'
-    client.flush
-    Cache.config.client = client
   end
     
   include SharedTests
   
   def get_bare_client_id
-    Cache::Storage.instance.bare_client.object_id
+    @cache.storage.send(:bare_client).object_id
   end
   
   def test_treats_as_not_thread_safe
     # make sure bare client is initialized
-    Cache.get 'hi'
+    @cache.get 'hi'
     
     # get the main thread's bare client
     main_thread_bare_client_id = get_bare_client_id
     
     # sanity check that it's not changing every time
-    Cache.get 'hi'
+    @cache.get 'hi'
     assert_equal main_thread_bare_client_id, get_bare_client_id
     
     # create a new thread and get its bare client
-    new_thread_bare_client_id = Thread.new { Cache.get 'hi'; get_bare_client_id }.value
+    new_thread_bare_client_id = Thread.new { @cache.get 'hi'; get_bare_client_id }.value
     
     # make sure the bare client was reinitialized
     assert(main_thread_bare_client_id != new_thread_bare_client_id)
@@ -36,18 +34,18 @@ class TestMemcachedRailsStorage < Test::Unit::TestCase
   
   def test_treats_as_not_fork_safe
     # make sure bare client is initialized
-    Cache.get 'hi'
+    @cache.get 'hi'
     
     # get the main process's bare client
     parent_process_bare_client_id = get_bare_client_id
     
     # sanity check that it's not changing every time
-    Cache.get 'hi'
+    @cache.get 'hi'
     assert_equal parent_process_bare_client_id, get_bare_client_id
     
     # fork a new process
     pid = Kernel.fork do
-      Cache.get 'hi'
+      @cache.get 'hi'
       raise "Didn't split!" if parent_process_bare_client_id == get_bare_client_id
     end
     Process.wait pid

data/test/test_memcached_storage.rb

@@ -4,31 +4,29 @@ require 'memcached'
 
 class TestMemcachedStorage < Test::Unit::TestCase
   def setup
+    @client = Memcached.new 'localhost:11211'
     super
-    client = Memcached.new 'localhost:11211'
-    client.flush
-    Cache.config.client = client
   end
     
   include SharedTests
   
   def get_bare_client_id
-    Cache::Storage.instance.bare_client.object_id
+    @cache.storage.send(:bare_client).object_id
   end
   
   def test_treats_as_not_thread_safe
     # make sure bare client is initialized
-    Cache.get 'hi'
+    @cache.get 'hi'
     
     # get the main thread's bare client
     main_thread_bare_client_id = get_bare_client_id
     
     # sanity check that it's not changing every time
-    Cache.get 'hi'
+    @cache.get 'hi'
     assert_equal main_thread_bare_client_id, get_bare_client_id
     
     # create a new thread and get its bare client
-    new_thread_bare_client_id = Thread.new { Cache.get 'hi'; get_bare_client_id }.value
+    new_thread_bare_client_id = Thread.new { @cache.get 'hi'; get_bare_client_id }.value
     
     # make sure the bare client was reinitialized
     assert(main_thread_bare_client_id != new_thread_bare_client_id)
@@ -36,18 +34,18 @@ class TestMemcachedStorage < Test::Unit::TestCase
   
   def test_treats_as_not_fork_safe
     # make sure bare client is initialized
-    Cache.get 'hi'
+    @cache.get 'hi'
     
     # get the main process's bare client
     parent_process_bare_client_id = get_bare_client_id
     
     # sanity check that it's not changing every time
-    Cache.get 'hi'
+    @cache.get 'hi'
     assert_equal parent_process_bare_client_id, get_bare_client_id
     
     # fork a new process
     pid = Kernel.fork do
-      Cache.get 'hi'
+      @cache.get 'hi'
       raise "Didn't split!" if parent_process_bare_client_id == get_bare_client_id
     end
     Process.wait pid

data/test/test_redis_storage.rb

@@ -6,18 +6,16 @@ if ENV['REDIS_URL']
 
   class TestRedisStorage < Test::Unit::TestCase
     def setup
-      super
       uri = URI.parse(ENV["REDIS_URL"])
-      client = Redis.new(:host => uri.host, :port => uri.port, :password => uri.password)
-      client.flushdb
-      Cache.config.client = client
+      @client = Redis.new(:host => uri.host, :port => uri.port, :password => uri.password)
+      super
     end
     
     include SharedTests
     
     # client DOT client
     def get_redis_client_connection_socket_id
-      connection = Cache.config.client.client.instance_variable_get :@connection
+      connection = @cache.config.client.client.instance_variable_get :@connection
       sock = connection.instance_variable_get(:@sock)
       # $stderr.puts sock.inspect
       sock.object_id
@@ -25,17 +23,17 @@ if ENV['REDIS_URL']
     
     def test_treats_as_thread_safe
       # make sure ring is initialized
-      Cache.get 'hi'
+      @cache.get 'hi'
 
       # get the main thread's ring
       main_thread_redis_client_connection_socket_id = get_redis_client_connection_socket_id
 
       # sanity check that it's not changing every time
-      Cache.get 'hi'
+      @cache.get 'hi'
       assert_equal main_thread_redis_client_connection_socket_id, get_redis_client_connection_socket_id
 
       # create a new thread and get its ring
-      new_thread_redis_client_connection_socket_id = Thread.new { Cache.get 'hi'; get_redis_client_connection_socket_id }.value
+      new_thread_redis_client_connection_socket_id = Thread.new { @cache.get 'hi'; get_redis_client_connection_socket_id }.value
 
       # make sure the ring was reinitialized
       assert_equal main_thread_redis_client_connection_socket_id, new_thread_redis_client_connection_socket_id
@@ -43,18 +41,18 @@ if ENV['REDIS_URL']
 
     def test_treats_as_not_fork_safe
       # make sure ring is initialized
-      Cache.get 'hi'
+      @cache.get 'hi'
 
       # get the main thread's ring
       parent_process_redis_client_connection_socket_id = get_redis_client_connection_socket_id
 
       # sanity check that it's not changing every time
-      Cache.get 'hi'
+      @cache.get 'hi'
       assert_equal parent_process_redis_client_connection_socket_id, get_redis_client_connection_socket_id
 
       # fork a new process
       pid = Kernel.fork do
-        Cache.get 'hi'
+        @cache.get 'hi'
         raise "Didn't split!" if parent_process_redis_client_connection_socket_id == get_redis_client_connection_socket_id
       end
       Process.wait pid

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cache
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Seamus Abshere