merb-cache 0.9.7 → 0.9.8

data/lib/merb-cache/stores/strategy/adhoc_store.rb

@@ -0,0 +1,69 @@
+module Merb::Cache
+  # General purpose store, use for your own
+  # contexts. Since it wraps access to multiple
+  # fundamental stores, it's easy to use
+  # this strategy store with distributed cache
+  # stores like Memcached.
+  class AdhocStore < AbstractStrategyStore
+    class << self
+      alias_method :[], :new
+    end
+
+    attr_accessor :stores
+
+    def initialize(*names)
+      @stores = names.map {|n| Merb::Cache[n]}
+    end
+
+    def writable?(key, parameters = {}, conditions = {})
+      @stores.capture_first {|s| s.writable?(key, parameters, conditions)}
+    end
+
+    # gets the data from the store identified by the key & parameters.
+    # return nil if the entry does not exist.
+    def read(key, parameters = {})
+      @stores.capture_first {|s| s.read(key, parameters)}
+    end
+
+    # persists the data so that it can be retrieved by the key & parameters.
+    # returns nil if it is unable to persist the data.
+    # returns true if successful.
+    def write(key, data = nil, parameters = {}, conditions = {})
+      @stores.capture_first {|s| s.write(key, data, parameters, conditions)}
+    end
+
+    # persists the data to all context stores.
+    # returns nil if none of the stores were able to persist the data.
+    # returns true if at least one write was successful.
+    def write_all(key, data = nil, parameters = {}, conditions = {})
+      @stores.map {|s| s.write_all(key, data, parameters, conditions)}.all?
+    end
+
+    # tries to read the data from the store.  If that fails, it calls
+    # the block parameter and persists the result.  If it cannot be fetched,
+    # the block call is returned.
+    def fetch(key, parameters = {}, conditions = {}, &blk)
+      read(key, parameters) ||
+        @stores.capture_first {|s| s.fetch(key, parameters, conditions, &blk)} ||
+        blk.call
+    end
+
+    # returns true/false/nil based on if data identified by the key & parameters
+    # is persisted in the store.
+    def exists?(key, parameters = {})
+      @stores.capture_first {|s| s.exists?(key, parameters)}
+    end
+
+    # deletes the entry for the key & parameter from the store.
+    def delete(key, parameters = {})
+      @stores.map {|s| s.delete(key, parameters)}.any?
+    end
+
+    # deletes all entries for the key & parameters for the store.
+    # considered dangerous because strategy stores which call delete_all!
+    # on their context stores could delete other store's entrees.
+    def delete_all!
+      @stores.map {|s| s.delete_all!}.all?
+    end
+  end
+end

data/lib/merb-cache/stores/strategy/gzip_store.rb

@@ -0,0 +1,63 @@
+# Pinched from Tobias Luetke's "cacheable" rails plugin (http://github.com/tobi/cacheable/tree/master)
+require 'zlib' 
+require 'stringio'
+
+module Merb::Cache
+  # Store that compresses cached data using GZip.
+  # Usually wraps other stores and good for caching of
+  # large pages.
+  class GzipStore < AbstractStrategyStore
+    def writable?(key, parameters = {}, conditions = {})
+      true
+    end
+
+    def read(key, parameters = {})
+      decompress(@stores.capture_first {|c| c.read(key, parameters)})
+    end
+
+    def write(key, data = nil, parameters = {}, conditions = {})
+      if writable?(key, parameters, conditions)
+        @stores.capture_first {|c| c.write(key, compress(data), parameters, conditions)}
+      end
+    end
+
+    def write_all(key, data = nil, parameters = {}, conditions = {})
+      if writable?(key, parameters, conditions)
+        @stores.map {|c| c.write_all(key, compress(data), parameters, conditions)}.all?
+      end
+    end
+
+    def fetch(key, parameters = {}, conditions = {}, &blk)
+      wrapper_blk = lambda { compress(blk.call) }
+      decompress(read(key, parameters) || @stores.capture_first {|s| s.fetch(key, parameters, conditions, &wrapper_blk)})
+    end
+
+    def exists?(key, parameters = {})
+      @stores.capture_first {|c| c.exists?(key, parameters)}
+    end
+
+    def delete(key, parameters = {})
+      @stores.map {|c| c.delete(key, parameters)}.any?
+    end
+
+    def delete_all!
+      @stores.map {|c| c.delete_all! }.all?
+    end
+
+    def compress(data)
+      return if data.nil?
+
+      output = StringIO.new
+      gz = Zlib::GzipWriter.new(output)
+      gz.write(Marshal.dump(data))
+      gz.close
+      output.string
+    end
+
+    def decompress(data)
+      return if data.nil?
+
+      Marshal.load(Zlib::GzipReader.new(StringIO.new(data)).read)
+    end
+  end
+end

data/lib/merb-cache/stores/strategy/page_store.rb

@@ -0,0 +1,64 @@
+module Merb::Cache
+  # Store well suited for page caching.
+  class PageStore < AbstractStrategyStore
+    def writable?(dispatch, parameters = {}, conditions = {})
+      if Merb::Controller === dispatch && dispatch.request.method == :get &&
+          !dispatch.request.uri.nil? && !dispatch.request.uri.empty? &&
+          !conditions.has_key?(:if) && !conditions.has_key?(:unless) &&
+          query_string_present?(dispatch)
+        @stores.any? {|s| s.writable?(normalize(dispatch), parameters, conditions)}
+      else
+        false
+      end
+    end
+
+    def read(dispatch, parameters = {})
+      nil
+    end
+
+    def write(dispatch, data = nil, parameters = {}, conditions = {})
+      if writable?(dispatch, parameters, conditions)
+        @stores.capture_first {|s| s.write(normalize(dispatch), data || dispatch.body, {}, conditions)}
+      end
+    end
+
+    def write_all(dispatch, data = nil, parameters = {}, conditions = {})
+      if writable?(dispatch, parameters, conditions)
+        @stores.map {|s| s.write_all(normalize(dispatch), data || dispatch.body, {}, conditions)}.all?
+      end
+    end
+
+    def fetch(dispatch, parameters = {}, conditions = {}, &blk)
+      if writable?(dispatch, parameters, conditions)
+        read(dispatch, parameters) || @stores.capture_first {|s| s.fetch(normalize(dispatch), data || dispatch.body, {}, conditions, &blk)}
+      end
+    end
+
+    def exists?(dispatch, parameters = {})
+      if writable?(dispatch, parameters)
+        @stores.capture_first {|s| s.exists?(normalize(dispatch), {})}
+      end
+    end
+
+    def delete(dispatch, parameters = {})
+      if writable?(dispatch, parameters)
+        @stores.map {|s| s.delete(normalize(dispatch), {})}.any?
+      end
+    end
+
+    def delete_all!
+      @stores.map {|s| s.delete_all!}.all?
+    end
+
+    def normalize(dispatch)
+      key = dispatch.request.uri.split('?').first
+      key << "index" if key =~ /\/$/
+      key << ".#{dispatch.content_type}" unless key =~ /\.\w{2,6}/
+      key
+    end
+
+    def query_string_present?(dispatch)
+      dispatch.request.env["REQUEST_URI"] == dispatch.request.uri
+    end
+  end
+end

data/lib/merb-cache/stores/strategy/sha1_store.rb

@@ -0,0 +1,62 @@
+require 'digest/sha1'
+
+module Merb::Cache
+  # Strategy store that uses SHA1 hex of
+  # base cache key and parameters as
+  # cache key.
+  #
+  # It is good for caching of expensive
+  # search queries that use multiple
+  # parameters passed via query string
+  # of request.
+  class SHA1Store < AbstractStrategyStore
+    def initialize(config = {})
+      super(config)
+      @map = {}
+    end
+
+    def writable?(key, parameters = {}, conditions = {})
+      case key
+      when String, Numeric, Symbol
+        @stores.any? {|c| c.writable?(digest(key, parameters), {}, conditions)}
+      else nil
+      end
+    end
+
+    def read(key, parameters = {})
+      @stores.capture_first {|c| c.read(digest(key, parameters))}
+    end
+
+    def write(key, data = nil, parameters = {}, conditions = {})
+      if writable?(key, parameters, conditions)
+        @stores.capture_first {|c| c.write(digest(key, parameters), data, {}, conditions)}
+      end
+    end
+
+    def write_all(key, data = nil, parameters = {}, conditions = {})
+      if writable?(key, parameters, conditions)
+        @stores.map {|c| c.write_all(digest(key, parameters), data, {}, conditions)}.all?
+      end
+    end
+
+    def fetch(key, parameters = {}, conditions = {}, &blk)
+      read(key, parameters) || (writable?(key, parameters, conditions) && @stores.capture_first {|c| c.fetch(digest(key, parameters), {}, conditions, &blk)})
+    end
+
+    def exists?(key, parameters = {})
+      @stores.capture_first {|c| c.exists?(digest(key, parameters))}
+    end
+
+    def delete(key, parameters = {})
+      @stores.map {|c| c.delete(digest(key, parameters))}.any?
+    end
+
+    def delete_all!
+      @stores.map {|c| c.delete_all! }.all?
+    end
+
+    def digest(key, parameters = {})
+      @map[[key, parameters]] ||= Digest::SHA1.hexdigest("#{key}#{parameters.to_sha2}")
+    end
+  end
+end

data/lib/merb-cache.rb

@@ -1,10 +1,11 @@
+# make sure we're running inside Merb
 if defined?(Merb::Plugins)
-  Merb::Plugins.add_rakefiles "merb-cache/merbtasks"
-  unless 1.respond_to? :minutes
-    class Numeric
-      def minutes; self * 60; end
-      def from_now(now = Time.now); now + self; end
-    end
+  require "merb-cache" / "cache"
+  require "merb-cache" / "core_ext" / "enumerable"
+  require "merb-cache" / "core_ext" / "hash"
+  require "merb-cache" / "merb_ext" / "controller"
+
+  class Merb::Controller
+    include Merb::Cache::CacheMixin
   end
-  require "merb-cache/merb-cache"
 end

data/spec/merb-cache/cache_spec.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Merb::Cache do
+  before(:each) do
+    Merb::Cache.stores.clear
+    Thread.current[:'merb-cache'] = nil
+  end
+
+  describe ".setup" do
+    it "should have have access to the Merb::Cache.register method from the block" do
+      Merb::Cache.setup do
+        self.respond_to?(:register).should == true
+      end
+    end
+  end
+
+  describe ".register" do
+    it "should add the store name and instance to the store hash" do
+      Merb::Cache.stores.should_not have_key(:foo)
+      Merb::Cache.register(:foo, DummyStore)
+      Merb::Cache.stores.should have_key(:foo)
+    end
+
+    it "should use :default when no name is supplied" do
+      Merb::Cache.stores.should_not have_key(:default)
+      Merb::Cache.register(DummyStore)
+      Merb::Cache.stores.should have_key(:default)
+    end
+    
+    it "should not allow a store to be redefined" do
+      Merb::Cache.register(DummyStore)
+      lambda do
+        Merb::Cache.register(DummyStore)
+      end.should raise_error(Merb::Cache::StoreExists)
+    end
+  end
+  
+  describe ".exists?" do
+    it "should return true if a repository is setup" do
+      Merb::Cache.register(DummyStore)
+      Merb::Cache.register(:store_that_exists, DummyStore)
+      Merb::Cache.exists?(:default).should be_true
+      Merb::Cache.exists?(:store_that_exists).should be_true
+    end
+    
+    it "should return false if a repository is not setup" do
+      Merb::Cache.exists?(:not_here).should be_false
+    end
+  end
+
+  describe ".[]" do
+    it "should clone the stores so to keep them threadsafe" do
+      Merb::Cache.register(DummyStore)
+      Merb::Cache[:default].should_not be_nil
+      Merb::Cache[:default].should_not == Merb::Cache.stores[:default]
+    end
+
+    it "should cache the thread local stores in Thread.current" do
+      Merb::Cache.register(DummyStore)
+      Thread.current[:'merb-cache'].should be_nil
+      Merb::Cache[:default]
+      Thread.current[:'merb-cache'].should_not be_nil
+    end
+
+    it "should create an adhoc store if multiple store names are supplied" do
+      Merb::Cache.register(DummyStore)
+      Merb::Cache.register(:dummy, DummyStore)
+      Merb::Cache[:default, :dummy].class.should == Merb::Cache::AdhocStore
+    end
+    
+    it "should let you create new stores after accessing the old ones" do
+      Merb::Cache.register(DummyStore)
+      Merb::Cache.register(:one, DummyStore)
+      Merb::Cache[:default].should_not be_nil
+      Merb::Cache[:one].should_not be_nil
+      Merb::Cache.register(:two, DummyStore)
+      Merb::Cache[:two].should_not be_nil
+    end
+    
+    it "should raise an error if the cache has not been setup" do
+      Merb::Cache.register(DummyStore)
+      Merb::Cache[:default].should_not be_nil      
+      lambda do
+        Merb::Cache[:does_not_exist]
+      end.should raise_error(Merb::Cache::StoreNotFound)
+    end
+  end
+end

data/spec/merb-cache/core_ext/enumerable_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Enumerable do
+  describe "#capture_first" do
+    it "should return the result of the first block call that is non-nil, not the item sent to the block" do
+      [1, 2, 3].capture_first {|i| i ** i if i % 2 == 0}.should == 4
+    end
+
+    it "should return nil if all block calls are nil" do
+      [1, 2, 3].capture_first {|i| nil }.should be_nil
+    end
+
+    it "should stop calling the block once a block evaluates to non-nil" do
+      lambda {
+        [1, 2, 3].capture_first do |i|
+          raise "#{i} is divisible by 3!" if i % 3 == 0
+          i ** i if i % 2 == 0
+        end
+      }.should_not raise_error
+    end
+  end
+end

data/spec/merb-cache/core_ext/hash_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Hash do
+  
+  describe "to_sha1" do
+    before(:each) do
+      @params = {:id => 1, :string => "string", :symbol => :symbol}
+    end
+    
+    it{@params.should respond_to(:to_sha2)}
+    
+    it "should encode the hash by alphabetic key" do
+      string = ""
+      @params.keys.sort_by{|k| k.to_s}.each{|k| string << @params[k].to_s}
+      digest = Digest::SHA2.hexdigest(string)    
+      @params.to_sha2.should == digest      
+    end  
+  end
+  
+end

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

@@ -0,0 +1,284 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Merb::Cache::CacheMixin do
+  before(:all) do
+    Merb::Cache.stores.clear
+    Thread.current[:'merb-cache'] = nil
+
+    Merb::Cache.register(:default, DummyStore)
+    @dummy = Merb::Cache[:default]
+  end
+
+  describe ".cache!" do
+    it "should add a before filter for all actions" do
+      class CacheAllActionsBeforeCallController < Merb::Controller
+        self.should_receive(:before).with(:_cache_before, :with =>{})
+
+        cache!
+      end
+    end
+
+    it "should add an after filter for all actions" do
+      class CacheAllActionsAfterCallController < Merb::Controller
+        self.should_receive(:after).with(:_cache_after, :with =>{})
+
+        cache!
+      end
+    end
+  end
+
+  describe ".cache" do
+    it "should call .cache_action with each method symbol" do
+      class CacheActionsCallController < Merb::Controller
+        actions = [:first, :second, :third]
+
+        actions.each do |action|
+          self.should_receive(:cache_action).with(action)
+        end
+
+        cache *actions
+      end
+    end
+
+    it "should call .cache_action with the method symbol and conditions hash" do
+      class CacheActionConditionsController < Merb::Controller
+        self.should_receive(:cache_action).with(:action, :conditions => :hash)
+
+        cache :action, :conditions => :hash
+      end
+    end
+  end
+
+  describe ".cache_action" do
+    it "should add the before filter for only the action" do
+      class CacheActionBeforeController < Merb::Controller
+        self.should_receive(:before).with("_cache_action_before", :with => [{}], :only => :action)
+
+        cache_action(:action)
+      end
+    end
+
+    it "should add the after filter for only the action" do
+      class CacheActionAfterController < Merb::Controller
+        self.should_receive(:after).with("_cache_action_after", :with => [{}], :only => :action)
+
+        cache_action(:action)
+      end
+    end
+  end
+
+  before(:each) do
+    class TestController < Merb::Controller; end
+    @controller = TestController.new(fake_request)
+    @controller.stub!(:action_name).and_return :index
+  end
+
+  describe "#_lookup_store" do
+    it "should use the :store entry from the conditions hash" do
+      @controller._lookup_store(:store => :foo_store).should == :foo_store
+    end
+
+    it "should use the :stores entry from the conditions hash" do
+      @controller._lookup_store(:stores => [:foo_store, :bar_store]).should == [:foo_store, :bar_store]
+    end
+
+    it "should default store name if none is supplied in the conditions hash" do
+      @controller._lookup_store.should == Merb::Cache.default_store_name
+    end
+    
+    it "should request the default_cache_store" do
+      @controller.should_receive(:default_cache_store).and_return(Merb::Cache.default_store_name)
+      @controller._lookup_store
+    end
+  end
+
+  describe "#_parameters_and_conditions" do
+    it "should remove the :params entry from the conditions hash" do
+      @controller._parameters_and_conditions(:params => [:foo, :bar]).last.should_not include(:params)
+    end
+
+    it "should remove the :store entry from the conditions hash" do
+      @controller._parameters_and_conditions(:store => :foo_store).last.should_not include(:store)
+    end
+
+    it "should remove the :stores entry from the conditions hash" do
+      @controller._parameters_and_conditions(:stores => [:foo_store, :bar_store]).last.should_not include(:stores)
+    end
+
+    it "should keep an :expires_in entry in the conditions hash" do
+      @controller._parameters_and_conditions(:expire_in => 10).last.should include(:expire_in)
+    end
+
+    it "should move the :params entry to the parameters array" do
+      @controller._parameters_and_conditions(:params => :foo).first.should include(:foo)
+    end
+  end
+
+  describe "#skip_cache!" do
+    it "should set @_skip_cache = true" do
+      lambda { @controller.skip_cache! }.should change { @controller.instance_variable_get(:@_skip_cache) }.to(true)
+    end
+  end
+
+  describe "force_cache!" do
+    class AController < Merb::Controller
+      
+      cache :start
+      
+      def start
+        "START"
+      end      
+    end
+    
+    before(:each) do
+      @mock_store = mock("store", :null_object => true)
+      Merb::Cache.stub!(:[]).and_return(@mock_store)
+      @mock_store.stub!(:read).and_return("CACHED")
+    end
+        
+    it "should try to hit the cache if force_cache is not set" do
+      @mock_store.should_receive(:read).and_return("CACHED")
+      controller = dispatch_to(AController, :start)
+      controller.body.should == "CACHED"
+    end
+    
+    it "should not try to hit the cache if force_cache is set" do
+      @mock_store.should_not_receive(:read)
+      controller = dispatch_to(AController, :start){|c| c.force_cache!}
+      controller.body.should == "START"
+    end
+  end
+
+  describe "eager_cache (Instance Method)" do
+    class HasRun
+      cattr_accessor :has_run
+    end
+    
+    def dispatch_and_wait(*args)
+      @controller = nil
+      Timeout.timeout(2) do
+        until HasRun.has_run do
+          @controller ||= dispatch_to(*args){ |c| 
+            yield c if block_given?
+          }
+        end
+      end
+      @controller
+    end
+    
+    class MyController < Merb::Controller
+      after nil, :only => :start do
+        eager_cache :stop
+      end
+      
+      def start
+        "START"
+      end
+      
+      def stop
+        "STOP"
+      end
+      
+      def inline_call
+        eager_cache :stop
+      end
+    end
+    
+    before(:each) do
+      HasRun.has_run = false
+    end
+    
+    after(:each) do
+      HasRun.has_run = false
+    end
+        
+    it "should run the stop action from a new instance as an after filter" do
+      new_controller = MyController.new(fake_request)
+      dispatch_and_wait(MyController, :start) do |c|
+        MyController.should_receive(:new).and_return(new_controller)
+        new_controller.should_receive(:stop).and_return(HasRun.has_run = true)
+      end
+    end
+    
+    it "should run the stop action from a new instance called inline" do
+      new_controller = MyController.new(fake_request)
+      dispatch_and_wait(MyController, :inline_call) do |c|
+        MyController.should_receive(:new).and_return(new_controller)
+        new_controller.should_receive(:stop).and_return(HasRun.has_run = true)
+      end
+    end
+    
+    it "should not run the stop action if the _set_skip_cache is set to true" do
+      new_controller = MyController.new(fake_request)
+      dispatch_and_wait(MyController, :start) do |c|
+        MyController.stub!(:new).and_return(new_controller)
+        c.skip_cache!
+        new_controller.should_not_receive(:stop)
+        HasRun.has_run = true        
+      end    
+    end
+    
+    it "should set the cache to be forced" do
+      new_controller = MyController.new(fake_request)
+      dispatch_and_wait(MyController, :start) do |c|
+        MyController.should_receive(:new).and_return(new_controller)
+        new_controller.should_receive(:force_cache!)
+        new_controller.should_receive(:stop).and_return(HasRun.has_run = true)   
+      end
+    end
+  end
+
+  describe "#fetch_partial" do
+    it "should pass the template argument to the partial method" do
+      new_controller = MyController.new(fake_request)
+      new_controller.should_receive(:partial).with(:foo, {})
+      new_controller.stub!(:concat)
+
+      new_controller.fetch_partial(:foo)
+    end
+
+    it "should pass the options to the partial method " do
+      new_controller = MyController.new(fake_request)
+      new_controller.should_receive(:partial).with(:foo, :bar => :baz)
+      new_controller.stub!(:concat)
+
+      new_controller.fetch_partial(:foo, :bar => :baz)
+    end
+
+    it "should contain only alpha-numeric characters in the template key" do
+      new_controller = MyController.new(fake_request)
+      new_controller.stub!(:partial)
+      new_controller.stub!(:concat)
+
+      @dummy.should_receive(:fetch).and_return do |template_key, opts, conditions, block|
+        template_key.should =~ /^(?:[a-zA-Z0-9_\/\.-])+/
+      end
+
+      new_controller.fetch_partial('path/to/foo')
+    end
+  end
+
+  describe "#fetch_fragment" do
+    it "should include the filename that defines the fragment proc in the fragment key" do
+      new_controller = MyController.new(fake_request)
+      new_controller.stub!(:concat)
+
+      @dummy.should_receive(:fetch).and_return do |fragment_key, opts, conditions, block|
+        fragment_key.should include(__FILE__)
+      end
+
+      new_controller.fetch_fragment {}
+    end
+
+    it "should include the line number that defines the fragment proc in the fragment key" do
+      new_controller = MyController.new(fake_request)
+      new_controller.stub!(:concat)
+
+      @dummy.should_receive(:fetch).and_return do |fragment_key, opts, conditions, block|
+        fragment_key.should =~ %r{[\d+]}
+      end
+
+      new_controller.fetch_fragment {}
+    end
+  end
+end