merb-cache 0.9.2

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

@@ -0,0 +1,195 @@
+class Merb::Cache::MemcacheStore
+  # Provides the memcache cache store for merb-cache
+
+  def initialize
+    @config = Merb::Controller._cache.config
+    prepare
+  end
+
+  class NotReady < Exception #:nodoc:
+    def initialize
+      super("Memcache server is not ready")
+    end
+  end
+
+  class NotDefined < Exception #:nodoc:
+    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]
+    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 @memcache.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 = @memcache.get(key)
+    if _data.nil?
+      _expire = from_now ? from_now.minutes.from_now.to_i : 0
+      _data = _controller.send(:capture, &block)
+      @memcache.set(key, _data, _expire)
+    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)
+    Merb.logger.info("cache: #{data.nil? ? "miss" : "hit"} (#{key})")
+    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)
+    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

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

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

@@ -0,0 +1,164 @@
+require "merb-cache/cache-action"
+require "merb-cache/cache-page"
+require "merb-cache/cache-fragment"
+
+class Merb::Cache
+  attr_reader  :config, :store
+
+  class StoreNotFound < Exception #:nodoc:
+    def initialize(cache_store)
+      super("cache_store (#{cache_store}) not found (not implemented?)")
+    end
+  end
+
+  DEFAULT_CONFIG = {
+    :cache_html_directory => Merb.dir_for(:public) / "cache",
+
+    #:store => "database",
+    #:table_name => "merb_cache",
+
+    #:disable => "development", # disable merb-cache in development
+    #:disable => true, # disable merb-cache in all environments
+
+    :store => "file",
+    :cache_directory => Merb.root_path("tmp/cache"),
+
+    #:store => "memcache",
+    #:host => "127.0.0.1:11211",
+    #:namespace => "merb_cache",
+    #:track_keys => true,
+
+    #:store => "memory",
+    # store could be: file, memcache, memory, database, dummy, ...
+  }
+
+  # Called in the after_app_loads loop and instantiate the right backend
+  #
+  # ==== Raises
+  # Store#NotFound::
+  #   If the cache_store mentionned in the config is unknown
+  def start
+    @config = DEFAULT_CONFIG.merge(Merb::Plugins.config[:merb_cache] || {})
+    if @config[:disable] == true || Merb.environment == @config[:disable]
+      config[:store] = "dummy"
+    end
+    @config[:cache_html_directory] ||= Merb.dir_for(:public) / "cache"
+    require "merb-cache/cache-store/#{@config[:store]}"
+    @store = Merb::Cache.const_get("#{@config[:store].capitalize}Store").new
+    Merb.logger.info("Using #{@config[:store]} cache")
+  rescue LoadError
+    raise Merb::Cache::StoreNotFound, @config[:store].inspect
+  end
+
+  # Compute a cache key and yield it to the given block
+  # It is used by the #expire_page, #expire_action and #expire methods.
+  #
+  # ==== Parameters
+  # options<String, Hash>:: The key or the Hash that will be used to build the key
+  # controller<String>:: The name of the controller
+  # controller_based<Boolean>:: only used by action and page caching
+  #
+  # ==== Options (options)
+  # :key<String>:: The complete or partial key that will be computed.
+  # :action<String>:: The action name that will be used to compute the key
+  # :controller<String>:: The controller name that will be part of the key
+  # :params<Array[String]>::
+  #   The params will be joined together (with '/') and added to the key
+  # :match<Boolean, String>::
+  #   true, it will try to match multiple cache entries
+  #   string, shortcut for {:key => "mykey", :match => true}
+  #
+  # ==== Examples
+  #   expire(:key => "root_key", :params => [session[:me], params[:id]])
+  #   expire(:match => "root_key")
+  #   expire_action(:action => 'list')
+  #   expire_page(:action => 'show', :controller => 'news')
+  #
+  # ==== Returns
+  # The result of the given block
+  #
+  def expire_key_for(options, controller, controller_based = false)
+    key = ""
+    if options.is_a? Hash
+      case
+      when key = options[:key]
+      when action = options[:action]
+        controller = options[:controller] || controller
+        key = "/#{controller}/#{action}"
+      when match = options[:match]
+        key = match
+      end
+      if _params = options[:params]
+        key += "/" + _params.join("/")
+      end
+      yield key, !options[:match].nil?
+    else
+      yield controller_based ? "/#{controller}/#{options}" : options, false
+    end
+  end
+
+  # Compute a cache key based on the given parameters
+  # Only used by the #cached_page?, #cached_action?, #cached?, #cache,
+  # #cache_get and #cache_set methods
+  #
+  # ==== Parameters
+  # options<String, Hash>:: The key or the Hash that will be used to build the key
+  # controller<String>:: The name of the controller
+  # controller_based<Boolean>:: only used by action and page caching
+  #
+  # ==== Options (options)
+  # :key<String>:: The complete or partial key that will be computed.
+  # :action<String>:: The action name that will be used to compute the key
+  # :controller<String>:: The controller name that will be part of the key
+  # :params<Array[String]>::
+  #   The params will be joined together (with '/') and added to the key
+  #
+  # ==== Examples
+  #   cache_set("my_key", @data)
+  #   cache_get(:key => "root_key", :params => [session[:me], params[:id]])
+  #
+  # ==== Returns
+  # The computed key
+  def key_for(options, controller, controller_based = false)
+    key = ""
+    if options.is_a? Hash
+      case
+      when key = options[:key]
+      when action = options[:action]
+        controller = options[:controller] || controller
+        key = "/#{controller}/#{action}"
+      end
+      if _params = options[:params]
+        key += "/" + _params.join("/")
+      end
+    else
+      key = controller_based ? "/#{controller}/#{options}" : options
+    end
+    key
+  end
+
+  module ControllerInstanceMethods
+    # Mixed in Merb::Controller and provides expire_all for action and fragment caching.
+    def expire_all
+      Merb::Controller._cache.store.expire_all
+    end
+  end
+end
+
+module Merb #:nodoc:
+  class Controller #:nodoc:
+    cattr_reader :_cache
+    @@_cache = Merb::Cache.new
+    # extends Merb::Controller with new instance methods
+    include Merb::Cache::ControllerInstanceMethods
+    class << self #:nodoc:
+      # extends Merb::Controller with new class methods
+      include Merb::Cache::ControllerClassMethods
+    end
+  end
+end
+
+Merb::BootLoader.after_app_loads do
+  # the cache starts after the application is loaded
+  Merb::Controller._cache.start
+end

data/lib/merb-cache/merbtasks.rb

@@ -0,0 +1,6 @@
+namespace :merb_cache do
+  desc "Do something for merb-cache"
+  task :default do
+    puts "merb-cache doesn't do anything"
+  end
+end

data/lib/merb-cache.rb

@@ -0,0 +1,10 @@
+if defined?(Merb::Plugins)
+  Merb::Plugins.add_rakefiles "merb-cache/merbtasks"
+  unless 1.respond_to? :minutes
+    class Numeric #:nodoc:
+      def minutes; self * 60; end
+      def from_now(now = Time.now); now + self; end
+    end
+  end
+  require "merb-cache/merb-cache"
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: merb-cache
+version: !ruby/object:Gem::Version 
+  version: 0.9.2
+platform: ruby
+authors: 
+- Alex Boussinet
+autorequire: merb-cache
+bindir: bin
+cert_chain: []
+
+date: 2008-03-24 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: merb-core
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.2
+    version: 
+description: Merb plugin that provides caching (page, action, fragment, object)
+email: alex.boussinet@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/merb-cache
+- lib/merb-cache/cache-action.rb
+- lib/merb-cache/cache-fragment.rb
+- lib/merb-cache/cache-page.rb
+- lib/merb-cache/cache-store
+- lib/merb-cache/cache-store/database-activerecord.rb
+- lib/merb-cache/cache-store/database-datamapper.rb
+- lib/merb-cache/cache-store/database-sequel.rb
+- lib/merb-cache/cache-store/database.rb
+- lib/merb-cache/cache-store/dummy.rb
+- lib/merb-cache/cache-store/file.rb
+- lib/merb-cache/cache-store/memcache.rb
+- lib/merb-cache/cache-store/memory.rb
+- lib/merb-cache/merb-cache.rb
+- lib/merb-cache/merbtasks.rb
+- lib/merb-cache.rb
+has_rdoc: true
+homepage: http://www.merbivore.com
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Merb plugin that provides caching (page, action, fragment, object)
+test_files: []
+