bchiu-merb_cache_more 0.9.4

data/lib/merb_cache_more/cache-fragment.rb

@@ -0,0 +1,95 @@
+module Merb::Cache::ControllerInstanceMethods
+  # Mixed in Merb::Controller. Provides methods related to fragment caching
+
+  # Checks whether a cache entry exists
+  #
+  # ==== Parameter
+  # options<String,Hash>:: The options that will be passed to #key_for
+  #
+  # ==== Returns
+  # true if the cache entry exists, false otherwise
+  #
+  # ==== Example
+  #   cached_action?("my_key")
+  def cached?(options)
+    key = Merb::Controller._cache.key_for(options, controller_name)
+    Merb::Controller._cache.store.cached?(key)
+  end
+
+  # ==== Example
+  #   In your view:
+  #   <%- cache("my_key") do -%>
+  #     <%= partial :test, :collection => @test %>
+  #   <%- end -%>
+  def cache(options, from_now = nil, &block)
+    key = Merb::Controller._cache.key_for(options, controller_name)
+    Merb::Controller._cache.store.cache(self, key, from_now, &block)
+  end
+
+  # Fetch data from cache
+  #
+  # ==== Parameter
+  # options<String,Hash>:: The options that will be passed to #key_for
+  #
+  # ==== Returns
+  # data<Object,NilClass>::
+  #   nil is returned if the cache entry is not found
+  #
+  # ==== Example
+  #   if cache_data = cache_get("my_key")
+  #     @var1, @var2 = *cache_data
+  #   else
+  #     @var1 = MyModel.big_query1
+  #     @var2 = MyModel.big_query2
+  #     cache_set("my_key", nil, [@var1, @var2])
+  #   end
+  def cache_get(options)
+    key = Merb::Controller._cache.key_for(options, controller_name)
+    Merb::Controller._cache.store.cache_get(key)
+  end
+
+  # Store data to cache
+  #
+  # ==== Parameter
+  # options<String,Hash>:: The options that will be passed to #key_for
+  # object<Object>:: The object(s) to put in cache
+  # from_now<~minutes>::
+  #   The number of minutes (from now) the cache should persist
+  #
+  # ==== Returns
+  # data<Object,NilClass>::
+  #   nil is returned if the cache entry is not found
+  #
+  # ==== Example
+  #   if cache_data = cache_get("my_key")
+  #     @var1, @var2 = *cache_data
+  #   else
+  #     @var1 = MyModel.big_query1
+  #     @var2 = MyModel.big_query2
+  #     cache_set("my_key", nil, [@var1, @var2])
+  #   end
+  def cache_set(options, object, from_now = nil)
+    key = Merb::Controller._cache.key_for(options, controller_name)
+    Merb::Controller._cache.store.cache_set(key, object, from_now)
+  end
+
+  # Expires the entry identified by the key computed after the parameters
+  #
+  # ==== Parameter
+  # options<String,Hash>:: The options that will be passed to #key_for
+  #
+  # ==== Examples
+  #   expire("my_key")
+  #   expire(:key => "my_", :match => true)
+  #   expire(:key => "my_key", :params => [session[:me], params[:ref]])
+  def expire(options)
+    Merb::Controller._cache.expire_key_for(options, controller_name) do |key, match|
+      if match
+        Merb::Controller._cache.store.expire_match(key)
+      else
+        Merb::Controller._cache.store.expire(key)
+      end
+    end
+    true
+  end
+end

data/lib/merb_cache_more/cache-page.rb

@@ -0,0 +1,248 @@
+class Merb::Cache
+  cattr_accessor :cached_pages
+  self.cached_pages = {}
+end
+
+module Merb::Cache::ControllerClassMethods
+  # Mixed in Merb::Controller. Provides class methods related to page caching
+  # Page caching is mostly action caching with file backend using its own output directory of .html files
+
+  # Register the action for page caching
+  #
+  # ==== Parameters
+  # action<Symbol>:: The name of the action to register
+  # from_now<~minutes>::
+  #   The number of minutes (from now) the cache should persist
+  # options<Hash>::
+  #   Key formats :format => :snake|:tree|:hash|:query or nil for default
+  #   Custom format :format => ":param1/:param2-and_:param3"
+  #   Params :params => [params to include] or false to disable
+  #
+  # ==== Examples
+  #   cache_page :mostly_static
+  #   cache_page :barely_dynamic, 10
+  #   cache_page :barely_dynamic, 10, {:format => :hash, :params => [:id, :name]}
+  #   cache_page :barely_dynamic, :format => ":param1/:param2-and_:param3[key]"
+  def cache_page(action, from_now = nil, opts = {})
+    from_now, opts = nil, from_now if Hash === from_now
+
+    cache_opts = {:format => opts[:format], :params => opts[:params]}
+    opts.delete(:format); opts.delete(:params); opts.delete(:exclude)
+    
+    before("cache_#{action}_before", opts.merge(:only => action, :with => [cache_opts]))
+    after("cache_#{action}_after", opts.merge(:only => action, :with => [cache_opts]))
+    alias_method "cache_#{action}_before", :cache_page_before
+    alias_method "cache_#{action}_after", :cache_page_after
+    
+    _pages = Merb::Cache.cached_pages[controller_name] ||= {}
+    _pages[action] = [from_now, 0]
+  end
+
+  # Register actions for page caching (before and after filters)
+  #
+  # ==== Parameter
+  # actions<Symbol,Array[Symbol,~minutes,Hash]>:: See #cache_page
+  #
+  # ==== Example
+  #   cache_pages :mostly_static,  :barely_dynamic
+  #   cache_pages :mostly_static,  [:barely_dynamic, 10]
+  #   cache_pages :barely_dynamic, [:barely_dynamic, 10, :format => :hash]
+  #   cache_pages :barely_dynamic, [:barely_dynamic, 10, :params => [:id, :name]]
+  #   cache_pages :all, 10, :exclude => [:show], :format => :snake, :params => [:id, :name]
+  def cache_pages(*pages)
+    config = Merb::Plugins.config[:merb_cache]
+    
+    if pages[0] == :all
+      from_now = Hash === pages[1] ? config[:cache_page_ttl] : pages[1]
+      opts     = Hash === pages[1] ? pages[1] : pages[2] || {}
+      excludes = opts[:exclude] || []
+      pages    = self.instance_methods(false).map {|action|
+        [action.to_sym, from_now, opts] unless excludes.include?(action.to_sym)
+      }.compact
+    end
+
+    pages.each do |page_opts|
+      if Array === page_opts
+        action   = page_opts[0]
+        from_now = Hash === page_opts[1] ? config[:cache_page_ttl] : page_opts[1]
+        opts     = Hash === page_opts[1] ? page_opts[1] : page_opts[2]
+      else
+        action   = page_opts
+        from_now = config[:cache_page_ttl]
+        opts     = {}
+      end
+      cache_page(action, from_now, opts||{})
+    end
+    true
+  end
+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
+  # options<String,Hash>:: The options that will be passed to #key_for
+  #
+  # ==== Returns
+  # true if the cache entry exists, false otherwise
+  #
+  # ==== 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)
+    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
+  #
+  # ==== Parameter
+  # options<String,Hash>:: The options that will be passed to #expire_key_for
+  #
+  # ==== Examples (See Merb::Cache#expire_key_for for more options)
+  #   # will expire path/to/page/cache/news/show/1.html
+  #   expire_page(:key => url(:news,News.find(1)))
+  #
+  #   # will expire path/to/page/cache/news/show.html
+  #   expire_page(:action => 'show', :controller => 'news')
+  #
+  #   # will expire path/to/page/cache/news/show*
+  #   expire_page(:action => 'show', :match => true)
+  #
+  #   # will expire path/to/page/cache/news/show.js
+  #   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
+        extension = options[:extension] || DEFAULT_PAGE_EXTENSION
+        files = config_dir / "#{key}.#{extension}"
+      end
+      FileUtils.rm_rf(files)
+    end
+    true
+  end
+
+  # Expires all the pages stored in config[:cache_html_directory]
+  def expire_all_pages
+    FileUtils.rm_rf(Dir.glob(Merb::Controller._cache.config[:cache_html_directory] / "*"))
+  end
+
+  # You can call this method if you need to prevent caching the page
+  # after it has been rendered.
+  def abort_cache_page
+    @capture_page = false
+  end
+
+  private
+
+  # Called by the before and after filters. Stores or recalls a cache entry.
+  # The name used for the cache file is based on request.path
+  # If the name ends with "/" then it is removed
+  # If the name is "/" then it will be replaced by "index"
+  #
+  # ==== Parameters
+  # data<String>:: the data to put in cache
+  #
+  # ==== Examples
+  #   All the file are written to config[:cache_html_directory]
+  #   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, opts = {})
+    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?
+
+    _format = opts[:format] || Merb::Controller._cache.config[:cache_key_format]
+    _params = opts[:params]==false ? nil : Merb::Request.query_parse(request.query_string, '&', true)
+    _params.delete_if {|k,v| !opts[:params].include?(k.to_sym) } if _params && opts[:params]
+ 
+    key = Merb::Controller._cache.key_for({:key => path, :params => _params, :format => _format})
+
+    no_format = params[:format].nil? || params[:format].empty?
+    ext = "." + (no_format ? DEFAULT_PAGE_EXTENSION : params[:format])
+    ext = nil if File.extname(key) == ext
+    cache_file = Merb::Controller._cache.config[:cache_html_directory] / "#{key}#{ext}"
+
+    if data
+      cache_directory = File.dirname(cache_file)
+      FileUtils.mkdir_p(cache_directory)
+      _expire_in = pages[action][0]
+      pages[action][1] = _expire_in.minutes.from_now unless _expire_in.nil?
+      cache_write_page(cache_file, data)
+      Merb.logger.info("cache: set (#{path})")
+    else
+      @capture_page = false
+      if File.file?(cache_file)
+        _data = cache_read_page(cache_file)
+        _expire_in, _expire_at = pages[action]
+        if _expire_in.nil? || Time.now.to_i < _expire_at.to_i
+          Merb.logger.info("cache: hit (#{path})")
+          throw(:halt, _data)
+        end
+        FileUtils.rm_f(cache_file)
+      end
+      @capture_page = true
+    end
+    true
+  end
+
+  # Read data from a file using exclusive lock
+  #
+  # ==== Parameters
+  # cache_file<String>:: the full path to the file
+  #
+  # ==== Returns
+  # data<String>:: the data that has been read from the file
+  def cache_read_page(cache_file)
+    _data = nil
+    File.open(cache_file, "r") do |cache_data|
+      cache_data.flock(File::LOCK_EX)
+      _data = cache_data.read
+      cache_data.flock(File::LOCK_UN)
+    end
+    _data
+  end
+
+  # Write data to a file using exclusive lock
+  #
+  # ==== Parameters
+  # cache_file<String>:: the full path to the file
+  # data<String>:: the data that will be written to the file
+  def cache_write_page(cache_file, data)
+    File.open(cache_file, "w+") do |cache_data|
+      cache_data.flock(File::LOCK_EX)
+      cache_data.write(data)
+      cache_data.flock(File::LOCK_UN)
+    end
+    true
+  end
+
+  # before filter
+  def cache_page_before(opts)
+    # recalls a cached entry or set @capture_page to true in order
+    # to grab the response in the after filter
+    _cache_page(nil, opts)
+  end
+
+  # after filter
+  def cache_page_after(opts)
+    # takes the body of the response
+    # if the cache entry expired, if it doesn't exist or status is 200
+    _cache_page(body, opts) if @capture_page && status == 200
+  end
+end

data/lib/merb_cache_more/cache-store/database-activerecord.rb

@@ -0,0 +1,88 @@
+module Merb::Cache::DatabaseStore::ActiveRecord
+  # Module that provides ActiveRecord support for the database backend
+
+  # The cache model migration
+  class CacheMigration < ActiveRecord::Migration
+    def self.up
+      create_table (Merb::Controller._cache.config[:table_name]), :primary_key => :ckey do |t|
+        t.column    :ckey, :string
+        t.column    :data, :text
+        t.datetime  :expire, :default => nil
+      end
+    end
+
+    def self.down
+      drop_table Merb::Controller._cache.config[:table_name]
+    end
+  end
+
+  # The cache model
+  class CacheModel < ActiveRecord::Base
+    set_table_name Merb::Controller._cache.config[:table_name]
+
+    # Fetch data from the database using the specified key
+    # The entry is deleted if it has expired
+    #
+    # ==== Parameter
+    # key<Sting>:: The key identifying the cache entry
+    #
+    # ==== Returns
+    # data<String, NilClass>::
+    #   nil is returned whether the entry expired or was not found
+    def self.cache_get(key)
+      if entry = self.find(:first, :conditions => ["ckey=?", key])
+        return entry.data if entry.expire.nil? || Time.now < entry.expire
+        self.expire(key)
+      end
+      nil
+    end
+
+    # Store data to the database using the specified key
+    #
+    # ==== Parameters
+    # key<Sting>:: The key identifying the cache entry
+    # data<String>:: The data to be put in cache
+    # expire<~minutes>::
+    #   The number of minutes (from now) the cache should persist
+    # get<Boolean>::
+    #   used internally to behave like this
+    #   - when set to true, perform update_or_create on the cache entry
+    #   - when set to false, force creation of the cache entry
+    def self.cache_set(key, data, expire = nil, get = true)
+      attributes = {:ckey => key, :data => data, :expire => expire }
+      if get
+        entry = self.find(:first, :conditions => ["ckey=?",key])
+        entry.nil? ? self.create(attributes) : entry.update_attributes(attributes)
+      else
+        self.create(attributes)
+      end
+      true
+    end
+
+    # Expire the cache entry identified by the given key
+    #
+    # ==== Parameter
+    # key<Sting>:: The key identifying the cache entry
+    def self.expire(key)
+      self.delete_all(["ckey=?", key])
+    end
+
+    # Expire the cache entries matching the given key
+    #
+    # ==== Parameter
+    # key<Sting>:: The key matching the cache entries
+    def self.expire_match(key)
+      self.delete_all(["ckey like ?", key + "%"])
+    end
+
+    # Expire all the cache entries
+    def self.expire_all
+      self.delete_all
+    end
+
+    # Perform auto-migration in case the table is unknown in the database
+    def self.check_table
+      CacheMigration.up unless self.table_exists?
+    end
+  end
+end

data/lib/merb_cache_more/cache-store/database-datamapper.rb

@@ -0,0 +1,79 @@
+module Merb::Cache::DatabaseStore::DataMapper
+  # Module that provides DataMapper support for the database backend
+
+  # The cache model
+  class CacheModel < DataMapper::Base
+    set_table_name Merb::Controller._cache.config[:table_name]
+    property  :ckey, :string, :length => 255, :lazy => false, :key => true
+    property  :data, :text, :lazy => false
+    property  :expire, :datetime, :default => nil
+
+    # Fetch data from the database using the specified key
+    # The entry is deleted if it has expired
+    #
+    # ==== Parameter
+    # key<Sting>:: The key identifying the cache entry
+    #
+    # ==== Returns
+    # data<String, NilClass>::
+    #   nil is returned whether the entry expired or was not found
+    def self.cache_get(key)
+      if entry = self.first(key)
+        return entry.data if entry.expire.nil? || DateTime.now < entry.expire
+        entry.destroy!
+      end
+      nil
+    end
+
+    # Store data to the database using the specified key
+    #
+    # ==== Parameters
+    # key<Sting>:: The key identifying the cache entry
+    # data<String>:: The data to be put in cache
+    # expire<~minutes>::
+    #   The number of minutes (from now) the cache should persist
+    # get<Boolean>::
+    #   used internally to behave like this:
+    #   - when set to true, perform update_or_create on the cache entry
+    #   - when set to false, force creation of the cache entry
+    def self.cache_set(key, data, expire = nil, get = true)
+      attributes = {:ckey => key, :data => data,
+        :expire => expire.nil? ? nil : expire.to_s_db }
+      if get
+        entry = self.first(key)
+        entry.nil? ? self.create(attributes) : entry.update_attributes(attributes)
+      else
+        self.create(attributes)
+      end
+      true
+    end
+
+    # Expire the cache entry identified by the given key
+    #
+    # ==== Parameter
+    # key<Sting>:: The key identifying the cache entry
+    def self.expire(key)
+      entry = self.first(key)
+      entry.destroy! unless entry.nil?
+    end
+
+    # Expire the cache entries matching the given key
+    #
+    # ==== Parameter
+    # key<Sting>:: The key matching the cache entries
+    def self.expire_match(key)
+      #FIXME
+      database.execute("DELETE FROM #{self.table.name} WHERE ckey LIKE '#{key}%'")
+    end
+
+    # Expire all the cache entries
+    def self.expire_all
+      self.truncate!
+    end
+
+    # Perform auto-migration in case the table is unknown in the database
+    def self.check_table
+      self.auto_migrate! unless self.table.exists?
+    end
+  end
+end