lawnchair 0.3.0

data/.document

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

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Shane Wolf
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,59 @@
+= Lawnchair
+
+Very simple caching mechanism for arbitrary pieces of ruby code using Redis as the distributed (or local) cache
+
+== 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
+
+  Lawnchair.connectdb
+
+This will connect to a default database on localhost, if you want to connect to a particular database you can do:
+
+  Lawnchair.connectdb(Redis.new(:database => 11, :host => "127.0.0.1", :port => 6379))
+
+Obligatory example:
+  
+  Lawnchair::Cache.me(:key => "contrived_example") 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")
+      sleep 1
+      set
+    end
+  end
+  
+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.
+
+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 milliseconds
+
+  Lawnchair::Cache.me(:key => "contrived_example", :expires_in => 1.day) do
+    # expensive code to be cached for 24 hours
+  end
+
+If you need to manually expire a key just call:
+
+  Lawnchair::Cache.expire("contrived_example")
+
+If you need to flush all the values in the database
+
+  Lawnchair.flushdb
+
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* I will promply ignore anything that is not a refactor that does not have associated specs :)
+* Have fun
+
+== Copyright
+
+Copyright (c) 2010 Shane Wolf. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'rake'
+
+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.email = "shanewolf@gmail.com"
+    gem.homepage = "http://github.com/gizm0duck/lawnchair"
+    gem.authors = ["Shane Wolf"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "lawnchair #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/lawnchair.gemspec

@@ -0,0 +1,55 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{lawnchair}
+  s.version = "0.3.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-07}
+  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 = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lawnchair.gemspec",
+     "lib/lawnchair.rb",
+     "spec/lawnchair_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "spec/speed.rb",
+     "spec/speed_results.png"
+  ]
+  s.homepage = %q{http://github.com/gizm0duck/lawnchair}
+  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.test_files = [
+    "spec/lawnchair_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/speed.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/lawnchair.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'redis'
+
+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
+    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])])
+      else
+        val = block.call
+        expires_in = compute_expiry(options[:expires_in])
+        Lawnchair.redis.set(compute_key(options[:key]), Marshal.dump(val), expires_in)
+        return val
+      end
+    end
+    
+    def self.compute_key(key)
+      "Lawnchair:#{key}"
+    end
+    
+    def self.expire(key)
+      Lawnchair.redis.del compute_key(key)
+    end
+    
+    def self.exists?(key)
+      return !!Lawnchair.redis[compute_key(key)]
+    end
+    
+    def self.compute_expiry(ms)
+      ms ||= 3600000
+      ms/1000
+    end
+  end
+end

data/spec/lawnchair_spec.rb

@@ -0,0 +1,77 @@
+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
+    
+    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 "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
+    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 }
+        
+        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
+    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 => 1000) { "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.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$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)  { Lawnchair.flushdb }
+end

data/spec/speed.rb

@@ -0,0 +1,39 @@
+require 'benchmark'
+require "#{File.dirname(__FILE__)}/../lib/lawnchair"
+
+Lawnchair.redis.flushdb
+
+# Totally contrived and fairly useless example... just wanted to make sure the overhead of 
+# 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)
+
+n = (ARGV.shift || 1000).to_i
+
+puts "*** Performing #{n} iterations ***"
+
+def expensive_stuff
+  a = []
+  100.times do
+    a << Date.parse("Dec 3. 1981")
+  end
+end
+
+Benchmark.bm(7) do |x|
+  x.report("cached:") do
+    (1..n).each do |i|
+      Lawnchair::Cache.me(:key => "foo") do
+        expensive_stuff
+      end
+    end
+  end
+  
+  x.report("not cached:") do
+    (1..n).each do |i|
+      expensive_stuff
+    end
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: lawnchair
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Shane Wolf
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-07 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
+email: shanewolf@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lawnchair.gemspec
+- lib/lawnchair.rb
+- spec/lawnchair_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/speed.rb
+- spec/speed_results.png
+has_rdoc: true
+homepage: http://github.com/gizm0duck/lawnchair
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+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
+test_files: 
+- spec/lawnchair_spec.rb
+- spec/spec_helper.rb
+- spec/speed.rb