merb-cache 0.9.7 → 0.9.8

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

@@ -1,194 +0,0 @@
-require 'fileutils'
-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 #
-    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
-    FileUtils.mkdir_p @config[:cache_directory]
-    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

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

@@ -1,199 +0,0 @@
-class Merb::Cache::MemcacheStore
-  # Provides the memcache cache store for merb-cache
-
-  def initialize
-    @config = Merb::Controller._cache.config
-    prepare
-  end
-
-  class NotReady < Exception
-    def initialize
-      super("Memcache server is not ready")
-    end
-  end
-
-  class NotDefined < Exception
-    def initialize
-      super("Memcache is not defined (require it in init.rb)")
-    end
-  end
-
-  # This method is there to ensure minimal requirements are met
-  # (directories are accessible, table exists, connected to server, ...)
-  def prepare
-    namespace = @config[:namespace] || 'merb-cache'
-    host = @config[:host] || '127.0.0.1:11211'
-    @memcache = MemCache.new(host, {:namespace => namespace})
-    @tracking_key = "_#{namespace}_keys" unless @config[:no_tracking] == true
-    raise NotReady unless @memcache.active?
-    true
-  rescue NameError
-    raise NotDefined
-  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 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 = cache_get(key)
-    if _data.nil?
-      _data = _controller.send(:capture, &block)
-      cache_set(key, _data, from_now)
-    end
-    _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)
-    _expire = from_now ? from_now.minutes.from_now.to_i : 0
-    @memcache.set(key, data, _expire)
-    cache_start_tracking(key)
-    Merb.logger.info!("cache: set (#{key})")
-    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)
-    data = @memcache.get(key)
-    if data.nil?
-      Merb.logger.info!("cache: miss (#{key})")
-    else
-      Merb.logger.debug!("cache: hit (#{key})")
-    end
-    data
-  end
-
-  # Expire the cache entry identified by the given key
-  #
-  # ==== Parameter
-  # key<Sting>:: The key identifying the cache entry
-  def expire(key)
-    @memcache.delete(key)
-    cache_stop_tracking(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
-  #
-  # ==== Additional info
-  #   In memcache this requires to keep track of all keys (on by default).
-  #   If you don't need this, set :no_tracking => true in the config.
-  def expire_match(key)
-    Merb.logger.debug!("cache: attempting to expire #{key}")
-    if @tracking_key
-      for _key in get_tracked_keys
-        expire(_key) if /#{key}/ =~ _key
-      end
-    else
-      Merb.logger.info("cache: expire_match is not supported with memcache (set :no_tracking => false in your config")
-    end
-    true
-  end
-
-  # Expire all the cache entries
-  def expire_all
-    @memcache.flush_all
-    stop_tracking_keys
-    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
-    "memcache"
-  end
-
-  private
-
-  # Store the tracked keys in memcache (used by expire_match)
-  #
-  # ==== Parameter
-  # keys<Array[String]>:: The keys to keep track of
-  def set_tracked_keys(keys)
-    @memcache.set(@tracking_key, keys)
-  end
-
-  # Retrieve tracked keys from memcache
-  #
-  # ==== Returns
-  # keys<Array[String]>:: The tracked keys
-  def get_tracked_keys
-    @memcache.get(@tracking_key) || []
-  end
-
-  # Remove all tracked keys
-  def stop_tracking_keys
-    @memcache.delete(@tracking_key) if @tracking_key
-  end
-
-  # Add a key in the array of tracked keys (used by expire_match)
-  #
-  # ==== Parameter
-  # key<String>:: the key to add
-  def cache_start_tracking(key)
-    return unless @tracking_key
-    keys = get_tracked_keys
-    keys.push(key)
-    set_tracked_keys(keys)
-  end
-
-  # Remove a key from the array of tracked keys (used by expire_match)
-  #
-  # ==== Parameter
-  # key<String>:: the key to remove
-  def cache_stop_tracking(key)
-    return unless @tracking_key
-    keys = get_tracked_keys
-    keys.delete(key)
-    set_tracked_keys(keys)
-  end
-end

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

@@ -1,168 +0,0 @@
-class Merb::Cache::MemoryStore
-  # Provides the memory cache store for merb-cache
-
-  def initialize
-    @config = Merb::Controller._cache.config
-    @cache = {}
-    @mutex = Mutex.new
-    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)
-    if @cache.key?(key)
-      _data, _expire = *cache_read(key)
-      return true if _expire.nil? || Time.now < _expire
-      expire(key)
-    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)
-    if @cache.key?(key)
-      _data, _expire = *cache_read(key)
-      _cache_hit = _expire.nil? || Time.now < _expire
-    end
-    unless _cache_hit
-      _expire = from_now ? from_now.minutes.from_now : nil
-      _data = _controller.send(:capture, &block)
-      cache_write(key, [_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)
-    _expire = from_now ? from_now.minutes.from_now : nil
-    cache_write(key, [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)
-    if @cache.key?(key)
-      _data, _expire = *cache_read(key)
-      if _expire.nil? || Time.now < _expire
-        Merb.logger.info("cache: hit (#{key})")
-        return _data
-      end
-      @mutex.synchronize do @cache.delete(key) end
-    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)
-    @mutex.synchronize do
-      @cache.delete(key)
-    end
-    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)
-    @mutex.synchronize do
-      @cache.delete_if do |k,v| k.match(/#{key}/) end
-    end
-    Merb.logger.info("cache: expired matching (#{key})")
-    true
-  end
-
-  # Expire all the cache entries
-  def expire_all
-    @mutex.synchronize do
-      @cache.clear
-    end
-    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
-    "memory"
-  end
-
-  private
-
-  # Read data from the memory hash table using mutex
-  #
-  # ==== Parameters
-  # cache_file<String>:: The key identifying the cache entry
-  #
-  # ==== Returns
-  # _data<String>:: The data fetched from the cache
-  def cache_read(key)
-    @mutex.synchronize do
-      @cache[key]
-    end
-  end
-
-  # Write data to the memory hash table using mutex
-  #
-  # ==== Parameters
-  # cache_file<String>:: The key identifying the cache entry
-  # data<String>:: The data to be put in cache
-  def cache_write(key, data)
-    @mutex.synchronize do
-      @cache[key] = data
-    end
-  end
-end