merb-cache 0.9.8 → 0.9.9

data/Rakefile

@@ -17,7 +17,7 @@ GEM_EMAIL  = "ben@benburkert.com"
 
 GEM_NAME    = "merb-cache"
 PKG_BUILD   = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
-GEM_VERSION = (Merb::MORE_VERSION rescue "0.9.8") + PKG_BUILD
+GEM_VERSION = (Merb::VERSION rescue "0.9.9") + PKG_BUILD
 
 RELEASE_NAME    = "REL #{GEM_VERSION}"
 
@@ -35,7 +35,7 @@ spec = Gem::Specification.new do |s|
   s.author = GEM_AUTHOR
   s.email = GEM_EMAIL
   s.homepage = PROJECT_URL
-  s.add_dependency('merb-core', '>= 0.9.8')
+  s.add_dependency('merb-core', '>= 0.9.9')
   s.require_path = 'lib'
   s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,spec}/**/*")
 end
@@ -100,4 +100,4 @@ namespace :memcached do
       system("kill -9 #{process.to_i}") rescue nil
     end
   end
-end
+end

data/lib/merb-cache.rb

@@ -4,6 +4,7 @@ if defined?(Merb::Plugins)
   require "merb-cache" / "core_ext" / "enumerable"
   require "merb-cache" / "core_ext" / "hash"
   require "merb-cache" / "merb_ext" / "controller"
+  require "merb-cache" / "cache_request"
 
   class Merb::Controller
     include Merb::Cache::CacheMixin

data/lib/merb-cache/cache.rb

@@ -7,7 +7,13 @@ module Merb
   module Cache
 
     def self.setup(&blk)
-      instance_eval(&blk) unless blk.nil?
+      if Merb::BootLoader.finished?(Merb::BootLoader::BeforeAppLoads)
+        instance_eval(&blk) unless blk.nil?
+      else
+        Merb::BootLoader.before_app_loads do
+          instance_eval(&blk) unless blk.nil?
+        end
+      end
     end
 
     # autoload is used so that gem dependencies can be required only when needed by

data/lib/merb-cache/cache_request.rb

@@ -0,0 +1,38 @@
+module Merb
+  module Cache
+    class CacheRequest < Merb::Request
+      
+      attr_accessor :path, :params
+
+      def initialize(path, params = {}, env = {})
+        super(DEFAULT_ENV.merge(env))
+
+        @path, @params = path, params
+      end
+
+      DEFAULT_ENV = Mash.new({
+        'SERVER_NAME' => 'localhost',
+        'PATH_INFO' => '/',
+        'HTTP_ACCEPT_ENCODING' => 'gzip,deflate',
+        'HTTP_USER_AGENT' => 'Mozilla/5.0 (Macintosh; U; PPC Mac OS X Mach-O; en-US; rv:1.8.0.1) Gecko/20060214 Camino/1.0',
+        'SCRIPT_NAME' => '/',
+        'SERVER_PROTOCOL' => 'HTTP/1.1',
+        'HTTP_CACHE_CONTROL' => 'max-age=0',
+        'HTTP_ACCEPT_LANGUAGE' => 'en,ja;q=0.9,fr;q=0.9,de;q=0.8,es;q=0.7,it;q=0.7,nl;q=0.6,sv;q=0.5,nb;q=0.5,da;q=0.4,fi;q=0.3,pt;q=0.3,zh-Hans;q=0.2,zh-Hant;q=0.1,ko;q=0.1',
+        'HTTP_HOST' => 'localhost',
+        'REMOTE_ADDR' => '127.0.0.1',
+        'SERVER_SOFTWARE' => 'Mongrel 1.1',
+        'HTTP_KEEP_ALIVE' => '300',
+        'HTTP_REFERER' => 'http://localhost/',
+        'HTTP_ACCEPT_CHARSET' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
+        'HTTP_VERSION' => 'HTTP/1.1',
+        'REQUEST_URI' => '/',
+        'SERVER_PORT' => '80',
+        'GATEWAY_INTERFACE' => 'CGI/1.2',
+        'HTTP_ACCEPT' => 'text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5',
+        'HTTP_CONNECTION' => 'keep-alive',
+        'REQUEST_METHOD' => 'GET'
+      }) unless defined?(DEFAULT_ENV)
+    end
+  end
+end

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

@@ -37,16 +37,41 @@ module Merb::Cache::CacheMixin
       alias_method "_eager_cache_#{trigger_action}_to_#{target_controller.name.snake_case}__#{target_action}_after", :_eager_cache_after
     end
 
-    def eager_dispatch(action, env = {}, blk = nil)
-      kontroller = new(Merb::Request.new(env))
-      kontroller.force_cache!
+    def eager_dispatch(action, params = {}, env = {}, blk = nil)
+      kontroller = if blk.nil?
+        new(Merb::Request.new(env))
+      else
+        result = case blk.arity
+          when 0  then  blk[]
+          when 1  then  blk[params]
+          else          blk[*[params, env]]
+        end
+
+        case result
+        when NilClass         then new(Merb::Request.new(env))
+        when Hash, Mash       then new(Merb::Request.new(result))
+        when Merb::Request    then new(result)
+        when Merb::Controller then result
+        else raise ArgumentError, "Block to eager_cache must return nil, the env Hash, a Request object, or a Controller object"
+        end
+      end
 
-      blk.call(kontroller) unless blk.nil?
+      kontroller.force_cache!
 
       kontroller._dispatch(action)
 
       kontroller
     end
+
+    def build_request(path, params = {}, env = {})
+      path, params, env = nil, path, params if path.is_a? Hash
+
+      Merb::Cache::CacheRequest.new(path, params, env)
+    end
+
+    def build_url(*args)
+      Merb::Router.url(*args)
+    end
   end
 
   def fetch_partial(template, opts={}, conditions = {})
@@ -95,14 +120,14 @@ module Merb::Cache::CacheMixin
   def _eager_cache_after(klass, action, conditions = {}, blk = nil)
     if @_skip_cache.nil?
       run_later do
-        controller = klass.eager_dispatch(action, request.env, blk)
+        controller = klass.eager_dispatch(action, request.params.dup, request.env.dup, blk)
 
         Merb::Cache[controller._lookup_store(conditions)].write(controller, nil, *controller._parameters_and_conditions(conditions))
       end
     end
   end
 
-  def eager_cache(action, conditions = {}, env = request.env.dup, &blk)
+  def eager_cache(action, conditions = {}, params = request.params.dup, env = request.env.dup, &blk)
     unless @_skip_cache
       if action.is_a?(Array)
         klass, action = *action
@@ -111,7 +136,7 @@ module Merb::Cache::CacheMixin
       end
 
       run_later do
-        controller = klass.eager_dispatch(action, env, blk)
+        controller = klass.eager_dispatch(action, params.dup, env.dup, blk)
       end
     end
   end

data/spec/merb-cache/cache_request_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Merb::Cache::CacheRequest do
+  it "should subclass Merb::Request" do
+    Merb::Cache::CacheRequest.superclass.should == Merb::Request
+  end
+
+  describe "#path" do
+    it "can be specified without manipulating the env" do
+      Merb::Cache::CacheRequest.new('/path/to/foo').path.should == '/path/to/foo'
+    end
+  end
+
+  describe "#params" do
+    it "can be specified without manipulating the env" do
+      Merb::Cache::CacheRequest.new('/', 'foo' => 'bar').params.should == {'foo' => 'bar'}
+    end
+  end
+
+  describe "#env" do
+    it "can be specified in the constructor" do
+      Merb::Cache::CacheRequest.new('', {}, 'foo' => 'bar').env['foo'].should == 'bar'
+    end
+  end
+
+  it "should setup a default env" do
+    Merb::Cache::CacheRequest.new('').env.should_not be_empty
+  end
+end

data/spec/merb-cache/merb_ext/controller_spec.rb

@@ -149,6 +149,84 @@ describe Merb::Cache::CacheMixin do
     end
   end
 
+  describe "#eager_cache" do
+    before(:each) do
+      Object.send(:remove_const, :EagerCacher) if defined?(EagerCacher)
+
+      class EagerCacher < Merb::Controller
+        def index
+          "index"
+        end
+      end
+    end
+
+
+
+    it "should accept a block with an arity of 1" do
+      class EagerCacher
+        eager_cache(:index) {|params|}
+      end
+
+      lambda { dispatch_to(EagerCacher, :index) }.should_not raise_error
+    end
+
+    it "should accept a block with an arity greater than 1" do
+      class EagerCacher
+        eager_cache(:index) {|params, env|}
+      end
+
+      lambda { dispatch_to(EagerCacher, :index) }.should_not raise_error
+    end
+
+    it "should accept a block with an arity of -1" do
+      class EagerCacher
+        eager_cache(:index) {|*args|}
+      end
+
+      lambda { dispatch_to(EagerCacher, :index) }.should_not raise_error
+    end
+
+    it "should accept a block with an arity of 0" do
+      class EagerCacher
+        eager_cache(:index) {||}
+      end
+
+      lambda { dispatch_to(EagerCacher, :index) }.should_not raise_error
+    end
+
+    it "should allow the block to return nil" do
+      class EagerCacher
+        eager_cache(:index) {}
+      end
+
+      lambda { dispatch_to(EagerCacher, :index) }.should_not raise_error
+    end
+
+    it "should allow the block to return a params hash" do
+      class EagerCacher
+        eager_cache(:index) {|params| params.merge(:foo => :bar)}
+      end
+
+      lambda { dispatch_to(EagerCacher, :index) }.should_not raise_error(ArgumentError)
+    end
+
+    it "should allow the block to return a Merb::Request object" do
+      class EagerCacher
+        eager_cache(:index) {|params| build_request('/')}
+      end
+
+      lambda { dispatch_to(EagerCacher, :index) }.should_not raise_error(ArgumentError)
+    end
+
+    it "should allow the block to return a Merb::Controller object" do
+      class EagerCacher
+        eager_cache(:index) {|params, env| EagerCacher.new(env)}
+      end
+
+      lambda { dispatch_to(EagerCacher, :index) }.should_not raise_error(ArgumentError)
+    end
+  end
+
   describe "eager_cache (Instance Method)" do
     class HasRun
       cattr_accessor :has_run
@@ -281,4 +359,22 @@ describe Merb::Cache::CacheMixin do
       new_controller.fetch_fragment {}
     end
   end
+
+  describe ".build_request" do
+    it "should create a CacheRequest" do
+      Merb::Controller.build_request({}).class.should == Merb::Cache::CacheRequest
+    end
+
+    it "should use nil if the path is not supplied" do
+      Merb::Controller.build_request({}).path.should be_nil
+    end
+
+    it "should allow the params to be specified" do
+      Merb::Controller.build_request(:foo => :bar).params[:foo].should == :bar
+    end
+
+    it "should allow the env to be specified" do
+      Merb::Controller.build_request({}, :foo => :bar).env[:foo].should == :bar
+    end
+  end
 end

data/spec/merb-cache/stores/fundamental/memcached_store_spec.rb

@@ -17,227 +17,228 @@ begin
   raise Exception unless cache.get(key) == value
 rescue Exception => e
   puts e.message
-  raise "Memcached connection failed.  Try starting memcached with the memcached:start rake task or installing memcached gem with sudo gem install memcached."
-end
+  puts "Memcached connection failed.  Try starting memcached with the memcached:start rake task or installing memcached gem with sudo gem install memcached."
+else
 
-describe Merb::Cache::MemcachedStore do
-  it_should_behave_like 'all stores'
+  describe Merb::Cache::MemcachedStore do
+    it_should_behave_like 'all stores'
 
-  before(:each) do
-    @store = Merb::Cache::MemcachedStore.new(:namespace => "specs", :servers => ["127.0.0.1:43042", "127.0.0.1:43043"])
-    @memcached = @store.memcached
-    @memcached.flush
-  end
+    before(:each) do
+      @store = Merb::Cache::MemcachedStore.new(:namespace => "specs", :servers => ["127.0.0.1:43042", "127.0.0.1:43043"])
+      @memcached = @store.memcached
+      @memcached.flush
+    end
 
-  after(:each) do
-    @memcached.flush
-  end
+    after(:each) do
+      @memcached.flush
+    end
   
 
-  it "has accessor for namespace" do
-    @store.namespace.should == "specs"
-  end
+    it "has accessor for namespace" do
+      @store.namespace.should == "specs"
+    end
 
-  it "has accessor for servers" do
-    @store.servers.should == ["127.0.0.1:43042", "127.0.0.1:43043"]
-  end
+    it "has accessor for servers" do
+      @store.servers.should == ["127.0.0.1:43042", "127.0.0.1:43043"]
+    end
   
-  it "has accessor for memcached connector" do
-    @store.memcached.should == @memcached
-  end
+    it "has accessor for memcached connector" do
+      @store.memcached.should == @memcached
+    end
 
 
-  #
-  # ==== #writable?
-  #
+    #
+    # ==== #writable?
+    #
 
-  describe "#writable?" do
-    describe "when conditions hash is empty" do
-      it "returns true" do
-        @store.writable?('foo').should be_true
+    describe "#writable?" do
+      describe "when conditions hash is empty" do
+        it "returns true" do
+          @store.writable?('foo').should be_true
+        end
       end
     end
-  end
   
-  #
-  # ==== #read
-  #  
-
-  describe "#read" do
-    describe "when cache has NO entry matching key" do
-      it "returns nil" do
-        key = "foo"
-
-        @memcached.delete(key) rescue nil
-        @store.read(key).should be_nil
+    #
+    # ==== #read
+    #  
+
+    describe "#read" do
+      describe "when cache has NO entry matching key" do
+        it "returns nil" do
+          key = "foo"
+
+          @memcached.delete(key) rescue nil
+          @store.read(key).should be_nil
+        end
       end
-    end
     
-    describe "when cache has entry matching key" do
-      it "returns the entry matching the key" do
-        key, data = "foo", "bar"
+      describe "when cache has entry matching key" do
+        it "returns the entry matching the key" do
+          key, data = "foo", "bar"
 
-        @memcached.set(key, data)
+          @memcached.set(key, data)
 
-        @store.read(key).should == data
-      end      
-    end    
-  end
+          @store.read(key).should == data
+        end      
+      end    
+    end
 
-  #
-  # ==== #write
-  #
+    #
+    # ==== #write
+    #
 
-  describe "#write" do
-    describe "when entry with the same key does not exist" do
-      it "create a new entry" do
-        key, data = "foo", "bar"
+    describe "#write" do
+      describe "when entry with the same key does not exist" do
+        it "create a new entry" do
+          key, data = "foo", "bar"
 
-        @memcached.delete(key) rescue nil
-        lambda { @memcached.get(key) }.should raise_error(Memcached::NotFound)
+          @memcached.delete(key) rescue nil
+          lambda { @memcached.get(key) }.should raise_error(Memcached::NotFound)
 
-        @store.write(key, data)
-        @memcached.get(key).should == data
-      end      
-    end
+          @store.write(key, data)
+          @memcached.get(key).should == data
+        end      
+      end
     
-    describe "when entry with the same key already exists" do
-      it "overwrites the entry in the cache" do
-        key, data = "foo", "bar"
+      describe "when entry with the same key already exists" do
+        it "overwrites the entry in the cache" do
+          key, data = "foo", "bar"
 
-        @memcached.set(key, "baz")
-        @memcached.get(key).should == "baz"
+          @memcached.set(key, "baz")
+          @memcached.get(key).should == "baz"
 
-        @store.write(key, data)
-        @memcached.get(key).should == data
-      end      
-    end    
-  end
+          @store.write(key, data)
+          @memcached.get(key).should == data
+        end      
+      end    
+    end
 
-  #
-  # ==== #fetch
-  #
+    #
+    # ==== #fetch
+    #
 
-  describe "#fetch" do
-    describe "when the entry exists in the cache" do
-      it "does NOT call the block" do
-         key, data = "foo", "bar"
-         called = false
-         proc = lambda { called = true }
+    describe "#fetch" do
+      describe "when the entry exists in the cache" do
+        it "does NOT call the block" do
+           key, data = "foo", "bar"
+           called = false
+           proc = lambda { called = true }
 
-         @memcached.set(key, data)
-         @store.fetch(key, &proc)
+           @memcached.set(key, data)
+           @store.fetch(key, &proc)
 
-         called.should be_false
-      end      
-    end
+           called.should be_false
+        end      
+      end
     
-    describe "when the entry does not exist in the cache" do
-      it "calls the block" do
-        key, data = "foo", "bar"
-         called = false
-         proc = lambda { called = true }
-
-         @memcached.delete(key) rescue nil
-         @store.fetch(key, &proc)
+      describe "when the entry does not exist in the cache" do
+        it "calls the block" do
+          key, data = "foo", "bar"
+           called = false
+           proc = lambda { called = true }
+
+           @memcached.delete(key) rescue nil
+           @store.fetch(key, &proc)
          
-         called.should be_true
-      end      
-    end    
-  end
+           called.should be_true
+        end      
+      end    
+    end
 
-  #
-  # ==== #delete
-  #
+    #
+    # ==== #delete
+    #
 
-  describe "#delete" do
-    describe "when the entry exists in the cache" do
-      it "deletes the entry" do
-        key, data = "foo", "bar"
+    describe "#delete" do
+      describe "when the entry exists in the cache" do
+        it "deletes the entry" do
+          key, data = "foo", "bar"
 
-        @memcached.set(key, data)
-        @memcached.get(key).should == data
+          @memcached.set(key, data)
+          @memcached.get(key).should == data
 
-        @store.delete(key)
-        lambda { @memcached.get(key) }.should raise_error(Memcached::NotFound)
-      end      
-    end
+          @store.delete(key)
+          lambda { @memcached.get(key) }.should raise_error(Memcached::NotFound)
+        end      
+      end
     
-    describe "when the entry does not exist in the cache" do
-      it "raises Memcached::NotFound" do
-        lambda { @memcached.delete("#{rand}-#{rand}-#{Time.now.to_i}") }.
-          should raise_error(Memcached::NotFound)
-      end      
+      describe "when the entry does not exist in the cache" do
+        it "raises Memcached::NotFound" do
+          lambda { @memcached.delete("#{rand}-#{rand}-#{Time.now.to_i}") }.
+            should raise_error(Memcached::NotFound)
+        end      
+      end
     end
-  end
 
-  #
-  # ==== #delete_all
-  #
+    #
+    # ==== #delete_all
+    #
 
-  describe "#delete_all" do
-    it "flushes Memcached object" do
-      @memcached.set("ruby", "rb")
-      @memcached.set("python", "py")
-      @memcached.set("perl", "pl")
+    describe "#delete_all" do
+      it "flushes Memcached object" do
+        @memcached.set("ruby", "rb")
+        @memcached.set("python", "py")
+        @memcached.set("perl", "pl")
 
-      @store.delete_all
+        @store.delete_all
       
-      @store.exists?("ruby").should be_nil
-      @store.exists?("python").should be_nil
-      @store.exists?("perl").should be_nil           
+        @store.exists?("ruby").should be_nil
+        @store.exists?("python").should be_nil
+        @store.exists?("perl").should be_nil           
+      end
     end
-  end
 
-  #
-  # ==== #clone
-  #
+    #
+    # ==== #clone
+    #
 
-  describe "#clone" do
-    it "clones Memcached instance" do
-      clone = @store.clone
+    describe "#clone" do
+      it "clones Memcached instance" do
+        clone = @store.clone
       
-      clone.memcached.object_id.should_not == @store.memcached.object_id
+        clone.memcached.object_id.should_not == @store.memcached.object_id
+      end
     end
-  end
 
-  #
-  # ==== #normalize
-  #
+    #
+    # ==== #normalize
+    #
 
-  describe "#normalize" do
-    it "should begin with the key" do
-      @store.normalize("this/is/the/key").should =~ /^this\/is\/the\/key/
-    end
+    describe "#normalize" do
+      it "should begin with the key" do
+        @store.normalize("this/is/the/key").should =~ /^this\/is\/the\/key/
+      end
 
-    it "should not add the '?' if there are no parameters" do
-      @store.normalize("this/is/the/key").should_not =~ /\?/
-    end
+      it "should not add the '?' if there are no parameters" do
+        @store.normalize("this/is/the/key").should_not =~ /\?/
+      end
 
-    it "should seperate the parameters from the key by a '?'" do
-      @store.normalize("this/is/the/key", :page => 3, :lang => :en).
-        should =~ %r!this\/is\/the\/key--#{{:page => 3, :lang => :en}.to_sha2}$!
+      it "should seperate the parameters from the key by a '?'" do
+        @store.normalize("this/is/the/key", :page => 3, :lang => :en).
+          should =~ %r!this\/is\/the\/key--#{{:page => 3, :lang => :en}.to_sha2}$!
+      end
     end
-  end
 
-  #
-  # ==== #expire_time
-  #
+    #
+    # ==== #expire_time
+    #
 
-  describe "#expire_time" do
-    describe "when there is NO :expire_in parameter" do
-      it "returns 0" do
-        @store.expire_time.should == 0
-      end      
-    end
+    describe "#expire_time" do
+      describe "when there is NO :expire_in parameter" do
+        it "returns 0" do
+          @store.expire_time.should == 0
+        end      
+      end
     
-    describe "when there is :expire_in parameter" do
-      it "returns Time.now + the :expire_in parameter" do
-        now = Time.now
-        Time.should_receive(:now).and_return now
+      describe "when there is :expire_in parameter" do
+        it "returns Time.now + the :expire_in parameter" do
+          now = Time.now
+          Time.should_receive(:now).and_return now
 
-        @store.expire_time(:expire_in => 100).should == now + 100
-      end      
+          @store.expire_time(:expire_in => 100).should == now + 100
+        end      
+      end
     end
   end
 end

data/spec/merb-cache/stores/strategy/action_store_spec.rb

@@ -104,7 +104,9 @@ describe Merb::Cache::ActionStore do
 
       eager_cache :index, [MLBSchedule, :index]
       eager_cache :overview, :index
-      eager_cache(:short, :params => :page) {|c| c.params[:page] = (c.params[:page].to_i + 1).to_s}
+      eager_cache(:short, :params => :page) do |params, env|
+        build_request(params.merge(:page => (params[:page].to_i + 1).to_s))
+      end
 
       def index
         "MLBScores index"

data/spec/spec_helper.rb

@@ -6,10 +6,11 @@ require 'merb-core'
 require 'merb-action-args'
 require File.join(File.dirname(__FILE__), '..', 'lib', 'merb-cache')
 
-# We want logging!
-Merb.logger = Merb::Logger.new(File.join(File.dirname(__FILE__), '..', 'log', 'merb_test.log'))
+Merb.disable(:initfile)
 
-Merb.start :environment => "test", :adapter => "runner"
+Merb.start :environment => "test",
+           :adapter     => "runner",
+           :log_file    => File.join(File.dirname(__FILE__), '..', 'log', 'merb_test.log')
 
 require "merb-core/test"
 Spec::Runner.configure do |config|
@@ -78,4 +79,4 @@ class Merb::Controller
   def run_later
     yield
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: merb-cache
 version: !ruby/object:Gem::Version 
-  version: 0.9.8
+  version: 0.9.9
 platform: ruby
 authors: 
 - Ben Burkert
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-06 00:00:00 +03:00
+date: 2008-10-13 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.9.8
+        version: 0.9.9
     version: 
 description: Merb plugin that provides caching (page, action, fragment, object)
 email: ben@benburkert.com
@@ -39,6 +39,7 @@ files:
 - TODO
 - lib/merb-cache
 - lib/merb-cache/cache.rb
+- lib/merb-cache/cache_request.rb
 - lib/merb-cache/core_ext
 - lib/merb-cache/core_ext/enumerable.rb
 - lib/merb-cache/core_ext/hash.rb
@@ -57,8 +58,8 @@ files:
 - lib/merb-cache/stores/strategy/page_store.rb
 - lib/merb-cache/stores/strategy/sha1_store.rb
 - lib/merb-cache.rb
-- spec/log
 - spec/merb-cache
+- spec/merb-cache/cache_request_spec.rb
 - spec/merb-cache/cache_spec.rb
 - spec/merb-cache/core_ext
 - spec/merb-cache/core_ext/enumerable_spec.rb