lawnchair 0.5.1 → 0.5.2

data/README.rdoc

@@ -1,11 +1,8 @@
 = Lawnchair
 
-Very simple caching mechanism for arbitrary pieces of ruby code using Redis as the distributed (or local) cache
+Fully featured caching mechanism for arbitrary pieces of resource expensive ruby code using Redis while being able to optionally store data in the Ruby process itself for maximum efficiency.
 
-== Prerequisites
-  git clone git://github.com/ezmobius/redis-rb.git
-  cd redis-rb
-  rake redis:install
+Lawnchair includes a Rails view helper that can be used to cache the rendered view code, but other than that everything should work fine in a Merb, Sinatra, or plain old Ruby app.
 
 == Installation
 
@@ -27,7 +24,7 @@ This will connect to a default database on localhost, if you want to connect to
 
 Obligatory example:
   
-  Lawnchair::Cache.me(:key => "contrived_example") do
+  Lawnchair::Cache.me("cache_key2") do
     # ideally this would be something a little more computationally expensive, but sleep will have to do
     (1..3).inject([]) do
       |set, i| set << Time.now.strftime("%H:%M:%S")
@@ -40,32 +37,55 @@ The return value is exactly what you think it should be
 
   ["12:26:08", "12:26:09", "12:26:10"]
 
-Now, since it is cached, any time this block method is called (for the next 60 minute) it will return those values.  also, you will note it comes back instantly, instead of waiting on those sleeps.
+Now, since it is cached, any time this block method is called (for the next 60 minutes) it will return those values.  also, you will note it comes back instantly, instead of waiting on those sleeps.
 
 If an hour is too long, or short for the cache key expiration you can set that to anything you want using the :expires_in hash key and entering a time in seconds
 
-  Lawnchair::Cache.me(:key => "contrived_example", :expires_in => 1.day) do
+  Lawnchair::Cache.me("cache_key", :expires_in => 1.day) do
     # expensive code to be cached for 24 hours
   end
   
+Available options:
+* :expires_in - takes a time in seconds and will be set as the ttl on the key (only works for Redis store) 
+* :raw - tells the cache not to marshall the data, if you are storing a string value, this is the way to go
+* :in_process - stores the value in memory for as long as the ruby process is running as well as in redis
+  
 == In Process Caching
 
 If you want to get really fancy you can cache the values in process as well as in Redis.  This can be a fairly significant win
 if you are running the Redis server on a different physical machine as all network latency is taken out of the equation, especially if you are hitting a cache key many times on the same request.  Also, it's probably best not to store TONS of keys in there, as your ruby process can bloat fairly quickly if you put everything in there.  Also, these will persist as long as the process is running, unless you manually expire it.
 
-  Lawnchair::Cache.me(:key => "contrived_example", :in_process => true) do
+  Lawnchair::Cache.me("cache_key3", :in_process => true) do
     # expensive code to be cached in process AND in redis
   end
   
 This code will get cached in redis as well, so each different process that runs the expensive code in the block will get the value from redis, instead of having to run it to get the value.
 
-== Odds and Ends
+== Accessing DataStores Directly
+
+There are currently two different storage engines (Redis and InProcess) that you can use either together or independently, depending on your needs.  If you want to just store something in process for example you can do
+
+  Lawnchair::StorageEngine::InProcess.fetch("cache_key4", :raw => true) do
+    # expensive code to be cached in process
+  end
+
+Also, you can expire a key for a given storage engine directly by calling
+
+  Lawnchair::StorageEngine::InProcess.expire!("cache_key3") # For memory store
+or
+  Lawnchair::StorageEngine::Redis.expire!("cache_key3") # For redis store
 
-If you need to manually expire a key just call:
+You can also access any of the methods for a given datastore directly, and choose to expire a key in whatever store you want.
 
-  Lawnchair::Cache.expire("contrived_example")
+Available methods are:
+* get - get a value for a key
+* set - set a value for a key regardless of whether or not it exists
+* fetch - get a value if it exists for a given key, otherwise set it
+* expire! - forcefully expire a key
+* exists? - check if a given key exists
+* data_store - access the datastore's values directly like a hash
 
-If you need to flush all the values in the database
+If you need to flush all the values in the Redis database
 
   Lawnchair.flushdb
 

data/Rakefile

@@ -5,11 +5,12 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "lawnchair"
-    gem.summary = "Enclose resource expensive Ruby code in a block and cache it in redis"
-    gem.description = "Very simple caching mechanism for arbitrary pieces of resoucre ruby code using Redis as the distributed (or local) cache"
+    gem.summary = "Speed up your app by caching expensive code in Redis or in the ruby process itself"
+    gem.description = "Fully featured caching mechanism for arbitrary pieces of resource expensive ruby code using Redis while being able to optionally store data in the Ruby process itself for maximum efficiency."
     gem.email = "shanewolf@gmail.com"
     gem.homepage = "http://github.com/gizm0duck/lawnchair"
     gem.authors = ["Shane Wolf"]
+    gem.add_dependency "redis"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.5.1
+0.5.2

data/lawnchair.gemspec

@@ -5,12 +5,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{lawnchair}
-  s.version = "0.5.1"
+  s.version = "0.5.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Shane Wolf"]
-  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.date = %q{2010-02-14}
+  s.description = %q{Fully featured caching mechanism for arbitrary pieces of resource expensive ruby code using Redis while being able to optionally store data in the Ruby process itself for maximum efficiency.}
   s.email = %q{shanewolf@gmail.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -24,6 +24,7 @@ Gem::Specification.new do |s|
      "VERSION",
      "lawnchair.gemspec",
      "lib/lawnchair.rb",
+     "lib/marshal_extension.rb",
      "lib/storage_engine/abstract.rb",
      "lib/storage_engine/composite.rb",
      "lib/storage_engine/in_process.rb",
@@ -43,7 +44,7 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubygems_version = %q{1.3.5}
-  s.summary = %q{Enclose resource expensive Ruby code in a block and cache it in redis}
+  s.summary = %q{Speed up your app by caching expensive code in Redis or in the ruby process itself}
   s.test_files = [
     "spec/lawnchair_spec.rb",
      "spec/spec_helper.rb",
@@ -59,9 +60,12 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<redis>, [">= 0"])
     else
+      s.add_dependency(%q<redis>, [">= 0"])
     end
   else
+    s.add_dependency(%q<redis>, [">= 0"])
   end
 end
 

data/lib/lawnchair.rb

@@ -1,24 +1,25 @@
-Dir[File.dirname(__FILE__) + '/storage_engine/*.rb'].each {|file| require file }
+require 'rubygems'
 require 'redis'
-require 'view/helper'
+require 'storage_engine/abstract'
+require 'storage_engine/redis'
+require 'storage_engine/in_process'
+require 'storage_engine/composite'
+
+if defined? RAILS_ENV
+  require 'marshal_extension' if RAILS_ENV == "development"
+  require 'view/helper'
+end
 
 module Lawnchair
   class Cache
     def self.me(key, options={}, &block)
       if options[:in_process]
-        store = initialize_composite_store
+        store = Lawnchair::StorageEngine::Composite.new(:in_process, :redis)
       else
         store = Lawnchair::StorageEngine::Redis
       end
       store.fetch(key, options, &block)
     end
-    
-    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
   end
   
   class << self

data/lib/marshal_extension.rb

@@ -0,0 +1,19 @@
+# Shamelessly swiped from: http://pastie.org/720905
+# Initial implementation from: http://kballcodes.com/2009/09/05/rails-memcached-a-better-solution-to-the-undefined-classmodule-problem/
+class << Marshal
+  def load_with_rails_classloader(*args)
+    begin
+      load_without_rails_classloader(*args)
+    rescue ArgumentError, NameError => e
+      if e.message =~ %r(undefined class/module)
+        const = e.message.split(' ').last
+        const.constantize
+        retry
+      else
+        raise(e)
+      end
+    end
+  end
+
+  alias_method_chain :load, :rails_classloader
+end

data/lib/storage_engine/abstract.rb

@@ -2,10 +2,10 @@ module Lawnchair
   module StorageEngine
     class Abstract
       class << self
-        attr_reader :cache_container
+        attr_reader :data_store
         
-        def cache_container
-          @cache_container ||= {}
+        def data_store
+          @data_store ||= {}
         end
       
         def fetch(key, options, &block)
@@ -20,9 +20,9 @@ module Lawnchair
       
         def get(key, options={})
           if options[:raw]
-            cache_container[computed_key(key)]
+            data_store[computed_key(key)]
           else
-            exists?(key) ? Marshal.load(cache_container[computed_key(key)]) : nil
+            exists?(key) ? Marshal.load(data_store[computed_key(key)]) : nil
           end
         end
       

data/lib/storage_engine/composite.rb

@@ -3,12 +3,16 @@ module Lawnchair
     class Composite
       attr_reader :storage_engines
     
-      def initialize
+      def initialize(*args)
         @storage_engines = []
+        args.each do |arg|
+          register_storage_engine arg
+        end
       end
       
       def register_storage_engine(storage_engine)
-        storage_engines << storage_engine
+        klass = storage_engine == :redis ? "Redis" : "InProcess"
+        storage_engines << Object.module_eval("Lawnchair::StorageEngine::#{klass}")
       end
     
       def fetch(key, options, &block)
@@ -19,7 +23,7 @@ module Lawnchair
         place_in_storage(key, value, options, index)
       end
       
-      private 
+      private
       
       def find_in_storage(key, options)
         value, index = nil, nil

data/lib/storage_engine/in_process.rb

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

data/lib/storage_engine/redis.rb

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

data/lib/view/helper.rb

@@ -3,7 +3,7 @@ module Lawnchair
   module View
     module Helper
       def lawnchair_cache(key, &block)
-        rendered_value = Lawnchair::Cache.me({:key => key, :raw => true}) do
+        rendered_value = Lawnchair::Cache.me(key, :raw => true) do
           capture(&block)
         end
         concat(rendered_value)

data/spec/spec_helper.rb

@@ -1,19 +1,17 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'rubygems'
 require 'lawnchair'
 require 'spec'
 require 'spec/autorun'
-require 'redis'
 
 Spec::Runner.configure do |config|
   config.before(:all)   { Lawnchair.connectdb(Redis.new(:db => 11)) }
   config.before(:each)  do 
     Lawnchair.flushdb
     abstract_store = Lawnchair::StorageEngine::Abstract
-    abstract_store.cache_container.keys.each {|k| abstract_store.cache_container.delete(k)}
+    abstract_store.data_store.keys.each {|k| abstract_store.data_store.delete(k)}
     
     in_process = Lawnchair::StorageEngine::InProcess
-    in_process.cache_container.keys.each {|k| in_process.cache_container.delete(k)}
+    in_process.data_store.keys.each {|k| in_process.data_store.delete(k)}
   end
 end

data/spec/speed.rb

@@ -8,10 +8,10 @@ Lawnchair.flushdb
 # reading and marshalling the data isn't obscene
 
 # *** Performing 1000 iterations ***
-#              user       system        total        real
-# cached:     0.140000    0.040000    0.180000    ( 0.292324)
-# not cached: 26.070000   0.620000    26.690000   ( 27.156388)
-
+#                       user     system      total        real
+# cached:             0.200000   0.050000   0.250000 (  0.397476)
+# in process cached:  0.090000   0.010000   0.100000 (  0.088927)
+# not cached:         26.710000   0.580000  27.290000 ( 27.331749)
 n = (ARGV.shift || 1000).to_i
 
 puts "*** Performing #{n} iterations ***"
@@ -26,7 +26,7 @@ end
 Benchmark.bm(7) do |x|
   x.report("cached:\t\t") do
     (1..n).each do |i|
-      Lawnchair::Cache.me(:key => "redis_cache") do
+      Lawnchair::Cache.me("redis_cache") do
         expensive_stuff
       end
     end
@@ -34,7 +34,7 @@ Benchmark.bm(7) do |x|
   
   x.report("in process cached:") do
     (1..n).each do |i|
-      Lawnchair::Cache.me(:key => "in_process_cache") do
+      Lawnchair::Cache.me("in_process_cache", :in_process => true) do
         expensive_stuff
       end
     end

data/spec/storage_engine/abstract_spec.rb

@@ -7,9 +7,9 @@ describe "Lawnchair::StorageEngine::Abstract" do
     @abstract_store = Lawnchair::StorageEngine::Abstract
   end
   
-  describe ".cache_container" do
+  describe ".data_store" do
     it "should be an empty hash" do
-      abstract_store.cache_container.should == {}
+      abstract_store.data_store.should == {}
     end
   end
   
@@ -17,7 +17,7 @@ describe "Lawnchair::StorageEngine::Abstract" do
     context "when key exists" do
       before do
         abstract_store.stub!(:exists?).and_return(true)
-        abstract_store.cache_container["Lawnchair:sim"] = "ba"
+        abstract_store.data_store["Lawnchair:sim"] = "ba"
       end
       
       it "returns the value from the cache" do
@@ -29,18 +29,18 @@ describe "Lawnchair::StorageEngine::Abstract" do
     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
+        abstract_store.data_store["Lawnchair:sim"].should be_nil
         
         class Lawnchair::StorageEngine::Abstract
           def self.set(key, value, options={})
-            cache_container["Lawnchair:#{key}"] = value
+            data_store["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"
+        abstract_store.data_store["Lawnchair:sim"].should == "ba"
       end
     end
   end
@@ -48,12 +48,12 @@ describe "Lawnchair::StorageEngine::Abstract" do
   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.data_store["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.data_store["mu"].should be_nil
         abstract_store.get("mu", :raw => true).should be_nil
       end
     end
@@ -68,7 +68,7 @@ describe "Lawnchair::StorageEngine::Abstract" do
           expected_value = "fasa"
           value = Marshal.dump(expected_value)
 
-          abstract_store.cache_container["Lawnchair:mu"] = value
+          abstract_store.data_store["Lawnchair:mu"] = value
           abstract_store.get("mu", :raw => false).should == expected_value
         end
       end
@@ -79,7 +79,7 @@ describe "Lawnchair::StorageEngine::Abstract" do
         end
         
         it "returns nil if the key does not exist" do
-          abstract_store.cache_container["Lawnchair:mu"].should be_nil
+          abstract_store.data_store["Lawnchair:mu"].should be_nil
           abstract_store.get("mu", :raw => false).should be_nil
         end
       end

data/spec/storage_engine/composite_spec.rb

@@ -11,6 +11,11 @@ describe "Lawnchair::StorageEngine::Composite" do
     it "has a collection of storage_engines" do
       composite_store.storage_engines == []
     end
+    
+    it "allows you to specify storage engines" do
+      composite_store = Lawnchair::StorageEngine::Composite.new(:in_process, :redis)
+      composite_store.storage_engines.should == [Lawnchair::StorageEngine::InProcess, Lawnchair::StorageEngine::Redis]
+    end
   end
   
   describe "#register_storage_engine" do
@@ -19,7 +24,7 @@ describe "Lawnchair::StorageEngine::Composite" do
     end
     
     it "adds a storage engine to the collection" do
-      composite_store.register_storage_engine Lawnchair::StorageEngine::Redis
+      composite_store.register_storage_engine :redis
       composite_store.storage_engines.should == [Lawnchair::StorageEngine::Redis]
     end
   end
@@ -35,7 +40,7 @@ describe "Lawnchair::StorageEngine::Composite" do
     
     context "when there is only 1 storage engine" do
       before do
-        composite_store.register_storage_engine Lawnchair::StorageEngine::Redis
+        composite_store.register_storage_engine :redis
       end
       
       context "when the key does not exist" do
@@ -60,8 +65,7 @@ describe "Lawnchair::StorageEngine::Composite" do
     
     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
+        @composite_store = Lawnchair::StorageEngine::Composite.new(:in_process, :redis)
       end
       
       context "when the key exists in the first storage engine" do

data/spec/storage_engine/in_process_spec.rb

@@ -7,19 +7,19 @@ describe "Lawnchair::StorageEngine::InProcessStore" do
     @in_process_store = Lawnchair::StorageEngine::InProcess
   end
 
-  describe "#cache_container" do
+  describe "#data_store" 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"
+      Lawnchair::StorageEngine::InProcess.send(:class_variable_set, "@@data_store", {"Lawnchair:mu" => "fasa"})
+      in_process_store.data_store["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.data_store["Lawnchair:mu"].should be_nil
         in_process_store.set("mu", "fasa", :raw => true)
-        in_process_store.cache_container["Lawnchair:mu"].should == "fasa"
+        in_process_store.data_store["Lawnchair:mu"].should == "fasa"
       end
     end
     
@@ -28,34 +28,34 @@ describe "Lawnchair::StorageEngine::InProcessStore" do
         value = "fasa"
         expected_value = Marshal.dump(value)
         
-        in_process_store.cache_container["Lawnchair:mu"].should be_nil
+        in_process_store.data_store["Lawnchair:mu"].should be_nil
         in_process_store.set("mu", value, :raw => false)
-        in_process_store.cache_container["Lawnchair:mu"].should == expected_value
+        in_process_store.data_store["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.data_store.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.data_store["Lawnchair:mu"] = "fasa"
+      in_process_store.data_store.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.data_store["Lawnchair:mu"] = "fasa"
+      in_process_store.data_store["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"
+      in_process_store.data_store["Lawnchair:mu"].should be_nil
+      in_process_store.data_store["Lawnchair:sim"].should == "ba"
     end
   end
 end

data/spec/storage_engine/redis_spec.rb

@@ -7,10 +7,10 @@ describe "Lawnchair::StorageEngine::RedisStore" do
     @redis_store = Lawnchair::StorageEngine::Redis
   end
   
-  describe "#cache_container" do
+  describe "#data_store" do
     it "returns the redis cache object" do
       Lawnchair.redis["Lawnchair:mu"] = "fasa"
-      redis_store.cache_container["Lawnchair:mu"].should == "fasa"
+      redis_store.data_store["Lawnchair:mu"].should == "fasa"
     end
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: lawnchair
 version: !ruby/object:Gem::Version 
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors: 
 - Shane Wolf
@@ -9,11 +9,20 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-12 00:00:00 -08:00
+date: 2010-02-14 00:00:00 -08:00
 default_executable: 
-dependencies: []
-
-description: Very simple caching mechanism for arbitrary pieces of resoucre ruby code using Redis as the distributed (or local) cache
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Fully featured caching mechanism for arbitrary pieces of resource expensive ruby code using Redis while being able to optionally store data in the Ruby process itself for maximum efficiency.
 email: shanewolf@gmail.com
 executables: []
 
@@ -30,6 +39,7 @@ files:
 - VERSION
 - lawnchair.gemspec
 - lib/lawnchair.rb
+- lib/marshal_extension.rb
 - lib/storage_engine/abstract.rb
 - lib/storage_engine/composite.rb
 - lib/storage_engine/in_process.rb
@@ -71,7 +81,7 @@ rubyforge_project:
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: Enclose resource expensive Ruby code in a block and cache it in redis
+summary: Speed up your app by caching expensive code in Redis or in the ruby process itself
 test_files: 
 - spec/lawnchair_spec.rb
 - spec/spec_helper.rb