merb-cache 0.9.7 → 0.9.8

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

@@ -1,203 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,79 +0,0 @@
-module Merb::Cache::DatabaseStore::DataMapper
-  # Module that provides DataMapper support for the database backend
-
-  # The cache model
-  class CacheModel
-    include DataMapper::Resource
-    storage_names[:default] = 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.get(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 }
-      if get
-        entry = self.get(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.get(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)
-      self.all(:ckey.like => "#{key}%").destroy!
-    end
-
-    # Expire all the cache entries
-    def self.expire_all
-      self.all.destroy!
-    end
-
-    # Perform auto-migration in case the table is unknown in the database
-    def self.check_table
-      self.auto_upgrade!
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-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

@@ -1,144 +0,0 @@
-class Merb::Cache::DatabaseStore
-  # Provides the database cache store for merb-cache
-
-  def initialize
-    @config = Merb::Controller._cache.config
-    prepare
-  end
-
-  class OrmNotFound < Exception #
-    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

@@ -1,106 +0,0 @@
-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