thorero-cache 0.9.4

data/lib/merb-cache/cache-page.rb

@@ -0,0 +1,203 @@
+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
+  #
+  # ==== Examples
+  #   cache_page :mostly_static
+  #   cache_page :barely_dynamic, 10
+  def cache_page(action, from_now = nil)
+    cache_pages([action, from_now])
+  end
+
+  # Register actions for page caching (before and after filters)
+  #
+  # ==== Parameter
+  # pages<Symbol,Array[Symbol,~minutes]>:: See #cache_page
+  #
+  # ==== Example
+  #   cache_pages :mostly_static, [:barely_dynamic, 10]
+  def cache_pages(*pages)
+    if pages.any? && !Merb::Cache.cached_pages.key?(controller_name)
+      before(:cache_page_before)
+      after(:cache_page_after)
+    end
+    pages.each do |action, from_now|
+      _pages = Merb::Cache.cached_pages[controller_name] ||= {}
+      _pages[action] = [from_now, 0]
+    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)
+    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?
+    no_format = params[:format].nil? || params[:format].empty?
+    ext = "." + (no_format ? DEFAULT_PAGE_EXTENSION : params[:format])
+    ext = nil if File.extname(path) == ext
+    cache_file = Merb::Controller._cache.config[:cache_html_directory] / "#{path}#{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
+    # recalls a cached entry or set @capture_page to true in order
+    # to grab the response in the after filter
+    _cache_page
+  end
+
+  # after filter
+  def cache_page_after
+    # takes the body of the response
+    # if the cache entry expired, if it doesn't exist or status is 200
+    _cache_page(body) if @capture_page && status == 200
+  end
+end

data/lib/merb-cache/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/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

data/lib/merb-cache/cache-store/database-sequel.rb

@@ -0,0 +1,78 @@
+module Merb::Cache::DatabaseStore::Sequel
+  # Module that provides Sequel support for the database backend
+
+  # The cache model
+  class CacheModel < Sequel::Model(Merb::Controller._cache.config[:table_name].to_sym)
+    set_schema do
+      primary_key :id
+      varchar     :ckey, :index => true
+      varchar     :data
+      timestamp   :expire, :default => nil
+    end
+
+    # 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.filter(:ckey => key).single_record(:limit => 1)
+        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.filter(:ckey => key).single_record(:limit => 1)
+        entry.nil? ? self.create(attributes) : entry.set(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.filter(:ckey => key).delete
+    end
+
+    # Expire the cache entries matching the given key
+    #
+    # ==== Parameter
+    # key<Sting>:: The key matching the cache entries
+    def self.expire_match(key)
+      self.filter{:ckey.like  key + "%"}.delete
+    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
+      self.create_table unless self.table_exists?
+    end
+  end
+end