merb-cache 0.9.2 → 0.9.3

data/Rakefile

@@ -5,7 +5,8 @@ require "spec/rake/spectask"
 
 PLUGIN = "merb-cache"
 NAME = "merb-cache"
-MERB_CACHE_VERSION = Merb::MORE_VERSION rescue "0.9.2"
+MERB_CACHE_VERSION = Merb::MORE_VERSION rescue "0.9.3"
+VERSION = "0.9.3"
 AUTHOR = "Alex Boussinet"
 EMAIL = "alex.boussinet@gmail.com"
 HOMEPAGE = "http://www.merbivore.com"
@@ -22,10 +23,10 @@ spec = Gem::Specification.new do |s|
   s.author = AUTHOR
   s.email = EMAIL
   s.homepage = HOMEPAGE
-  s.add_dependency('merb-core', '>= 0.9.2')
+  s.add_dependency('merb-core', '>= 0.9.3')
   s.require_path = 'lib'
   s.autorequire = PLUGIN
-  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs}/**/*")
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,spec}/**/*")
 
   # rdoc
   s.has_rdoc         = true
@@ -63,15 +64,17 @@ Rake::GemPackageTask.new(spec) do |pkg|
   pkg.gem_spec = spec
 end
 
+install_home = ENV['GEM_HOME'] ? "-i #{ENV['GEM_HOME']}" : ""
+
 task :install => [:package] do
-  sh %{sudo gem install pkg/#{NAME}-#{MERB_CACHE_VERSION} --no-update-sources}
+  sh %{sudo gem install #{install_home} pkg/#{NAME}-#{MERB_CACHE_VERSION} --no-update-sources}
 end
 
 namespace :jruby do
 
   desc "Run :package and install the resulting .gem with jruby"
   task :install => :package do
-    sh %{#{SUDO} jruby -S gem install pkg/#{NAME}-#{Merb::VERSION}.gem --no-rdoc --no-ri}
+    sh %{#{SUDO} jruby -S gem install #{install_home} pkg/#{NAME}-#{Merb::VERSION}.gem --no-rdoc --no-ri}
   end
   
 end

data/lib/merb-cache/cache-action.rb

@@ -28,7 +28,7 @@ module Merb::Cache::ControllerClassMethods
   # ==== Example
   #   cache_actions :mostly_static, [:barely_dynamic, 10]
   def cache_actions(*actions)
-    if actions.any? && Merb::Cache.cached_actions.empty?
+    if actions.any? && !Merb::Cache.cached_actions.key?(controller_name)
       before(:cache_action_before)
       after(:cache_action_after)
     end

data/lib/merb-cache/cache-page.rb

@@ -29,7 +29,7 @@ module Merb::Cache::ControllerClassMethods
   # ==== Example
   #   cache_pages :mostly_static, [:barely_dynamic, 10]
   def cache_pages(*pages)
-    if pages.any? && Merb::Cache.cached_pages.empty?
+    if pages.any? && !Merb::Cache.cached_pages.key?(controller_name)
       before(:cache_page_before)
       after(:cache_page_after)
     end
@@ -44,6 +44,8 @@ end
 module Merb::Cache::ControllerInstanceMethods
   # Mixed in Merb::Controller. Provides methods related to page caching
 
+  DEFAULT_PAGE_EXTENSION = 'html'
+
   # Checks whether a cache entry exists
   #
   # ==== Parameter
@@ -54,9 +56,11 @@ module Merb::Cache::ControllerInstanceMethods
   #
   # ==== Example
   #   cached_page?(:action => 'show', :params => [params[:page]])
+  #   cached_page?(:action => 'show', :extension => 'js')
   def cached_page?(options)
     key = Merb::Controller._cache.key_for(options, controller_name, true)
-    File.file?(Merb::Controller._cache.config[:cache_html_directory] / "#{key}.html")
+    extension = options[:extension] || DEFAULT_PAGE_EXTENSION
+    File.file?(Merb::Controller._cache.config[:cache_html_directory] / "#{key}.#{extension}")
   end
 
   # Expires the page identified by the key computed after the parameters
@@ -67,13 +71,15 @@ module Merb::Cache::ControllerInstanceMethods
   # ==== Examples
   #   expire_page(:action => 'show', :controller => 'news')
   #   expire_page(:action => 'show', :match => true)
+  #   expire_page(:action => 'show', :extension => 'js')
   def expire_page(options)
     config_dir = Merb::Controller._cache.config[:cache_html_directory]
     Merb::Controller._cache.expire_key_for(options, controller_name, true) do |key, match|
       if match
         files = Dir.glob(config_dir / "#{key}*")
       else
-        files = config_dir / "#{key}.html"
+        extension = options[:extension] || DEFAULT_PAGE_EXTENSION
+        files = config_dir / "#{key}.#{extension}"
       end
       FileUtils.rm_rf(files)
     end
@@ -106,14 +112,18 @@ module Merb::Cache::ControllerInstanceMethods
   #   If request.path is "/", the name will be "/index.html"
   #   If request.path is "/news/show/1", the name will be "/news/show/1.html"
   #   If request.path is "/news/show/", the name will be "/news/show.html"
+  #   If request.path is "/news/styles.css", the name will be "/news/styles.css"
   def _cache_page(data = nil)
+    return if Merb::Controller._cache.config[:disable_page_caching]
     controller = controller_name
     action = action_name.to_sym
     pages = Merb::Controller._cache.cached_pages[controller]
     return unless pages && pages.key?(action)
     path = request.path.chomp("/")
     path = "index" if path.empty?
-    cache_file = Merb::Controller._cache.config[:cache_html_directory] / "#{path}.html"
+    ext = "." + (params[:format].empty? ? DEFAULT_PAGE_EXTENSION : params[:format])
+    ext = nil if File.extname(path) == ext
+    cache_file = Merb::Controller._cache.config[:cache_html_directory] / "#{path}#{ext}"
     if data
       cache_directory = File.dirname(cache_file)
       FileUtils.mkdir_p(cache_directory)

data/lib/merb-cache/merb-cache.rb

@@ -40,6 +40,7 @@ class Merb::Cache
   def start
     @config = DEFAULT_CONFIG.merge(Merb::Plugins.config[:merb_cache] || {})
     if @config[:disable] == true || Merb.environment == @config[:disable]
+      config[:disable_page_caching] = true
       config[:store] = "dummy"
     end
     @config[:cache_html_directory] ||= Merb.dir_for(:public) / "cache"

data/spec/config/database.yml

@@ -0,0 +1,14 @@
+---
+:development: &defaults
+  :adapter: sqlite3
+  :database: tmp/merb-cache.sqlite3
+  :log_stream: log/sql.log
+  :log_level: 0
+
+:test:
+  <<: *defaults
+  :database: tmp/merb-cache.sqlite3
+
+:production:
+  <<: *defaults
+  :database: tmp/merb-cache.sqlite3

data/spec/controller.rb

@@ -0,0 +1,58 @@
+class CacheController < Merb::Controller
+  self._template_root = File.dirname(__FILE__) / "views"
+
+  cache_action :action3
+  cache_action :action4, 0.05
+  # or cache_actions :action3, [:action4, 0.05]
+
+  cache_page :action5
+  cache_page :action6, 0.05
+  # or cache_pages :action5, [:action6, 0.05]
+  cache_page :action7
+
+  def action1
+    render
+  end
+
+  def action2
+    render
+  end
+
+  def action3
+    "test action3"
+  end
+
+  def action4
+    "test action4"
+  end
+
+  def action5
+    "test action5"
+  end
+
+  def action6
+    Time.now.to_s
+  end
+
+  def action7
+    provides :js, :css, :html, :xml, :jpg
+    case params[:format]
+    when "css"
+      "CSS"
+    when "js"
+      "JS"
+    when "html"
+      "HTML"
+    when "xml"
+      "XML"
+    when "jpg"
+      "JPG"
+    else
+      raise "BAD FORMAT: #{params[:format].inspect}"
+    end
+  end
+
+  def index
+    "test index"
+  end
+end

data/spec/merb-cache-action_spec.rb

@@ -0,0 +1,106 @@
+describe "merb-cache-action" do
+
+  it "should cache action (action3)" do
+    c = get("/cache_controller/action3")
+    c.body.strip.should == "test action3"
+    c.cached?("/cache_controller/action3").should be_true
+    c.cached_action?("action3").should be_true
+    c.cache_get("/cache_controller/action3").should == "test action3"
+  end
+
+  it "should expire action (action3)" do
+    CACHE.expire_action "action3"
+    CACHE.cache_get("/cache_controller/action3").should be_nil
+  end
+
+  it "should cache action (action3) with full path" do
+    c = get("/cache_controller/action3/abc/456/ghi")
+    c.body.strip.should == "test action3"
+    c.cached?(c.request.path).should be_true
+    c.cache_get(c.request.path).should == "test action3"
+  end
+
+  it "should expire action (action3) with full path" do
+    c = get("/cache_controller/action3/abc/456/ghi")
+    c.expire_action(:key => c.request.path)
+    c.cache_get(c.request.path).should be_nil
+  end
+
+  it "should expire action (action4) after 3 seconds" do
+    c = get("/cache_controller/action4")
+    c.body.strip.should == "test action4"
+    c.cached?("/cache_controller/action4").should be_true
+    c.cache_get("/cache_controller/action4").should == "test action4"
+    sleep 4
+    c.cache_get("/cache_controller/action4").should be_nil
+    c.cached_action?(:action => "action4").should be_false
+  end
+
+  it "should cache action with full path (action4) and expire in 3 seconds" do
+    CACHE.expire_action :match => true, :action => "action4"
+    CACHE.cached_action?(:action => "action4", :params => %w(path to nowhere)).should be_false
+    c = get("/cache_controller/action4/path/to/nowhere/")
+    c.cached_action?(:action => "action4", :params => %w(path to nowhere)).should be_true
+    sleep 3.5
+    c.cache_get("/cache_controller/action4/path/to/nowhere").should be_nil
+    c.cached_action?(:action => "action4", :params => %w(path to nowhere)).should be_false
+  end
+
+  it "should expire action in many ways" do
+    c = get("/cache_controller/action4")
+    CACHE.expire_action("action4")
+    CACHE.cached_action?("action4").should be_false
+
+    c = get("/cache_controller/action4")
+    CACHE.expire_action(:match => "/cache_control")
+    CACHE.cached_action?(:action => "action4").should be_false
+
+    c = get("/cache_controller/action4")
+    CACHE.expire_action(:action => "action4")
+    CACHE.cached_action?(:action => "action4").should be_false
+
+    c = get("/cache_controller/action4/id1/id2")
+    CACHE.expire_action(:action => "action4", :params => %w(id1 id2))
+    CACHE.cached_action?(:action => "action4", :params => %w(id1 id2)).should be_false
+
+    c = get("/cache_controller/action4/id1/id2")
+    CACHE.expire_action(:action => "action4", :match => true)
+    CACHE.cached_action?(:action => "action4", :params => %w(id1 id2)).should be_false
+
+    c = get("/cache_controller/action4")
+    CACHE.expire_action(:action => "action4", :controller => "cache_controller")
+    CACHE.cached_action?(:action => "action4", :controller => "cache_controller").should be_false
+
+    c = get("/cache_controller/action4/id1/id2")
+    CACHE.expire_action(:action => "action4", :params => %w(id1), :match => true)
+    CACHE.cached_action?(:action => "action4", :params => %w(id1 id2)).should be_false
+
+    c = get("/cache_controller/action4/id1/id2")
+    CACHE.expire_action(:action => "action4", :controller => "cache_controller", :match => true)
+    CACHE.cached_action?(:action => "action4", :params => %w(id1 id2)).should be_false
+
+    c = get("/cache_controller/action4/id1/id2")
+    CACHE.expire_action(:action => "action4", :controller => "cache_controller", :params => %w(id1), :match => true)
+    CACHE.cached_action?(:action => "action4", :params => %w(id1 id2)).should be_false
+
+    c = get("/cache_controller/action4/id1/id2")
+    CACHE.expire_action(:action => "action4", :controller => "cache_controller", :params => %w(id1 id2))
+    CACHE.cached_action?(:action => "action4", :controller => "cache_controller", :params => %w(id1 id2)).should be_false
+
+    c = get("/cache_controller/action4")
+    CACHE.expire_action(:key => "/cache_controller/action4")
+    CACHE.cached_action?(:key => "/cache_controller/action4").should be_false
+    c = get("/cache_controller/action4/id1/id2")
+    CACHE.expire_action(:key => "/cache_controller/action4", :params => %w(id1 id2))
+    CACHE.cached_action?(:key => "/cache_controller/action4", :params => %w(id1 id2)).should be_false
+
+    c = get("/cache_controller/action4/id1/id2")
+    CACHE.expire_action(:key => "/cache_controller/action4/id1", :match => true)
+    CACHE.cached_action?(:key => "/cache_controller/action4/id1/id2").should be_false
+
+    c = get("/cache_controller/action4/id1/id2")
+    CACHE.expire_action(:key => "/cache_controller/action4", :params => %w(id1), :match => true)
+    CACHE.cached_action?(:key => "/cache_controller/action4/id1/id2").should be_false
+  end
+
+end

data/spec/merb-cache-fragment_spec.rb

@@ -0,0 +1,100 @@
+# TODO
+# more specs for fragment caching:
+# cache_get, cache_set, cached?, cache, expire
+
+describe "merb-cache-fragment" do
+
+  it "should render index" do
+    c = dispatch_to(CacheController, :index)
+    c.body.should == "test index"
+  end
+
+  it "should cache the fragment (erb capture/concat)" do
+    c = dispatch_to(CacheController, :action1)
+    NOW = c.body.strip
+    c.cache_get("key1").strip.should == NOW
+  end
+
+  it "should cache the fragment (haml capture/concat)" do
+    c = dispatch_to(CacheController, :action2)
+    now = c.body.strip
+    c.cache_get("key11").strip.should == now
+    sleep 1
+    c = dispatch_to(CacheController, :action2)
+    c.cache_get("key11").strip.should == now
+    c.expire("key11")
+    c.cache_get("key11").should be_nil
+  end
+
+  it "should use the fragment" do
+    sleep 1
+    c = dispatch_to(CacheController, :action1)
+    c.body.strip.should == NOW
+  end
+
+  it "should expire the fragment" do
+    CACHE.expire("key1")
+    CACHE.cache_get("key1").should be_nil
+  end
+
+  it "should refresh the template" do
+    c = dispatch_to(CacheController, :action1)
+    c.body.strip.should_not == NOW
+  end
+
+  it "should return nil for unknown keys" do
+    CACHE.cache_get("unknown_key").should be_nil
+  end
+
+  it "should expire matching keys" do
+    CACHE.cache_set("test1", "test1")
+    CACHE.cache_get("test1").should == "test1"
+    CACHE.cache_set("test2", "test2")
+    CACHE.cache_get("test2").should == "test2"
+    CACHE.cache_set("test3", "test3")
+    CACHE.cache_get("test3").should == "test3"
+    CACHE.expire(:match => "test")
+    CACHE.cache_get("test1").should be_nil
+    CACHE.cache_get("test2").should be_nil
+    CACHE.cache_get("test3").should be_nil
+  end
+
+  it "should expire entry after 3 seconds" do
+    CACHE.cache_set("timed_key", "vanish in 3 seconds", 0.05)
+    CACHE.cache_get("timed_key").should == "vanish in 3 seconds"
+    sleep 3.5
+    CACHE.cache_get("timed_key").should be_nil
+  end
+
+  it "should expire in many ways" do
+    CACHE.cache_set("test1", "test1")
+    CACHE.expire("test1")
+    CACHE.cache_get("test1").should be_nil
+
+    CACHE.cache_set("test2/id1", "test2")
+    CACHE.expire(:key => "test2", :params => %w(id1))
+    CACHE.cache_get("test2/id1").should be_nil
+
+    CACHE.cache_set("test3", "test3")
+    CACHE.expire(:key => "test3")
+    CACHE.cache_get("test3").should be_nil
+
+    CACHE.cache_set("test4/id1", "test4")
+    CACHE.expire(:key => "test4", :params => %w(id1), :match => true)
+    CACHE.cache_get("test4/id1/id2").should be_nil
+  end
+
+  it "should expire all keys" do
+    CACHE.expire_all
+    CACHE.cache_get("key1").should be_nil
+  end
+
+  it "should cache/restore ruby objects" do
+    now = Time.now
+    data = {:key1 => "key1", :key2 => "key2", :now => Time.now }
+    CACHE.cache_set("key1", data)
+    _data = CACHE.cache_get("key1")
+    data.should == _data
+  end
+
+end

data/spec/merb-cache-page_spec.rb

@@ -0,0 +1,150 @@
+describe "merb-cache-page" do
+
+  it "should cache page (action5)" do
+    c = get("/cache_controller/action5")
+    c.body.strip.should == "test action5"
+    c.cached_page?("action5").should be_true
+  end
+
+  it "should expire page (action5)" do
+    CACHE.expire_page("action5")
+    CACHE.cached_page?("action5").should be_false
+  end
+
+  it "should cache page (action5) with full path" do
+    c = get("/cache_controller/action5/this/is/a/test")
+    c.cached_page?(:action => "action5", :params => %w(this is a test)).should be_true
+  end
+
+  it "should expire page (action5) with full path" do
+    CACHE.expire_page(:action => "action5",
+                      :controller => "cache_controller",
+                      :params => %w(this is a test))
+    CACHE.cached_page?(:key => "/cache_controller/action5/this/is/a/test").should be_false
+  end
+
+  it "should cache page (action6), use it and expire 3 seconds after" do
+    CACHE.expire_page :match => true, :action => "action6"
+    c = get("/cache_controller/action6")
+    now = Time.now.to_s
+    c.body.strip.should == now
+    c.cached_page?("action6").should be_true
+    sleep 1
+    c = get("/cache_controller/action6")
+    c.body.strip.should == now
+    sleep 2
+    c = get("/cache_controller/action6")
+    c.body.strip.should == Time.now.to_s
+  end
+
+  it "should cache page with full path (action6) and expire in 3 seconds" do
+    CACHE.expire_page "action6"
+    CACHE.cached_page?(:action => "action6", :params => %w(path to nowhere)).should be_false
+    c = get("/cache_controller/action6/path/to/nowhere/")
+    now = Time.now.to_s
+    c.body.strip.should == now
+    c.cached_page?(:action => "action6", :params => %w(path to nowhere)).should be_true
+    sleep 1
+    c = get("/cache_controller/action6/path/to/nowhere")
+    c.body.strip.should == now
+    sleep 2
+    c = get("/cache_controller/action6/path/to/nowhere")
+    c.body.strip.should == Time.now.to_s
+  end
+
+  it "should expire page in many ways" do
+    c = get("/cache_controller/action6")
+    CACHE.expire_page("action6")
+    CACHE.cached_page?("action6").should be_false
+
+    c = get("/cache_controller/action6")
+    CACHE.expire_page(:match => "/cache_control")
+    CACHE.cached_page?(:action => "action6").should be_false
+
+    c = get("/cache_controller/action6")
+    CACHE.expire_page(:action => "action6")
+    CACHE.cached_page?(:action => "action6").should be_false
+
+    c = get("/cache_controller/action6/id1/id2")
+    CACHE.expire_page(:action => "action6", :params => %w(id1 id2))
+    CACHE.cached_page?(:action => "action6", :params => %w(id1 id2)).should be_false
+
+    c = get("/cache_controller/action6/id1/id2")
+    CACHE.expire_page(:action => "action6", :match => true)
+    CACHE.cached_page?(:action => "action6", :params => %w(id1 id2)).should be_false
+
+    c = get("/cache_controller/action6")
+    CACHE.expire_page(:action => "action6", :controller => "cache_controller")
+    CACHE.cached_page?(:action => "action6", :controller => "cache_controller").should be_false
+
+    c = get("/cache_controller/action6/id1/id2")
+    CACHE.expire_page(:action => "action6", :params => %w(id1), :match => true)
+    CACHE.cached_page?(:action => "action6", :params => %w(id1 id2)).should be_false
+
+    c = get("/cache_controller/action6/id1/id2")
+    CACHE.expire_page(:action => "action6", :controller => "cache_controller", :match => true)
+    CACHE.cached_page?(:action => "action6", :params => %w(id1 id2)).should be_false
+
+    c = get("/cache_controller/action6/id1/id2")
+    CACHE.expire_page(:action => "action6", :controller => "cache_controller", :params => %w(id1), :match => true)
+    CACHE.cached_page?(:action => "action6", :params => %w(id1 id2)).should be_false
+
+    c = get("/cache_controller/action6/id1/id2")
+    CACHE.expire_page(:action => "action6", :controller => "cache_controller", :params => %w(id1 id2))
+    CACHE.cached_page?(:action => "action6", :controller => "cache_controller", :params => %w(id1 id2)).should be_false
+
+    c = get("/cache_controller/action6")
+    CACHE.expire_page(:key => "/cache_controller/action6")
+    CACHE.cached_page?(:key => "/cache_controller/action6").should be_false
+    c = get("/cache_controller/action6/id1/id2")
+    CACHE.expire_page(:key => "/cache_controller/action6", :params => %w(id1 id2))
+    CACHE.cached_page?(:key => "/cache_controller/action6", :params => %w(id1 id2)).should be_false
+
+    c = get("/cache_controller/action6/id1/id2")
+    CACHE.expire_page(:key => "/cache_controller/action6/id1", :match => true)
+    CACHE.cached_page?(:key => "/cache_controller/action6/id1/id2").should be_false
+
+    c = get("/cache_controller/action6/id1/id2")
+    CACHE.expire_page(:key => "/cache_controller/action6", :params => %w(id1), :match => true)
+    CACHE.cached_page?(:key => "/cache_controller/action6/id1/id2").should be_false
+  end
+
+  it "should respect original content-type" do
+    c = get("/cache_controller/action7.css")
+    c.body.should == "CSS"
+    c = get("/cache_controller/action7.css")
+    c.params[:format].should == "css"
+    c.cached_page?(:action => "action7", :extension => 'css').should be_true
+
+    c = get("/cache_controller/action7.js")
+    c.body.should == "JS"
+    c = get("/cache_controller/action7.js")
+    c.params[:format].should == "js"
+    c.cached_page?(:action => "action7", :extension => 'js').should be_true
+
+    c = get("/cache_controller/action7.xml")
+    c.body.should == "XML"
+    c = get("/cache_controller/action7.xml")
+    c.params[:format].should == "xml"
+    c.cached_page?(:action => "action7", :extension => 'xml').should be_true
+
+    c = get("/cache_controller/action7.jpg")
+    c.body.should == "JPG"
+    c = get("/cache_controller/action7.jpg")
+    c.params[:format].should == "jpg"
+    c.cached_page?(:action => "action7", :extension => 'jpg').should be_true
+
+    c = get("/cache_controller/action7.html")
+    c.body.should == "HTML"
+    c = get("/cache_controller/action7.html")
+    c.params[:format].should == "html"
+    c.cached_page?(:action => "action7").should be_true
+  end
+
+  it "should expire all pages" do
+    CACHE.expire_all_pages
+    CACHE.cached_page?("action6").should be_false
+    Dir.glob(Merb::Controller._cache.config[:cache_html_directory] + '/*').should be_empty
+  end
+
+end

data/spec/merb-cache_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+Merb::Router.prepare do |r|
+  r.default_routes
+  r.match("/").to(:controller => "cache_controller", :action =>"index")
+end
+
+CACHE = CacheController.new(Merb::Test::RequestHelper::FakeRequest.new)
+CACHE.expire_all
+
+puts "Using #{CACHE._cache.store.cache_store_type.inspect} store"
+
+require File.dirname(__FILE__) + "/merb-cache-fragment_spec"
+require File.dirname(__FILE__) + "/merb-cache-action_spec"
+require File.dirname(__FILE__) + "/merb-cache-page_spec"

data/spec/spec_helper.rb

@@ -0,0 +1,83 @@
+$TESTING=true
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require "rubygems"
+require "merb-core"
+
+require "merb-cache"
+require File.dirname(__FILE__) / "controller"
+
+require "merb-haml"
+
+def set_database_adapter(adapter)
+  config_file = File.dirname(__FILE__) / "config/database.yml"
+  config = IO.read(config_file)
+  config.gsub!(/:adapter:\s+.*$/, ":adapter: #{adapter}")
+  File.open(config_file, "w+") do |c| c.write(config) end
+end
+
+def use_cache_store(store, orm = nil)
+  Merb::Plugins.config[:merb_cache] = {
+    :store => store,
+    :cache_directory => File.dirname(__FILE__) / "tmp/cache",
+    :cache_html_directory => File.dirname(__FILE__) / "tmp/html",
+  }
+  FileUtils.rm_rf(Dir.glob(File.dirname(__FILE__) / "/tmp"))
+  case store
+  when "dummy"
+  when "file"
+  when "memory"
+  when "memcache"
+    require "memcache"
+  when "database"
+    case orm
+    when "datamapper"
+      Merb.environment = "test"
+      Merb.logger = Merb::Logger.new("log/merb_test.log")
+      set_database_adapter("sqlite3")
+      require "merb_datamapper"
+    when "activerecord"
+      Merb.logger = Merb::Logger.new("log/merb_test.log")
+      set_database_adapter("sqlite3")
+      require "merb_activerecord"
+    when "sequel"
+      set_database_adapter("sqlite")
+      require "merb_sequel"
+    else
+      raise "Unknown orm: #{orm}"
+    end
+  else
+    raise "Unknown cache store: #{store}"
+  end
+end
+
+store = "file"
+case ENV["STORE"] || store
+when "file"
+  use_cache_store "file"
+when "memory"
+  use_cache_store "memory"
+when "memcache"
+  use_cache_store "memcache"
+when "datamapper"
+  use_cache_store "database", "datamapper"
+when "sequel"
+  use_cache_store "database", "sequel"
+when "activerecord"
+  use_cache_store "database", "activerecord"
+when "dummy"
+  use_cache_store "dummy"
+else
+  puts "Invalid cache store: #{ENV["store"]}"
+  exit
+end
+
+require "fileutils"
+FileUtils.mkdir_p(Merb::Plugins.config[:merb_cache][:cache_html_directory])
+FileUtils.mkdir_p(Merb::Plugins.config[:merb_cache][:cache_directory])
+
+Merb.start :environment => "test", :adapter => "runner"
+
+require "merb-core/test"
+Spec::Runner.configure do |config|
+  config.include Merb::Test::RequestHelper  
+end

data/spec/views/cache_controller/action1.html.erb

@@ -0,0 +1,4 @@
+<%- cache('key1') do -%>
+  <%= Time.now %>
+<%- end -%>
+

data/spec/views/cache_controller/action2.html.haml

@@ -0,0 +1,4 @@
+- cache('key11') do
+= Time.now
+- end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: merb-cache
 version: !ruby/object:Gem::Version 
-  version: 0.9.2
+  version: 0.9.3
 platform: ruby
 authors: 
 - Alex Boussinet
@@ -9,7 +9,7 @@ autorequire: merb-cache
 bindir: bin
 cert_chain: []
 
-date: 2008-03-24 00:00:00 -05:00
+date: 2008-05-04 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -19,7 +19,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.9.2
+        version: 0.9.3
     version: 
 description: Merb plugin that provides caching (page, action, fragment, object)
 email: alex.boussinet@gmail.com
@@ -52,6 +52,18 @@ files:
 - lib/merb-cache/merb-cache.rb
 - lib/merb-cache/merbtasks.rb
 - lib/merb-cache.rb
+- spec/config
+- spec/config/database.yml
+- spec/controller.rb
+- spec/merb-cache-action_spec.rb
+- spec/merb-cache-fragment_spec.rb
+- spec/merb-cache-page_spec.rb
+- spec/merb-cache_spec.rb
+- spec/spec_helper.rb
+- spec/views
+- spec/views/cache_controller
+- spec/views/cache_controller/action1.html.erb
+- spec/views/cache_controller/action2.html.haml
 has_rdoc: true
 homepage: http://www.merbivore.com
 post_install_message: