merb-cache 0.9.2

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

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

@@ -0,0 +1,144 @@
+class Merb::Cache::DatabaseStore
+  # Provides the database cache store for merb-cache
+
+  def initialize
+    @config = Merb::Controller._cache.config
+    prepare
+  end
+
+  class OrmNotFound < Exception #:nodoc:
+    def initialize
+      super("No valid ORM found (did you specify use_orm in init.rb?)")
+    end
+  end
+
+  # Requires the ORM at startup, raising an OrmNotFound exception if
+  # the backend is not found
+  Merb::Controller._cache.config[:table_name] ||= "merb_cache"
+  if defined?(Merb::Orms::ActiveRecord)
+    require "merb-cache/cache-store/database-activerecord.rb"
+    include Merb::Cache::DatabaseStore::ActiveRecord
+  elsif defined?(Merb::Orms::DataMapper)
+    require "merb-cache/cache-store/database-datamapper.rb"
+    include Merb::Cache::DatabaseStore::DataMapper
+  elsif defined?(Merb::Orms::Sequel)
+    require "merb-cache/cache-store/database-sequel.rb"
+    include Merb::Cache::DatabaseStore::Sequel
+  else
+    raise OrmNotFound
+  end
+
+  # This method is there to ensure minimal requirements are met
+  # (file permissions, table exists, connected to server, ...)
+  def prepare
+    CacheModel.check_table
+    true
+  end
+
+  # Checks whether a cache entry exists
+  #
+  # ==== Parameter
+  # key<String>:: The key identifying the cache entry
+  #
+  # ==== Returns
+  # true if the cache entry exists, false otherwise
+  def cached?(key)
+    not CacheModel.cache_get(key).nil?
+  end
+
+  # Capture or restore the data in cache.
+  # If the cache entry expired or does not exist, the data are taken
+  # from the execution of the block, marshalled and stored in cache.
+  # Otherwise, the data are loaded from the cache and returned unmarshalled
+  #
+  # ==== Parameters
+  # _controller<Merb::Controller>:: The instance of the current controller
+  # key<String>:: The key identifying the cache entry
+  # from_now<~minutes>::
+  #   The number of minutes (from now) the cache should persist
+  # &block:: The template to be used or not
+  #
+  # ==== Additional information
+  # When fetching data (the cache entry exists and has not expired)
+  # The data are loaded from the cache and returned unmarshalled.
+  # Otherwise:
+  # The controller is used to capture the rendered template (from the block).
+  # It uses the capture_#{engine} and concat_#{engine} methods to do so.
+  # The captured data are then marshalled and stored.
+  def cache(_controller, key, from_now = nil, &block)
+    _data = CacheModel.cache_get(key)
+    if _data.nil?
+      _expire = from_now ? from_now.minutes.from_now : nil
+      _data = _controller.send(:capture, &block)
+      CacheModel.cache_set(key, Marshal.dump(_data), _expire, false)
+    else
+      _data = Marshal.load(_data)
+    end
+    _controller.send(:concat, _data, block.binding)
+    true
+  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
+  # from_now<~minutes>::
+  #   The number of minutes (from now) the cache should persist
+  def cache_set(key, data, from_now = nil)
+    _expire = from_now ? from_now.minutes.from_now : nil
+    CacheModel.cache_set(key, Marshal.dump(data), _expire)
+    Merb.logger.info("cache: set (#{key})")
+    true
+  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 cache_get(key)
+    data = CacheModel.cache_get(key)
+    Merb.logger.info("cache: #{data.nil? ? "miss" : "hit"} (#{key})")
+    data.nil? ? nil : Marshal.load(data)
+  end
+
+  # Expire the cache entry identified by the given key
+  #
+  # ==== Parameter
+  # key<Sting>:: The key identifying the cache entry
+  def expire(key)
+    CacheModel.expire(key)
+    Merb.logger.info("cache: expired (#{key})")
+    true
+  end
+
+  # Expire the cache entries matching the given key
+  #
+  # ==== Parameter
+  # key<Sting>:: The key matching the cache entries
+  def expire_match(key)
+    CacheModel.expire_match(key)
+    Merb.logger.info("cache: expired matching (#{key})")
+    true
+  end
+
+  # Expire all the cache entries
+  def expire_all
+    CacheModel.expire_all
+    Merb.logger.info("cache: expired all")
+    true
+  end
+
+  # Gives info on the current cache store
+  #
+  # ==== Returns
+  #   The type of the current cache store
+  def cache_store_type
+    "database"
+  end
+end

data/lib/merb-cache/cache-store/dummy.rb

@@ -0,0 +1,106 @@
+class Merb::Cache::DummyStore
+  # Provides dummy cache store for merb-cache
+
+  def initialize
+    @config = Merb::Controller._cache.config
+    prepare
+  end
+
+  # This method is there to ensure minimal requirements are met
+  # (directories are accessible, table exists, connected to server, ...)
+  def prepare
+    true
+  end
+
+  # Checks whether a cache entry exists
+  #
+  # ==== Parameter
+  # key<String>:: The key identifying the cache entry
+  #
+  # ==== Returns
+  # true if the cache entry exists, false otherwise
+  def cached?(key)
+    false
+  end
+
+  # Capture or restore the data in cache.
+  # If the cache entry expired or does not exist, the data are taken
+  # from the execution of the block, marshalled and stored in cache.
+  # Otherwise, the data are loaded from the cache and returned unmarshalled
+  #
+  # ==== Parameters
+  # _controller<Merb::Controller>:: The instance of the current controller
+  # key<String>:: The key identifying the cache entry
+  # from_now<~minutes>::
+  #   The number of minutes (from now) the cache should persist
+  # &block:: The template to be used or not
+  #
+  # ==== Additional information
+  # When fetching data (the cache entry exists and has not expired)
+  # The data are loaded from the cache and returned unmarshalled.
+  # Otherwise:
+  # The controller is used to capture the rendered template (from the block).
+  # It uses the capture_#{engine} and concat_#{engine} methods to do so.
+  # The captured data are then marshalled and stored.
+  def cache(_controller, key, from_now = nil, &block)
+    _data = _controller.send(:capture, &block)
+    _controller.send(:concat, _data, block.binding)
+    true
+  end
+
+  # Store data to memcache using the specified key
+  #
+  # ==== Parameters
+  # key<Sting>:: The key identifying the cache entry
+  # data<String>:: The data to be put in cache
+  # from_now<~minutes>::
+  #   The number of minutes (from now) the cache should persist
+  def cache_set(key, data, from_now = nil)
+    true
+  end
+
+  # Fetch data from memcache 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 cache_get(key)
+    nil
+  end
+
+  # Expire the cache entry identified by the given key
+  #
+  # ==== Parameter
+  # key<Sting>:: The key identifying the cache entry
+  def expire(key)
+    true
+  end
+
+  # Expire the cache entries matching the given key
+  #
+  # ==== Parameter
+  # key<Sting>:: The key matching the cache entries
+  #
+  # ==== Warning !
+  #   This does not work in memcache.
+  def expire_match(key)
+    true
+  end
+
+  # Expire all the cache entries
+  def expire_all
+    true
+  end
+
+  # Gives info on the current cache store
+  #
+  # ==== Returns
+  #   The type of the current cache store
+  def cache_store_type
+    "dummy"
+  end
+end

data/lib/merb-cache/cache-store/file.rb

@@ -0,0 +1,192 @@
+class Merb::Cache::FileStore
+  # Provides the file cache store for merb-cache
+
+  def initialize
+    @config = Merb::Controller._cache.config
+    @config[:cache_directory] ||= Merb.root_path("tmp/cache")
+#    @config[:cache_action_directory] ||= Merb.dir_for(:public) / "cache"
+    prepare
+  end
+
+  class NotAccessible < Exception #:nodoc:
+    def initialize(message)
+      super("Cache directories are not readable/writeable (#{message})")
+    end
+  end
+
+  # This method is there to ensure minimal requirements are met
+  # (directories are accessible, table exists, connected to server, ...)
+  def prepare
+    unless File.readable?(@config[:cache_directory]) &&
+      File.writable?(@config[:cache_directory])
+      raise NotAccessible, @config[:cache_directory]
+    end
+    true
+  end
+
+  # Checks whether a cache entry exists
+  #
+  # ==== Parameter
+  # key<String>:: The key identifying the cache entry
+  #
+  # ==== Returns
+  # true if the cache entry exists, false otherwise
+  def cached?(key)
+    cache_file = @config[:cache_directory] / "#{key}.cache"
+    _data = _expire = nil
+    if File.file?(cache_file)
+      _data, _expire = Marshal.load(cache_read(cache_file))
+      return true if _expire.nil? || Time.now < _expire
+      FileUtils.rm_f(cache_file)
+    end
+    false
+  end
+
+  # Capture or restore the data in cache.
+  # If the cache entry expired or does not exist, the data are taken
+  # from the execution of the block, marshalled and stored in cache.
+  # Otherwise, the data are loaded from the cache and returned unmarshalled
+  #
+  # ==== Parameters
+  # _controller<Merb::Controller>:: The instance of the current controller
+  # key<String>:: The key identifying the cache entry
+  # from_now<~minutes>::
+  #   The number of minutes (from now) the cache should persist
+  # &block:: The template to be used or not
+  #
+  # ==== Additional information
+  # When fetching data (the cache entry exists and has not expired)
+  # The data are loaded from the cache and returned unmarshalled.
+  # Otherwise:
+  # The controller is used to capture the rendered template (from the block).
+  # It uses the capture_#{engine} and concat_#{engine} methods to do so.
+  # The captured data are then marshalled and stored.
+  def cache(_controller, key, from_now = nil, &block)
+    cache_file = @config[:cache_directory] / "#{key}.cache"
+    _cache_hit = _data = _expire = nil
+   
+    if File.file?(cache_file)
+      _data, _expire = Marshal.load(cache_read(cache_file))
+      _cache_hit = true if _expire.nil? || Time.now < _expire
+    end
+    unless _cache_hit
+      cache_directory = File.dirname(cache_file)
+      FileUtils.mkdir_p(cache_directory)
+      _expire = from_now ? from_now.minutes.from_now : nil
+      _data = _controller.send(:capture, &block)
+      cache_write(cache_file, Marshal.dump([_data, _expire]))
+    end
+    _controller.send(:concat, _data, block.binding)
+    true
+  end
+
+  # Store data to the file using the specified key
+  #
+  # ==== Parameters
+  # key<Sting>:: The key identifying the cache entry
+  # data<String>:: The data to be put in cache
+  # from_now<~minutes>::
+  #   The number of minutes (from now) the cache should persist
+  def cache_set(key, data, from_now = nil)
+    cache_file = @config[:cache_directory] / "#{key}.cache"
+    cache_directory = File.dirname(cache_file)
+    FileUtils.mkdir_p(cache_directory)
+    _expire = from_now ? from_now.minutes.from_now : nil
+    cache_write(cache_file, Marshal.dump([data, _expire]))
+    Merb.logger.info("cache: set (#{key})")
+    true
+  end
+
+  # Fetch data from the file 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 cache_get(key)
+    cache_file = @config[:cache_directory] / "#{key}.cache"
+    if File.file?(cache_file)
+      _data, _expire = Marshal.load(cache_read(cache_file))
+      if _expire.nil? || Time.now < _expire
+        Merb.logger.info("cache: hit (#{key})")
+        return _data
+      end
+      FileUtils.rm_f(cache_file)
+    end
+    Merb.logger.info("cache: miss (#{key})")
+    nil
+  end
+
+  # Expire the cache entry identified by the given key
+  #
+  # ==== Parameter
+  # key<Sting>:: The key identifying the cache entry
+  def expire(key)
+    FileUtils.rm_f(@config[:cache_directory] / "#{key}.cache")
+    Merb.logger.info("cache: expired (#{key})")
+    true
+  end
+
+  # Expire the cache entries matching the given key
+  #
+  # ==== Parameter
+  # key<Sting>:: The key matching the cache entries
+  def expire_match(key)
+    #files = Dir.glob(@config[:cache_directory] / "#{key}*.cache")
+    files = Dir.glob(@config[:cache_directory] / "#{key}*")
+    FileUtils.rm_rf(files)
+    Merb.logger.info("cache: expired matching (#{key})")
+    true
+  end
+
+  # Expire all the cache entries
+  def expire_all
+    FileUtils.rm_rf(Dir.glob("#{@config[:cache_directory]}/*"))
+    Merb.logger.info("cache: expired all")
+    true
+  end
+
+  # Gives info on the current cache store
+  #
+  # ==== Returns
+  #   The type of the current cache store
+  def cache_store_type
+    "file"
+  end
+
+  private
+
+  # Read data from the file using exclusive lock
+  #
+  # ==== Parameters
+  # cache_file<String>:: The full path to the file
+  #
+  # ==== Returns
+  # _data<String>:: The data read from the file
+  def cache_read(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 the file using exclusive lock
+  #
+  # ==== Parameters
+  # cache_file<String>:: The full path to the file
+  # data<String>:: The data to be put in cache
+  def cache_write(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
+end