benschwarz-merb-cache 1.0.0

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 = {})
+      @stores.any? {|c| c.writable?(key, parameters, conditions)}
+    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.any? {|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/mintcache_store.rb

@@ -0,0 +1,75 @@
+module Merb::Cache
+  class MintCacheStore < AbstractStrategyStore
+    
+    def writable?(key, parameters = {}, conditions = {})
+      @stores.capture_first {|s| s.writable?(key, parameters, conditions)}
+    end
+    
+    def read(key, parameters = {})
+      cache_read = @stores.capture_first {|c| c.read(key, parameters)}
+      return cache_read || read_mint_cache(key, parameters)
+    end
+    
+    def write(key, data = nil, parameters = {}, conditions = {})
+      if writable?(key, parameters, conditions)
+        write_mint_cache(key, data, parameters, conditions)
+        @stores.capture_first {|c| c.write(key, data, parameters, conditions)}
+      end
+    end
+    
+    # if you're wrapping multiple stores in a strategy store, 
+    # it will write to all the wrapped stores, not just the first store that is successful
+    def write_all(key, data = nil, parameters = {}, conditions = {})
+      if writable?(key, parameters, conditions)
+        key_write = @stores.map {|c| c.write_all(key, data, parameters, conditions)}.all?
+        validity_write = @stores.map {|c| c.write_all(validity_key(key), data, parameters, conditions)}.all?
+        data_write = @stores.map {|c| c.write_all(data_key(key), data, parameters, conditions)}.all?
+
+        return (key_write and validity_write and data_write) ? true : false
+      end
+    end
+    
+    def fetch(key, parameters = {}, conditions = {}, &blk)
+      wrapper_blk = lambda { blk.call }
+      cache_read = read(key, parameters) || @stores.capture_first {|s| s.fetch(key, parameters, conditions, &wrapper_blk)}
+      return cache_read || read_mint_cache(key, parameters)
+    end
+    
+    def exists?(key, parameters = {})
+      @stores.any?{|store| store.exists?(key, parameters)} || @stores.any? {|store| store.exists?(validity_key(key), parameters)}
+    end
+    
+    def delete(key, parameters = {})
+      [key, validity_key(key), data_key(key)].map{|k| @stores.map {|c| c.delete(k, parameters)} }.flatten.any?
+    end
+    
+    def delete_all!
+      @stores.map {|c| c.delete_all! }.all?
+    end
+    
+    private
+    def validity_key(key); "#{key}_validity"; end
+    def data_key(key); "#{key}_data"; end
+    
+    def write_mint_cache(key, data = nil, parameters = {}, conditions = {})
+      expiry = (conditions[:expire_in].nil?) ? 3600 : (conditions[:expire_in] * 2)
+      
+      @stores.capture_first {|c| c.write(validity_key(key), (Time.now + expiry), parameters, conditions.merge({:expire_in => expiry}))}
+      @stores.capture_first {|c| c.write(data_key(key), data, parameters, conditions.merge({:expire_in => expiry}))}
+    end
+    
+    def read_mint_cache(key, parameters = {})
+      validity_time = @stores.capture_first {|c| c.read(validity_key(key), parameters)}
+      data = @stores.capture_first {|c| c.read(data_key(key), parameters)}
+      
+      unless validity_time.nil?
+        if Time.now < validity_time
+          write(key, data, parameters)
+          return nil
+        end
+      end
+      
+      return data
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+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)
+        return @stores.capture_first {|s| s.write(normalize(dispatch), data || dispatch.body, {}, conditions)}
+      else
+        return false
+      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)
+        return @stores.any? {|s| s.exists?(normalize(dispatch), {})}
+      else
+        return false
+      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.any? {|c| x = 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/spec/merb-cache/cache_request_spec.rb

@@ -0,0 +1,78 @@
+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 "#env" do
+    it "can be specified in the constructor" do
+      Merb::Cache::CacheRequest.new('', {}, 'foo' => 'bar').env['foo'].should == 'bar'
+    end
+  end
+
+  describe "#env[Merb::Const::REQUEST_URI]" do
+    it "should give the uri with the query string" do
+      Merb::Cache::CacheRequest.new('/test?q=1').env[Merb::Const::REQUEST_URI].should == '/test?q=1'
+    end
+  end
+
+  describe "#host" do
+    it "should return the correct host if the uri is absolute" do
+      Merb::Cache::CacheRequest.new('http://example.org:453/').host.should == "example.org:453"
+    end
+  end
+
+  describe "#method" do
+    it "should be :get by default" do
+      Merb::Cache::CacheRequest.new('/test?q=1').method.should == :get
+    end
+    
+    it "should be set by the :method parameter" do
+      Merb::Cache::CacheRequest.new('/test?q=1', {}, :method => :put).method.should == :put
+    end
+  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
+    
+    it "should return the path without the query string" do
+      Merb::Cache::CacheRequest.new('/path/to/foo?q=1').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 "#subdomains" do 
+    it "should return the correct subdomains if the uri is absolute" do
+      Merb::Cache::CacheRequest.new('http://test.example.org:453/').subdomains.should == ['test']
+    end
+  end
+
+  describe "#uri" do
+    it "should give the uri without the query string" do
+      Merb::Cache::CacheRequest.new('/test?q=1').uri.should == '/test'
+    end
+  end
+  
+  it "should be compatiple with page store's way of detecting the presence of a query string" do
+    request = Merb::Cache::CacheRequest.new("/test?q=1")
+    (request.env[Merb::Const::REQUEST_URI] == request.uri).should be_false
+    request = Merb::Cache::CacheRequest.new("/test")
+    (request.env[Merb::Const::REQUEST_URI] == request.uri).should be_true
+  end
+
+  it "should not setup the uri if no uri is provided and env[Merb::Const::REQUEST_URI] is not nil" do
+    Merb::Cache::CacheRequest.new(nil, {}, {Merb::Const::REQUEST_URI => '/test'}).uri.should == '/test'
+  end
+
+  it "should setup a default env" do
+    Merb::Cache::CacheRequest.new('').env.should_not be_empty
+  end
+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,26 @@
+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
+    
+    it "should return the first item 'captured'" do
+      [1, 2, 3].capture_first{|i| i }.should == 1
+    end
+  end
+end