lawnchair 0.3.1 → 0.3.2

data/README.rdoc

@@ -3,16 +3,21 @@
 Very simple caching mechanism for arbitrary pieces of ruby code using Redis as the distributed (or local) cache
 
 == Prerequisites
-http://code.google.com/p/redis/
-and
-http://github.com/ezmobius/redis-rb/
+  git clone git://github.com/ezmobius/redis-rb.git
+  cd redis-rb
+  rake redis:install
 
-== Usage Examples
+== Installation
+
+  sudo gem install lawnchair
 
+== Usage Examples
 
 All you really need to do is wrap some expensive piece of Ruby code in the Lawnchair::Cache.me method as a block and it will be evaluated and the return value will cached in the given cache key.
 
-First, connect to the Redis database
+MAKE SURE REDIS SERVER IS RUNNING PRIOR TO TRYING ANYTHING BELOW!!!
+
+First, connect to the Redis database.  This would most likely go into an environment.rb.
 
   Lawnchair.connectdb
 
@@ -42,6 +47,19 @@ If an hour is too long, or short for the cache key expiration you can set that t
   Lawnchair::Cache.me(:key => "contrived_example", :expires_in => 1.day) do
     # expensive code to be cached for 24 hours
   end
+  
+== 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
+    # 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
 
 If you need to manually expire a key just call:
 

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.3.2

data/lawnchair.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{lawnchair}
-  s.version = "0.3.1"
+  s.version = "0.3.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-07}
+  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 = [
@@ -17,8 +17,7 @@ Gem::Specification.new do |s|
      "README.rdoc"
   ]
   s.files = [
-    ".document",
-     ".gitignore",
+    ".gitignore",
      "LICENSE",
      "README.rdoc",
      "Rakefile",

data/lib/lawnchair.rb

@@ -7,7 +7,7 @@ module Lawnchair
     attr_reader :redis
     
     def connectdb(redis=nil)
-      @redis ||= Redis.new(:db => 11)
+      @redis = (redis || Redis.new(:db => 11))
     end
 
     def flushdb
@@ -16,15 +16,39 @@ module Lawnchair
   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)
       
-      if exists?(options[:key])
-        Marshal.load(Lawnchair.redis[compute_key(options[:key])])
+      if options[:in_process]
+        key_exists = @@in_process_store.has_key?([compute_key(options[:key])])
+      else
+        key_exists = exists?(options[:key])
+      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])
-        Lawnchair.redis.set(compute_key(options[:key]), Marshal.dump(val), 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
@@ -34,11 +58,11 @@ module Lawnchair
     end
     
     def self.expire(key)
-      Lawnchair.redis.del compute_key(key)
+      Lawnchair.redis.del(compute_key(key))
     end
     
     def self.exists?(key)
-      return !!Lawnchair.redis[compute_key(key)]
+      return Lawnchair.redis.exists(compute_key(key))
     end
     
     def self.compute_expiry(seconds)

data/spec/lawnchair_spec.rb

@@ -8,35 +8,53 @@ describe "Lawnchair::Cache" do
       end.should raise_error("Cache key please!")
     end
     
-    context "when the object the block returns is a string" do
-      it "returns the item from the cache if it exists" do
-        Lawnchair::Cache.me(:key => "yogurt") { "strawberry/banana" }
-
-        Lawnchair.redis["Lawnchair:yogurt"] = Marshal.dump("FROM THE CACHE")
-        x = Lawnchair::Cache.me(:key => "yogurt") { "strawberry/banana" }
-        x.should == "FROM THE CACHE"
-      end
+    it "returns the value if it exists" do
+      expected_object = [1,2,3,4]
+      Lawnchair::Cache.me(:key => "marshalled_array") { expected_object }
       
-      it "sets the return value in the cache key given" do
-        Lawnchair::Cache.me(:key => "pizza") { "muschroom/onion" }
-        Lawnchair.redis["Lawnchair:pizza"].should == Marshal.dump("muschroom/onion")
-      end
+      x = Lawnchair::Cache.me(:key => "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 }
+      
+      Marshal.load(Lawnchair.redis["Lawnchair:marshalled_array"]).should == [1,2,3,4]
     end
     
-    context "when the object the block returns is an object" do
-      it "returns the value if it exists" do
-        expected_object = [1,2,3,4]
-        Lawnchair::Cache.me(:key => "marshalled_array") { expected_object }
+    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]
         
-        x = Lawnchair::Cache.me(:key => "marshalled_array") { "JUNK DATA" }
-        x.should == expected_object
+        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
       
-      it "marshalls the object into redis" do
-        expected_object = [1,2,3,4]
-        Lawnchair::Cache.me(:key => "marshalled_array") { expected_object }
-        
-        Marshal.load(Lawnchair.redis["Lawnchair:marshalled_array"]).should == [1,2,3,4]
+      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
       end
     end
     

data/spec/speed.rb

@@ -1,7 +1,8 @@
 require 'benchmark'
 require "#{File.dirname(__FILE__)}/../lib/lawnchair"
 
-Lawnchair.redis.flushdb
+Lawnchair.connectdb
+Lawnchair.flushdb
 
 # Totally contrived and fairly useless example... just wanted to make sure the overhead of 
 # reading and marshalling the data isn't obscene
@@ -23,17 +24,25 @@ def expensive_stuff
 end
 
 Benchmark.bm(7) do |x|
-  x.report("cached:") do
+  x.report("cached:\t\t") do
     (1..n).each do |i|
-      Lawnchair::Cache.me(:key => "foo") do
+      Lawnchair::Cache.me(:key => "redis_cache") do
         expensive_stuff
       end
     end
   end
   
-  x.report("not cached:") do
+  x.report("in process cached:") do
+    (1..n).each do |i|
+      Lawnchair::Cache.me(:key => "in_process_cache") do
+        expensive_stuff
+      end
+    end
+  end
+  
+  x.report("not cached:\t\t") do
     (1..n).each do |i|
       expensive_stuff
     end
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: lawnchair
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors: 
 - Shane Wolf
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-07 00:00:00 -08:00
+date: 2010-02-12 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -23,7 +23,6 @@ extra_rdoc_files:
 - LICENSE
 - README.rdoc
 files: 
-- .document
 - .gitignore
 - LICENSE
 - README.rdoc

data/.document

@@ -1,5 +0,0 @@
-README.rdoc
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE