bchiu-merb_cache_more 0.9.4

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

@@ -0,0 +1,195 @@
+class Merb::Cache::MemcacheStore
+  # Provides the memcache cache store for merb_cache_more
+
+  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_more'
+    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_more/cache-store/memory.rb

@@ -0,0 +1,168 @@
+class Merb::Cache::MemoryStore
+  # Provides the memory cache store for merb_cache_more
+
+  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_more/merb-cache.rb

@@ -0,0 +1,239 @@
+class Merb::Cache
+  attr_reader  :config, :store
+
+  class StoreNotFound < Exception
+    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 caching for development
+    #:disable => true, # disable caching for 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, ...
+
+    # can be nil|:snake|:tree|:hash|:query or a custom string
+    # such as ":paramname1/:paramname2_and_:paramname3"
+    #:cache_key_format => :snake,
+
+    # expiration time in minutes
+    #:cache_action_ttl => 10,
+    #:cache_page_ttl => 10
+  }
+
+  # 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[:disable_page_caching] = true
+      config[:store] = "dummy"
+    end
+    @config[:cache_html_directory] ||= Merb.dir_for(:public) / "cache"
+    require "merb_cache_more/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.
+  # :format<String>:: The formatting style that will be used for the key.
+  # :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]])
+  #   cache_get(:key => "root_key", :format => nil|:snake|:hash|:query|:tree)
+  #   cache_get(:key => "root_key", :format => ":one_:two[a]_and_:three[]")
+  #
+  # ==== Returns
+  # The computed key
+  # def key_for(options, controller = nil, 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
+  # 
+  #     _params = options[:params]
+  #     _format = options[:format]
+  # 
+  #     if _params && !_params.empty?
+  #       vals = _params.to_a.map {|p| String === p ? p : (Hash === p[1] ? p[1].values : p[1]) }.flatten
+  #       case _format
+  #       when nil
+  #         _params = _params.to_a.flatten.join('_').gsub('/','%2F') # key1_val1_key2_val2
+  #       when :snake
+  #         _params = vals.join('_').gsub('/','%2F') # val1_val2
+  #       when :hash
+  #         _params = Digest::MD5.hexdigest(_params.to_s) # 32-bit md5 hash
+  #       when :query
+  #         _params = Merb::Request.params_to_query_string(_params) # key1=val1&key2=val2
+  #       when :tree  
+  #         _params = vals[0..10].map {|v| v.gsub('/','%2F')}.join('/') # /val1/val2
+  #       else
+  #         _params.each do |k,v| 
+  #           _format.sub!(":#{k}", v.gsub('/','%2F')) if String === v
+  #           _format.sub!(":#{k}[]", v[0].gsub('/','%2F')) if Array === v
+  #           v.each {|kk,vv| _format.sub!(":#{k}[#{kk}]", vv.gsub('/','%2F')) } if Hash === v
+  #         end
+  #         _params = _format
+  #       end
+  #       key += '/' + sanitize_cache_key(_params) unless _params.blank?
+  #     else
+  #       #key += '/index' # all pages in one dir
+  #     end
+  #   else
+  #     key = controller_based ? "/#{controller}/#{options}" : options
+  #   end
+  #   key
+  # end
+  #
+  def key_for(options, controller = nil, 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
+
+      _params = options[:params]
+      _format = options[:format]
+
+      if _params && !_params.empty?
+        vals = _params.to_a.map {|p| String === p ? p : (Hash === p[1] ? p[1].values : p[1]) }.flatten
+        case _format
+        when nil
+          _params = _params.to_a.flatten.join('_').gsub('/','%2F') # key1_val1_key2_val2
+        when :snake
+          _params = vals.join('_').gsub('/','%2F') # val1_val2
+        when :hash
+          _params = Digest::MD5.hexdigest(_params.to_s) # 32-bit md5 hash
+        when :query
+          _params = Merb::Request.params_to_query_string(_params) # key1=val1&key2=val2
+        when :tree  
+          _params = vals[0..10].map {|v| v.gsub('/','%2F')}.join('/') # /val1/val2
+        else
+          _params.each do |k,v| 
+            _format.sub!(":#{k}", v.gsub('/','%2F')) if String === v
+            _format.sub!(":#{k}[]", v[0].gsub('/','%2F')) if Array === v
+            v.each {|kk,vv| _format.sub!(":#{k}[#{kk}]", vv.gsub('/','%2F')) } if Hash === v
+          end
+          _params = _format
+        end
+        key += '/' + sanitize_cache_key(_params) unless _params.blank?
+      else
+        #key += '/index' # all pages in one dir
+      end
+    else
+      key = controller_based ? "/#{controller}/#{options}" : options
+    end
+    key
+  end
+
+  # Removes illegal chars from key and allows cached pages to be safely
+  # stored on any filesystem. You may override this method in your app 
+  # to match how filenames are escaped by your web server.
+  #
+  # ==== Parameters
+  # key<String>:: The key to sanitize
+  #
+  # ==== Returns
+  # The sanitized key
+  #
+  def sanitize_cache_key(key = "")
+    key.gsub(/[\\\:\*\?\"\<\>\|\s]/,'_')
+  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
+