lawnchair 0.4.0 → 0.5.0

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.5.0

data/lawnchair.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{lawnchair}
-  s.version = "0.4.0"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Shane Wolf"]
-  s.date = %q{2010-02-11}
+  s.date = %q{2010-02-12}
   s.description = %q{Very simple caching mechanism for arbitrary pieces of resoucre ruby code using Redis as the distributed (or local) cache}
   s.email = %q{shanewolf@gmail.com}
   s.extra_rdoc_files = [
@@ -24,11 +24,20 @@ Gem::Specification.new do |s|
      "VERSION",
      "lawnchair.gemspec",
      "lib/lawnchair.rb",
+     "lib/storage_engine/abstract.rb",
+     "lib/storage_engine/composite.rb",
+     "lib/storage_engine/in_process.rb",
+     "lib/storage_engine/redis.rb",
+     "lib/view/helper.rb",
      "spec/lawnchair_spec.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
      "spec/speed.rb",
-     "spec/speed_results.png"
+     "spec/speed_results.png",
+     "spec/storage_engine/abstract_spec.rb",
+     "spec/storage_engine/composite_spec.rb",
+     "spec/storage_engine/in_process_spec.rb",
+     "spec/storage_engine/redis_spec.rb"
   ]
   s.homepage = %q{http://github.com/gizm0duck/lawnchair}
   s.rdoc_options = ["--charset=UTF-8"]
@@ -38,7 +47,11 @@ Gem::Specification.new do |s|
   s.test_files = [
     "spec/lawnchair_spec.rb",
      "spec/spec_helper.rb",
-     "spec/speed.rb"
+     "spec/speed.rb",
+     "spec/storage_engine/abstract_spec.rb",
+     "spec/storage_engine/composite_spec.rb",
+     "spec/storage_engine/in_process_spec.rb",
+     "spec/storage_engine/redis_spec.rb"
   ]
 
   if s.respond_to? :specification_version then

data/lib/lawnchair.rb

@@ -1,72 +1,34 @@
-require 'rubygems'
-require 'redis'
+Dir[File.dirname(__FILE__) + '/storage_engine/*.rb'].each {|file| require file }
+require 'view/helper'
 
 module Lawnchair
-  
-  class << self
-    attr_reader :redis
-    
-    def connectdb(redis=nil)
-      @redis ||= Redis.new(:db => 11)
-    end
-
-    def flushdb
-      redis.flushdb
-    end
-  end
-  
   class Cache
-    @@in_process_store = {}
-    
-    def self.in_process_store
-      @@in_process_store
-    end
-    
-    def self.me(options = {}, &block)
-      raise "Cache key please!" unless options.has_key?(:key)
-      
+    def self.me(key, options={}, &block)
       if options[:in_process]
-        key_exists = @@in_process_store.has_key?([compute_key(options[:key])])
+        store = initialize_composite_store
       else
-        key_exists = exists?(options[:key])
+        store = Lawnchair::StorageEngine::Redis
       end
-        
-      if key_exists && !options[:force]
-        if options[:in_process]
-          Marshal.load(@@in_process_store[compute_key(options[:key])])
-        else
-          Marshal.load(Lawnchair.redis[compute_key(options[:key])])
-        end
-      else
-        if options[:in_process] && exists?(options[:key])
-          cached_val = Lawnchair.redis[compute_key(options[:key])]
-          @@in_process_store[compute_key(options[:key])] = cached_val
-          return Marshal.dump(cached_val)
-        end
-        
-        val = block.call
-        expires_in = compute_expiry(options[:expires_in])
-        dumped_val = Marshal.dump(val)        
-        @@in_process_store[compute_key(options[:key])] = dumped_val if options[:in_process]
-        Lawnchair.redis.set(compute_key(options[:key]), dumped_val, expires_in)
-        return val
-      end
-    end
-    
-    def self.compute_key(key)
-      "Lawnchair:#{key}"
+      store.fetch(key, options, &block)
     end
     
-    def self.expire(key)
-      Lawnchair.redis.del(compute_key(key))
+    def self.initialize_composite_store
+      composite_store = Lawnchair::StorageEngine::Composite.new
+      composite_store.register_storage_engine(Lawnchair::StorageEngine::InProcess)
+      composite_store.register_storage_engine(Lawnchair::StorageEngine::Redis)
+      composite_store
     end
-    
-    def self.exists?(key)
-      return Lawnchair.redis.exists(compute_key(key))
+  end
+  
+  class << self
+    attr_reader :redis
+
+    def connectdb(redis=nil)
+      @redis = (redis || Redis.new(:db => 11))
     end
-    
-    def self.compute_expiry(seconds)
-      seconds || 3600
+
+    def flushdb
+      redis.flushdb
     end
   end
 end

data/lib/storage_engine/abstract.rb

@@ -0,0 +1,37 @@
+module Lawnchair
+  module StorageEngine
+    class Abstract
+      class << self
+        attr_reader :cache_container
+        
+        def cache_container
+          @cache_container ||= {}
+        end
+      
+        def fetch(key, options, &block)
+          if exists?(key)
+            value = get(key, options)
+          else
+            value = block.call
+            set(key, value, options)
+          end
+          value
+        end
+      
+        def get(key, options={})
+          if options[:raw]
+            cache_container[computed_key(key)]
+          else
+            exists?(key) ? Marshal.load(cache_container[computed_key(key)]) : nil
+          end
+        end
+      
+        def computed_key(key)
+          raise "Missiing key" if key.nil? || key.empty?
+          prefix = "Lawnchair"
+          "#{prefix}:#{key}"
+        end
+      end
+    end
+  end
+end

data/lib/storage_engine/composite.rb

@@ -0,0 +1,45 @@
+module Lawnchair
+  module StorageEngine
+    class Composite
+      attr_reader :storage_engines
+    
+      def initialize
+        @storage_engines = []
+      end
+      
+      def register_storage_engine(storage_engine)
+        storage_engines << storage_engine
+      end
+    
+      def fetch(key, options, &block)
+        raise "No Storage Engines Configured" if storage_engines.empty?
+        
+        value, index = find_in_storage(key, options)
+        value ||= yield
+        place_in_storage(key, value, options, index)
+      end
+      
+      private 
+      
+      def find_in_storage(key, options)
+        value, index = nil, nil
+        storage_engines.each_with_index do |storage_engine, i|
+          if storage_engine.exists?(key)
+            value = storage_engine.get(key, options)
+            index = i
+            break
+          end
+        end
+        return value, index
+      end
+      
+      def place_in_storage(key, value, options, index)
+        storage_engines.each_with_index do |storage_engine, i|
+          break if i == index
+          storage_engine.set(key, value, options)
+        end
+        value
+      end
+    end
+  end
+end

data/lib/storage_engine/in_process.rb

@@ -0,0 +1,29 @@
+module Lawnchair
+  module StorageEngine
+    class InProcess < Abstract
+      @@cache_container = {}
+      class << self
+    
+        def cache_container
+          @@cache_container
+        end
+    
+        def set(key, value, options={})
+          if options[:raw]
+            cache_container[computed_key(key)] = value
+          else
+            cache_container[computed_key(key)] = Marshal.dump(value)
+          end
+        end
+
+        def exists?(key)
+          cache_container.has_key?(computed_key(key))
+        end
+  
+        def expire!(key)
+          cache_container.delete(computed_key(key))
+        end
+      end
+    end
+  end
+end

data/lib/storage_engine/redis.rb

@@ -0,0 +1,28 @@
+module Lawnchair
+  module StorageEngine
+    class Redis < Abstract
+      class << self
+        def cache_container
+          Lawnchair.redis
+        end
+    
+        def set(key, value, options={})
+          ttl = options[:expires_in] || 3600
+          if options[:raw]
+            cache_container.set(computed_key(key), value, ttl)
+          else
+            cache_container.set(computed_key(key), Marshal.dump(value), ttl)
+          end
+        end
+  
+        def exists?(key)
+          cache_container.exists(computed_key(key))
+        end
+  
+        def expire!(key)
+          cache_container.del(computed_key(key))
+        end
+      end
+    end
+  end
+end

data/lib/view/helper.rb

@@ -0,0 +1,15 @@
+require 'action_view'
+module Lawnchair
+  module View
+    module Helper
+      def lawnchair_cache(key, &block)
+        rendered_value = Lawnchair::Cache.me({:key => key, :raw => true}) do
+          capture(&block)
+        end
+        concat(rendered_value)
+      end
+    end
+  end
+end
+
+ActionView::Base.send(:include, Lawnchair::View::Helper)

data/spec/lawnchair_spec.rb

@@ -2,94 +2,29 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "Lawnchair::Cache" do
   describe ".me" do
-    it "raises an exception if no key is given" do
-      lambda do
-        Lawnchair::Cache.me { 1 }
-      end.should raise_error("Cache key please!")
-    end
-    
     it "returns the value if it exists" do
       expected_object = [1,2,3,4]
-      Lawnchair::Cache.me(:key => "marshalled_array") { expected_object }
+      Lawnchair::Cache.me("marshalled_array") { expected_object }
       
-      x = Lawnchair::Cache.me(:key => "marshalled_array") { "JUNK DATA" }
+      x = Lawnchair::Cache.me("marshalled_array") { "JUNK DATA" }
       x.should == expected_object
     end
     
     it "marshalls the object into redis" do
       expected_object = [1,2,3,4]
-      Lawnchair::Cache.me(:key => "marshalled_array") { expected_object }
+      Lawnchair::Cache.me("marshalled_array") { expected_object }
       
       Marshal.load(Lawnchair.redis["Lawnchair:marshalled_array"]).should == [1,2,3,4]
     end
     
-    describe "when passed :force => true" do
-      it "expires the key and sets it to the new return value" do
-        initial_expected_object = [1,2,3,4]
-        new_expected_object     = [1,2,3]
-        Lawnchair::Cache.me(:key => "marshalled_array") { initial_expected_object }
-        Marshal.load(Lawnchair.redis["Lawnchair:marshalled_array"]).should == [1,2,3,4]
-        
-        Lawnchair::Cache.me(:key => "marshalled_array", :force => true) { new_expected_object }
-        Marshal.load(Lawnchair.redis["Lawnchair:marshalled_array"]).should == [1,2,3]
-      end
-    end
-    
     describe "when in_process => true" do
-      describe "when the value does not exist in redis" do
-        it "should set the value to the key in process as well as in redis" do
-          expected_object = [1,2,3,4]
-          Lawnchair::Cache.me(:key => "marshalled_array", :in_process => true) { expected_object }
-          Marshal.load(Lawnchair.redis["Lawnchair:marshalled_array"]).should == [1,2,3,4]
-          Marshal.load(Lawnchair::Cache.in_process_store["Lawnchair:marshalled_array"]).should == [1,2,3,4]
-        end
-      end
-      
-      describe "when the value exists in redis" do
-        it "takes the value from redis and places it in the in process cache" do
-          Lawnchair::Cache.in_process_store.delete("Lawnchair:marshalled_array")
-          expected_object = [1,2,3,4]
-          unexpected_object = [1,2,3,4,5,6,7,8]
-          Lawnchair::Cache.me(:key => "marshalled_array") { expected_object }
-          Lawnchair::Cache.in_process_store["Lawnchair:marshalled_array"].should be_nil
-          Lawnchair::Cache.me(:key => "marshalled_array", :in_process => true) { unexpected_object }
-          Marshal.load(Lawnchair::Cache.in_process_store["Lawnchair:marshalled_array"]).should == expected_object
-        end
+      it "fetches the value to/from the composite store" do
+        mock_composite_engine = Lawnchair::StorageEngine::Composite.new
+        Lawnchair::StorageEngine::Composite.stub!(:new).and_return(mock_composite_engine)
+        
+        mock_composite_engine.should_receive(:fetch)
+        Lawnchair::Cache.me("mu", :in_process => true, :raw => true) { "fasa" }
       end
     end
-    
-    it "sets a default ttl of 60 minutes" do
-      Lawnchair::Cache.me(:key => "pizza") { "muschroom/onion" }
-      Lawnchair.redis.ttl("Lawnchair:pizza").should == 3600 # seconds
-    end
-    
-    it "allows you to override the default ttl" do
-      Lawnchair::Cache.me(:key => "pizza", :expires_in => 1) { "muschroom/onion" }
-      Lawnchair.redis.ttl("Lawnchair:pizza").should == 1 # seconds
-    end
-  end
-  
-  describe ".exists?" do
-    it "returns false when the key does not exist" do
-      Lawnchair.redis.keys('*').should_not include("Lawnchair:mu")
-      Lawnchair::Cache.exists?("mu").should be_false
-    end
-    
-    it "returns true when the key exists" do
-      Lawnchair.redis["Lawnchair:mu"] = "fasa"
-      Lawnchair.redis.keys('*').should include("Lawnchair:mu")
-      Lawnchair::Cache.exists?("mu").should be_true
-    end
-  end
-  
-  describe ".expire" do
-    it "should only expire the key specified" do
-      Lawnchair.redis["Lawnchair:mu"] = "fasa"
-      Lawnchair.redis["Lawnchair:sim"] = "ba"
-    
-      Lawnchair::Cache.expire("mu")
-      Lawnchair.redis["Lawnchair:mu"].should be_nil
-      Lawnchair.redis["Lawnchair:sim"].should == "ba"
-    end
   end
 end

data/spec/spec_helper.rb

@@ -8,5 +8,12 @@ require 'redis'
 
 Spec::Runner.configure do |config|
   config.before(:all)   { Lawnchair.connectdb(Redis.new(:db => 11)) }
-  config.before(:each)  { Lawnchair.flushdb }
+  config.before(:each)  do 
+    Lawnchair.flushdb
+    abstract_store = Lawnchair::StorageEngine::Abstract
+    abstract_store.cache_container.keys.each {|k| abstract_store.cache_container.delete(k)}
+    
+    in_process = Lawnchair::StorageEngine::InProcess
+    in_process.cache_container.keys.each {|k| in_process.cache_container.delete(k)}
+  end
 end

data/spec/storage_engine/abstract_spec.rb

@@ -0,0 +1,103 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Lawnchair::StorageEngine::Abstract" do
+  attr_reader :abstract_store
+  
+  before do
+    @abstract_store = Lawnchair::StorageEngine::Abstract
+  end
+  
+  describe ".cache_container" do
+    it "should be an empty hash" do
+      abstract_store.cache_container.should == {}
+    end
+  end
+  
+  describe ".fetch" do
+    context "when key exists" do
+      before do
+        abstract_store.stub!(:exists?).and_return(true)
+        abstract_store.cache_container["Lawnchair:sim"] = "ba"
+      end
+      
+      it "returns the value from the cache" do
+        value = abstract_store.fetch("sim", :raw => true) { "DOESNT MATTER" }
+        value.should == "ba"
+      end
+    end
+    
+    context "when key does not exist" do
+      before do
+        abstract_store.stub!(:exists?).and_return(false)
+        abstract_store.cache_container["Lawnchair:sim"].should be_nil
+        
+        class Lawnchair::StorageEngine::Abstract
+          def self.set(key, value, options={})
+            cache_container["Lawnchair:#{key}"] = value
+          end
+        end
+      end
+      
+      it "computes the value and saves it to the cache" do
+        value = abstract_store.fetch("sim", :raw => true) { "ba" }
+        abstract_store.cache_container["Lawnchair:sim"].should == "ba"
+      end
+    end
+  end
+  
+  describe ".get" do
+    context "when raw is true" do
+      it "gets the value in key if it exists" do
+        abstract_store.cache_container["Lawnchair:mu"] = "fasa"
+        abstract_store.get("mu", :raw => true).should == "fasa"
+      end
+      
+      it "returns nil if the key does not exist" do
+        abstract_store.cache_container["mu"].should be_nil
+        abstract_store.get("mu", :raw => true).should be_nil
+      end
+    end
+    
+    context "when raw is false" do
+      context "when they key exists" do
+        before do
+          abstract_store.stub!(:exists?).and_return(true)
+        end
+        
+        it "gets the value in key if it exists and unmarshalls it" do
+          expected_value = "fasa"
+          value = Marshal.dump(expected_value)
+
+          abstract_store.cache_container["Lawnchair:mu"] = value
+          abstract_store.get("mu", :raw => false).should == expected_value
+        end
+      end
+      
+      context "when the key does not exist" do
+        before do
+          abstract_store.stub!(:exists?).and_return(false)
+        end
+        
+        it "returns nil if the key does not exist" do
+          abstract_store.cache_container["Lawnchair:mu"].should be_nil
+          abstract_store.get("mu", :raw => false).should be_nil
+        end
+      end
+    end
+  end
+  
+  describe ".computed_key" do
+    it "should prepend keys with Lawnchair:" do
+      abstract_store.computed_key("hooo").should == "Lawnchair:hooo"
+    end
+    it "raises an exception if no key is given" do
+      lambda do
+        abstract_store.computed_key("") { 1 }
+      end.should raise_error
+      
+      lambda do
+        abstract_store.computed_key(nil)
+      end.should raise_error
+    end
+  end
+end

data/spec/storage_engine/composite_spec.rb

@@ -0,0 +1,108 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Lawnchair::StorageEngine::Composite" do
+  attr_reader :composite_store
+  
+  before do
+    @composite_store = Lawnchair::StorageEngine::Composite.new
+  end
+  
+  describe "initialization" do
+    it "has a collection of storage_engines" do
+      composite_store.storage_engines == []
+    end
+  end
+  
+  describe "#register_storage_engine" do
+    before do
+      composite_store.storage_engines.should be_empty
+    end
+    
+    it "adds a storage engine to the collection" do
+      composite_store.register_storage_engine Lawnchair::StorageEngine::Redis
+      composite_store.storage_engines.should == [Lawnchair::StorageEngine::Redis]
+    end
+  end
+  
+  describe "#fetch" do
+    context "when no storage engines have been configured" do
+      it "raises an exception" do
+        lambda do
+          composite_store.fetch("key", {}) {x=1}
+        end.should raise_error("No Storage Engines Configured")
+      end
+    end
+    
+    context "when there is only 1 storage engine" do
+      before do
+        composite_store.register_storage_engine Lawnchair::StorageEngine::Redis
+      end
+      
+      context "when the key does not exist" do
+        it "sets the value on the key in the storage engine specified" do
+          Lawnchair.redis["Lawnchair:mu"].should be_nil
+          composite_store.fetch("mu", {:raw => true}) { "fasa" }
+          Lawnchair.redis["Lawnchair:mu"].should == "fasa"
+        end
+      end
+      
+      context "when the key exists" do
+        before do
+          Lawnchair.redis["Lawnchair:sim"] = "ba"
+        end
+        
+        it "returns the value in the key from the storage engine specified" do
+          value = composite_store.fetch("sim", {:raw => true}) { "DOESNT MATTER" }
+          value.should == "ba"
+        end
+      end
+    end
+    
+    context "when there are two storage engines" do
+      before do
+        composite_store.register_storage_engine Lawnchair::StorageEngine::InProcess
+        composite_store.register_storage_engine Lawnchair::StorageEngine::Redis
+      end
+      
+      context "when the key exists in the first storage engine" do
+        before do
+          Lawnchair::StorageEngine::InProcess.set("mu", "fasa", :raw => true)
+          Lawnchair::StorageEngine::Redis.get("mu").should be_nil
+        end
+        
+        it "returns the value from the first storage engine" do
+          value = composite_store.fetch("mu", {:raw => true}) { "DOESNT MATTER" }
+          value.should == "fasa"
+        end
+      end
+      
+      context "when the key exists in the second storage engine but not the first" do
+        before do
+          Lawnchair::StorageEngine::InProcess.get("mu").should be_nil
+          Lawnchair::StorageEngine::Redis.set("mu", "fasa", :raw => true)
+        end
+        
+        it "places the value in the first storage engine" do
+          composite_store.fetch("mu", {:raw => true}) { "DOESNT MATTER" }.should == "fasa"
+          Lawnchair::StorageEngine::InProcess.get("mu", :raw => true).should == "fasa"
+        end
+      end
+      
+      context "when the key doesnt exist in either storage engine" do
+        before do
+          Lawnchair::StorageEngine::InProcess.get("mu").should be_nil
+          Lawnchair::StorageEngine::Redis.get("mu").should be_nil
+        end
+        
+        it "sets the value in both storage engines" do
+          composite_store.fetch("mu", {:raw => true}) { sleep 0.2; "fasa" }
+          Lawnchair::StorageEngine::InProcess.get("mu", :raw => true).should == "fasa"
+          Lawnchair::StorageEngine::Redis.get("mu", :raw => true).should == "fasa"
+        end
+        
+        it "only calls the block 1 time for both engines" # spec should take less than .4 seconds to run
+      end
+    end
+  end
+  
+end

data/spec/storage_engine/in_process_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Lawnchair::StorageEngine::InProcessStore" do
+  attr_reader :in_process_store
+  
+  before do
+    @in_process_store = Lawnchair::StorageEngine::InProcess
+  end
+
+  describe "#cache_container" do
+    it "returns the redis cache object" do
+      Lawnchair::StorageEngine::InProcess.send(:class_variable_set, "@@cache_container", {"Lawnchair:mu" => "fasa"})
+      in_process_store.cache_container["Lawnchair:mu"].should == "fasa"
+    end
+  end
+  
+  describe "#set" do
+    context "when raw is true" do  
+      it "sets the value" do
+        in_process_store.cache_container["Lawnchair:mu"].should be_nil
+        in_process_store.set("mu", "fasa", :raw => true)
+        in_process_store.cache_container["Lawnchair:mu"].should == "fasa"
+      end
+    end
+    
+    context "when raw is false" do
+      it "sets the value" do
+        value = "fasa"
+        expected_value = Marshal.dump(value)
+        
+        in_process_store.cache_container["Lawnchair:mu"].should be_nil
+        in_process_store.set("mu", value, :raw => false)
+        in_process_store.cache_container["Lawnchair:mu"].should == expected_value
+      end
+    end
+  end
+  
+  describe "exists?" do
+    it "returns false when the key does not exist" do
+      in_process_store.cache_container.keys.should_not include("Lawnchair:mu")
+      in_process_store.exists?("mu").should be_false
+    end
+
+    it "returns true when the key exists" do
+      in_process_store.cache_container["Lawnchair:mu"] = "fasa"
+      in_process_store.cache_container.keys.should include("Lawnchair:mu")
+      in_process_store.exists?("mu").should be_true
+    end
+  end
+  
+  describe "#expire!" do
+    it "should only expire the key specified" do
+      in_process_store.cache_container["Lawnchair:mu"] = "fasa"
+      in_process_store.cache_container["Lawnchair:sim"] = "ba"
+
+      in_process_store.expire!("mu")
+      in_process_store.cache_container["Lawnchair:mu"].should be_nil
+      in_process_store.cache_container["Lawnchair:sim"].should == "ba"
+    end
+  end
+end

data/spec/storage_engine/redis_spec.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Lawnchair::StorageEngine::RedisStore" do
+  attr_reader :redis_store
+  
+  before do
+    @redis_store = Lawnchair::StorageEngine::Redis
+  end
+  
+  describe "#cache_container" do
+    it "returns the redis cache object" do
+      Lawnchair.redis["Lawnchair:mu"] = "fasa"
+      redis_store.cache_container["Lawnchair:mu"].should == "fasa"
+    end
+  end
+  
+  describe "#set" do    
+    it "sets a default ttl of 60 minutes" do
+      redis_store.set("mu", "fasa")
+      Lawnchair.redis.ttl("Lawnchair:mu").should == 3600 # seconds
+    end
+
+    it "allows you to override the default ttl" do
+      redis_store.set("mu", "fasa", :expires_in => 600)
+
+      Lawnchair.redis.ttl("Lawnchair:mu").should == 600 # seconds
+    end
+    
+    context "when raw is true" do  
+      it "sets the value in redis" do
+        Lawnchair.redis["Lawnchair:mu"].should be_nil
+        redis_store.set("mu", "fasa", :raw => true)
+        Lawnchair.redis["Lawnchair:mu"].should == "fasa"
+      end
+    end
+    
+    context "when raw is false" do
+      it "sets the value in redis" do
+        value = "fasa"
+        expected_value = Marshal.dump(value)
+        
+        Lawnchair.redis["Lawnchair:mu"].should be_nil
+        redis_store.set("mu", value, :raw => false)
+        Lawnchair.redis["Lawnchair:mu"].should == expected_value
+      end
+    end
+  end
+  
+  describe "exists?" do
+    it "returns false when the key does not exist" do
+      Lawnchair.redis.keys('*').should_not include("Lawnchair:mu")
+      redis_store.exists?("mu").should be_false
+    end
+
+    it "returns true when the key exists" do
+      Lawnchair.redis["Lawnchair:mu"] = "fasa"
+      Lawnchair.redis.keys('*').should include("Lawnchair:mu")
+      redis_store.exists?("mu").should be_true
+    end
+  end
+  
+  describe "#expire!" do
+    it "should only expire the key specified" do
+      Lawnchair.redis["Lawnchair:mu"] = "fasa"
+      Lawnchair.redis["Lawnchair:sim"] = "ba"
+
+      redis_store.expire!("mu")
+      Lawnchair.redis["Lawnchair:mu"].should be_nil
+      Lawnchair.redis["Lawnchair:sim"].should == "ba"
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: lawnchair
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Shane Wolf
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-11 00:00:00 -08:00
+date: 2010-02-12 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -30,11 +30,20 @@ files:
 - VERSION
 - lawnchair.gemspec
 - lib/lawnchair.rb
+- lib/storage_engine/abstract.rb
+- lib/storage_engine/composite.rb
+- lib/storage_engine/in_process.rb
+- lib/storage_engine/redis.rb
+- lib/view/helper.rb
 - spec/lawnchair_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 - spec/speed.rb
 - spec/speed_results.png
+- spec/storage_engine/abstract_spec.rb
+- spec/storage_engine/composite_spec.rb
+- spec/storage_engine/in_process_spec.rb
+- spec/storage_engine/redis_spec.rb
 has_rdoc: true
 homepage: http://github.com/gizm0duck/lawnchair
 licenses: []
@@ -67,3 +76,7 @@ test_files:
 - spec/lawnchair_spec.rb
 - spec/spec_helper.rb
 - spec/speed.rb
+- spec/storage_engine/abstract_spec.rb
+- spec/storage_engine/composite_spec.rb
+- spec/storage_engine/in_process_spec.rb
+- spec/storage_engine/redis_spec.rb