bchiu-merb_cache_more 0.9.4

data/lib/merb_cache_more/merbtasks.rb

@@ -0,0 +1,6 @@
+namespace :merb_cache_more do
+  desc "Do something for merb_cache_more"
+  task :default do
+    puts "merb_cache_more doesn't do anything"
+  end
+end

data/lib/merb_cache_more/request.rb

@@ -0,0 +1,59 @@
+module Merb
+  class Request
+    class << self
+      # ==== Parameters
+      # value<Array, Hash, Dictionary ~to_s>:: The value for the query string.
+      # prefix<~to_s>:: The prefix to add to the query string keys.
+      #
+      # ==== Returns
+      # String:: The query string.
+      #
+      # ==== Alternatives
+      # If the value is a string, the prefix will be used as the key.
+      #
+      # ==== Examples
+      #   params_to_query_string(10, "page")
+      #     # => "page=10"
+      #   params_to_query_string({ :page => 10, :word => "ruby" })
+      #     # => "page=10&word=ruby"
+      #   params_to_query_string({ :page => 10, :word => "ruby" }, "search")
+      #     # => "search[page]=10&search[word]=ruby"
+      #   params_to_query_string([ "ice-cream", "cake" ], "shopping_list")
+      #     # => "shopping_list[]=ice-cream&shopping_list[]=cake"
+      def params_to_query_string(value, prefix = nil)
+        case value
+        when Array
+          value.map { |v|
+            params_to_query_string(v, "#{prefix}[]")
+          } * "&"
+        when Hash, Dictionary
+          value.map { |k, v|
+            params_to_query_string(v, prefix ? "#{prefix}[#{Merb::Request.escape(k)}]" : Merb::Request.escape(k))
+          } * "&"
+        else
+          "#{prefix}=#{Merb::Request.escape(value)}"
+        end
+      end
+      
+      # ==== Parameters
+      # qs<String>:: The query string.
+      # d<String>:: The query string divider. Defaults to "&".
+      # preserve_order<Boolean>:: Preserve order of args. Defaults to false.
+      #
+      # ==== Returns
+      # Mash:: The parsed query string (Dictionary if preserve_order is set).
+      #
+      # ==== Examples
+      #   query_parse("bar=nik&post[body]=heya")
+      #     # => { :bar => "nik", :post => { :body => "heya" } }
+      def query_parse(qs, d = '&;', preserve_order = false)
+        qh = preserve_order ? Dictionary.new : {}
+        (qs||'').split(/[#{d}] */n).inject(qh) { |h,p| 
+          key, value = unescape(p).split('=',2)
+          normalize_params(h, key, value)
+        }
+        preserve_order ? qh : qh.to_mash
+      end
+    end
+  end
+end    

data/lib/merb_cache_more/request_helper.rb

@@ -0,0 +1,40 @@
+module Merb
+  module Test
+    module RequestHelper
+      # Dispatches an action to the given class. This bypasses the router and is
+      # suitable for unit testing of controllers.
+      #
+      # ==== Parameters
+      # controller_klass<Controller>::
+      #   The controller class object that the action should be dispatched to.
+      # action<Symbol>:: The action name, as a symbol.
+      # params<Hash>::
+      #   An optional hash that will end up as params in the controller instance.
+      # env<Hash>::
+      #   An optional hash that is passed to the fake request. Any request options
+      #   should go here (see +fake_request+), including :req or :post_body
+      #   for setting the request body itself.
+      # &blk::
+      #   The controller is yielded to the block provided for actions *prior* to
+      #   the action being dispatched.
+      #
+      # ==== Example
+      #   dispatch_to(MyController, :create, :name => 'Homer' ) do
+      #     self.stub!(:current_user).and_return(@user)
+      #   end
+      #
+      # ==== Notes
+      # Does not use routes.
+      #
+      #---
+      # @public
+      def dispatch_to(controller_klass, action, params = {}, env = {}, &blk)
+        action = action.to_s
+        request_body = { :post_body => env[:post_body], :req => env[:req] }
+        env = env.merge(:query_string => Merb::Request.params_to_query_string(params)) unless env.key?('QUERY_STRING')
+        request = fake_request(env, request_body)
+        dispatch_request(request, controller_klass, action, &blk)
+      end
+    end
+  end
+end

data/spec/cache_action_params_spec.rb

@@ -0,0 +1,76 @@
+describe "cache_action with params" do
+  
+  qs = "p1=abc&p2=456&p3=ghi"
+
+  it "should cache action (action3) with params in default format" do
+    c = get("/cache_controller/action3", {}, {:query_string => qs})
+    c.body.strip.should == "test action3"
+    c.cached?(:key => "/cache_controller/action3/p1_abc_p2_456_p3_ghi").should be_true
+    c.cache_get(:key => "/cache_controller/action3/p1_abc_p2_456_p3_ghi").should == "test action3"
+  end
+
+  it "should expire action (action3) with params in default format" do
+    c = get("/cache_controller/action3", {}, {:query_string => qs})
+    c.expire_action(:key => "/cache_controller/action3/p1_abc_p2_456_p3_ghi")
+    c.cache_get(:key => "/cache_controller/action3/p1_abc_p2_456_p3_ghi").should be_nil
+  end
+  
+  it "should cache action (action3) with full path and params in default format" do
+    c = get("/cache_controller/action3/foo/bar", {}, {:query_string => qs})
+    c.body.strip.should == "test action3"
+    c.cached?(:key => "/cache_controller/action3/foo/bar/p1_abc_p2_456_p3_ghi").should be_true
+    c.cache_get(:key => "/cache_controller/action3/foo/bar/p1_abc_p2_456_p3_ghi").should == "test action3"
+  end
+  
+  it "should expire action (action3) with full path and params in default format" do
+    c = get("/cache_controller/action3/foo/bar", {}, {:query_string => qs})
+    c.expire_action(:key => "/cache_controller/action3/foo/bar/p1_abc_p2_456_p3_ghi")
+    c.cache_get(:key => "/cache_controller/action3/foo/bar/p1_abc_p2_456_p3_ghi").should be_nil
+  end
+
+  it "should cache action (action12) with specific params" do
+    c = get("/cache_controller/action12", {}, {:query_string => qs})
+    c.cached?(:key => "/cache_controller/action12/p1_abc_p2_456").should be_true
+    c.cache_get(:key => "/cache_controller/action12/p1_abc_p2_456").should == "test action12"
+  end
+
+  it "should expire action (action12) with specific params" do
+    c = get("/cache_controller/action12", {}, {:query_string => qs})
+    c.expire_action(:key => "/cache_controller/action12/p1_abc_p2_456")
+    c.cache_get(:key => "/cache_controller/action12/p1_abc_p2_456").should be_nil
+  end
+  
+  it "should cache actions with params in every key format" do
+    c = get("/cache_controller/action13", {}, {:query_string => qs}) # snake
+    c.cached?(:key => "/cache_controller/action13/abc_456_ghi").should be_true
+  
+    c = get("/cache_controller/action14", {}, {:query_string => qs}) # tree
+    c.cached?(:key => "/cache_controller/action14/abc/456/ghi").should be_true
+  
+    c = get("/cache_controller/action15", {}, {:query_string => qs}) # hash
+    c.cached?(:key => "/cache_controller/action15/" + Digest::MD5.hexdigest("p1abcp2456p3ghi")).should be_true
+  
+    c = get("/cache_controller/action16", {}, {:query_string => qs}) # query
+    c.cached?(:key => "/cache_controller/action16/p1=abc&p2=456&p3=ghi").should be_true
+  
+    c = get("/cache_controller/action17", {}, {:query_string => qs}) # custom
+    c.cached?(:key => "/cache_controller/action17/abc/456_and_ghi").should be_true
+  end
+
+  it "should expire actions with params in every key format" do
+    CACHE.expire_action(:key => "/cache_controller/action13/abc_456_ghi")
+    CACHE.cached?(:key => "/cache_controller/action13/abc_456_ghi").should be_false
+
+    CACHE.expire_action(:key => "/cache_controller/action14/abc/456/ghi")
+    CACHE.cached?(:key => "/cache_controller/action14/abc/456/ghi").should be_false
+
+    CACHE.expire_action(:key => "/cache_controller/action15/" + Digest::MD5.hexdigest("p1abcp2456p3ghi"))
+    CACHE.cached?(:key => "/cache_controller/action15/" + Digest::MD5.hexdigest("p1abcp2456p3ghi")).should be_false
+
+    CACHE.expire_action(:key => "/cache_controller/action16/p1=abc&p2=456&p3=ghi")
+    CACHE.cached?(:key => "/cache_controller/action16/p1=abc&p2=456&p3=ghi").should be_false
+
+    CACHE.expire_action(:key => "/cache_controller/action17/abc/456_and_ghi")
+    CACHE.cached?(:key => "/cache_controller/action17/abc/456_and_ghi").should be_false
+  end
+end

data/spec/cache_action_spec.rb

@@ -0,0 +1,137 @@
+describe "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), :format => :tree).should be_false
+    c = get("/cache_controller/action4/path/to/nowhere/")
+    c.cached_action?(:action => "action4", :params => %w(path to nowhere), :format => :tree).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), :format => :tree).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), :format => :tree)
+    CACHE.cached_action?(:action => "action4", :params => %w(id1 id2), :format => :tree).should be_false
+
+    c = get("/cache_controller/action4/id1/id2")
+    CACHE.expire_action(:action => "action4", :match => true, :format => :tree)
+    CACHE.cached_action?(:action => "action4", :params => %w(id1 id2), :format => :tree).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), :format => :tree).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), :format => :tree).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), :format => :tree).should be_false
+
+    c = get("/cache_controller/action4/id1/id2")
+    CACHE.expire_action(:action => "action4", :controller => "cache_controller", :params => %w(id1 id2), :format => :tree)
+    CACHE.cached_action?(:action => "action4", :controller => "cache_controller", :params => %w(id1 id2), :format => :tree).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), :format => :tree)
+    CACHE.cached_action?(:key => "/cache_controller/action4", :params => %w(id1 id2), :format => :tree).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
+
+  it "should allow :if conditions with procs" do
+    c = get("/cache_controller/action8")
+    CACHE.cached_action?(:key => "/cache_controller/action8").should be_false
+
+    c = get("/cache_controller/action8/cache")
+    CACHE.cached_action?(:key => "/cache_controller/action8/cache").should be_true
+  end
+
+  it "should allow :unless conditions with procs" do
+    c = get("/cache_controller/action9")
+    CACHE.cached_action?(:key => "/cache_controller/action9").should be_false
+
+    c = get("/cache_controller/action9/cache")
+    CACHE.cached_action?(:key => "/cache_controller/action9/cache").should be_true
+  end
+
+  it "should allow :if conditions with symbols" do
+    c = get("/cache_controller/action10")
+    CACHE.cached_action?(:key => "/cache_controller/action10").should be_false
+
+    c = get("/cache_controller/action10/cache")
+    CACHE.cached_action?(:key => "/cache_controller/action10/cache").should be_true
+  end
+
+  it "should allow :unless conditions with symbols" do
+    c = get("/cache_controller/action11")
+    CACHE.cached_action?(:key => "/cache_controller/action11").should be_false
+
+    c = get("/cache_controller/action11/cache")
+    CACHE.cached_action?(:key => "/cache_controller/action11/cache").should be_true
+  end
+end

data/spec/cache_controller.rb

@@ -0,0 +1,85 @@
+class CacheController < Merb::Controller
+  self._template_root = File.dirname(__FILE__) / "views"
+  before :fix_query_string
+
+  cache_action :action3
+  cache_action :action4, 0.05
+  #cache_actions :action3, [:action4, 0.05]
+
+  cache_page :action5
+  cache_page :action6, 0.05
+  #cache_pages :action5, [:action6, 0.05]
+  cache_page :action7
+  
+  cache_action :action8, 0.05, :if => proc {|controller| !controller.params[:id].empty?}
+  cache_action :action9, 0.05, :unless => proc {|controller| controller.params[:id].empty?}
+  cache_action :action10, :if => :non_empty_id?
+  cache_action :action11, :unless => :empty_id?
+
+  cache_action :action12, :params => [:p1, :p2]
+  cache_action :action13, :format => :snake
+  cache_action :action14, :format => :tree
+  cache_action :action15, :format => :hash
+  cache_action :action16, :format => :query
+  cache_action :action17, :format => ":p1/:p2_and_:p3"
+
+  cache_page :action18, :params => [:p1, :p2]
+  cache_page :action19, :format => :snake
+  cache_page :action20, :format => :tree
+  cache_page :action21, :format => :hash
+  cache_page :action22, :format => :query
+  cache_page :action23, :format => ":p1/:p2_and_:p3"
+
+  def fix_query_string
+    params[:id] ||= ''
+    p = Merb::Request.query_parse(request.query_string, '&', true)
+    p.delete_if {|k,v| [:id,:format].include?(k.to_sym) }
+    request.env['QUERY_STRING'] = Merb::Request.params_to_query_string(p)
+  end
+
+  def index; "test index" end
+  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 action8; "test action8" end
+  def action9; "test action9" end
+  def action10; "test action10" end
+  def action11; "test action11" end
+  def action12; "test action12" end
+  def action13; "test action13" end
+  def action14; "test action14" end
+  def action15; "test action15" end
+  def action16; "test action16" end
+  def action17; "test action17" end
+  def action18; "test action18" end
+  def action19; "test action19" end
+  def action20; "test action20" end
+  def action21; "test action21" end
+  def action22; "test action22" end
+  def action23; "test action23" 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 empty_id?; params[:id].empty? end
+
+  def non_empty_id?; !empty_id? end
+end

data/spec/cache_fragment_spec.rb

@@ -0,0 +1,100 @@
+# TODO
+# more specs for fragment caching:
+# cache_get, cache_set, cached?, cache, expire
+
+describe "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