merb-cache 0.9.7 → 0.9.8

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

@@ -0,0 +1,167 @@
+module Merb::Cache::CacheMixin
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def cache!(conditions = {})
+      before(:_cache_before, conditions.only(:if, :unless).merge(:with => conditions))
+      after(:_cache_after, conditions.only(:if, :unless).merge(:with => conditions))
+    end
+
+    def cache(*actions)
+      if actions.last.is_a? Hash
+        cache_action(*actions)
+      else
+        actions.each {|a| cache_action(*a)}
+      end
+    end
+
+    def cache_action(action, conditions = {})
+      before("_cache_#{action}_before", conditions.only(:if, :unless).merge(:with => [conditions], :only => action))
+      after("_cache_#{action}_after", conditions.only(:if, :unless).merge(:with => [conditions], :only => action))
+      alias_method "_cache_#{action}_before", :_cache_before
+      alias_method "_cache_#{action}_after",  :_cache_after
+    end
+
+    def eager_cache(trigger_action, target = trigger_action, conditions = {}, &blk)
+      target, conditions = trigger_action, target if target.is_a? Hash
+
+      if target.is_a? Array
+        target_controller, target_action = *target
+      else
+        target_controller, target_action = self, target
+      end
+
+      after("_eager_cache_#{trigger_action}_to_#{target_controller.name.snake_case}__#{target_action}_after", conditions.only(:if, :unless).merge(:with => [target_controller, target_action, conditions, blk], :only => trigger_action))
+      alias_method "_eager_cache_#{trigger_action}_to_#{target_controller.name.snake_case}__#{target_action}_after", :_eager_cache_after
+    end
+
+    def eager_dispatch(action, env = {}, blk = nil)
+      kontroller = new(Merb::Request.new(env))
+      kontroller.force_cache!
+
+      blk.call(kontroller) unless blk.nil?
+
+      kontroller._dispatch(action)
+
+      kontroller
+    end
+  end
+
+  def fetch_partial(template, opts={}, conditions = {})
+    template_id = template.to_s
+    if template_id =~ %r{^/}
+      template_path = File.dirname(template_id) / "_#{File.basename(template_id)}"
+    else
+      kontroller = (m = template_id.match(/.*(?=\/)/)) ? m[0] : controller_name
+      template_id = "_#{File.basename(template_id)}"
+    end
+
+    unused, template_key = _template_for(template_id, opts.delete(:format) || content_type, kontroller, template_path)
+
+    fetch_proc = lambda { partial(template, opts) }
+
+    concat(Merb::Cache[_lookup_store(conditions)].fetch(template_key, opts, conditions, &fetch_proc), fetch_proc.binding)
+  end
+
+  def fetch_fragment(opts = {}, conditions = {}, &proc)
+    
+    if opts[:cache_key].blank?
+      file, line = proc.to_s.scan(%r{^#<Proc:0x\w+@(.+):(\d+)>$}).first
+      fragment_key = "#{file}[#{line}]"
+    else
+      fragment_key = opts.delete(:cache_key)
+    end
+      
+    concat(Merb::Cache[_lookup_store(conditions)].fetch(fragment_key, opts, conditions) { capture(&proc) }, proc.binding)
+  end
+
+  def _cache_before(conditions = {})
+    unless @_force_cache
+      if @_skip_cache.nil? && data = Merb::Cache[_lookup_store(conditions)].read(self, _parameters_and_conditions(conditions).first)
+        throw(:halt, data)
+        @_cache_hit = true
+      end
+    end
+  end
+
+  def _cache_after(conditions = {})
+    if @_skip_cache.nil? && Merb::Cache[_lookup_store(conditions)].write(self, nil, *_parameters_and_conditions(conditions))
+      @_cache_write = true
+    end
+  end
+
+  def _eager_cache_after(klass, action, conditions = {}, blk = nil)
+    if @_skip_cache.nil?
+      run_later do
+        controller = klass.eager_dispatch(action, request.env, blk)
+
+        Merb::Cache[controller._lookup_store(conditions)].write(controller, nil, *controller._parameters_and_conditions(conditions))
+      end
+    end
+  end
+
+  def eager_cache(action, conditions = {}, env = request.env.dup, &blk)
+    unless @_skip_cache
+      if action.is_a?(Array)
+        klass, action = *action
+      else
+        klass = self.class
+      end
+
+      run_later do
+        controller = klass.eager_dispatch(action, env, blk)
+      end
+    end
+  end
+
+  def _set_skip_cache
+    @_skip_cache = true
+  end
+
+  def skip_cache!
+    _set_skip_cache
+  end
+
+  def force_cache!
+    @_force_cache = true
+  end
+
+  def _lookup_store(conditions = {})
+    conditions[:store] || conditions[:stores] || default_cache_store
+  end
+
+  # Overwrite this in your controller to change the default store for a given controller
+  def default_cache_store
+    Merb::Cache.default_store_name
+  end
+
+  #ugly, please make me purdy'er
+  def _parameters_and_conditions(conditions)
+    parameters = {}
+
+    if self.class.respond_to? :action_argument_list
+      arguments, defaults = self.class.action_argument_list[action_name]
+      arguments.inject(parameters) do |parameters, arg|
+        if defaults.include?(arg.first)
+          parameters[arg.first] = self.params[arg.first] || arg.last
+        else
+          parameters[arg.first] = self.params[arg.first]
+        end
+        parameters
+      end
+    end
+
+    case conditions[:params]
+    when Symbol
+      parameters[conditions[:params]] = self.params[conditions[:params]]
+    when Array
+      conditions[:params].each do |param|
+        parameters[param] = self.params[param]
+      end
+    end
+
+    return parameters, conditions.except(:params, :store, :stores)
+  end
+end

data/lib/merb-cache/stores/fundamental/abstract_store.rb

@@ -0,0 +1,101 @@
+class Merb::Cache::AbstractStore
+
+  def initialize(config = {}); end
+
+  # determines if the store is able to persist data identified by the key & parameters
+  # with the given conditions.
+  #
+  # @param [#to_s] key the key used to identify an entry
+  # @param [Hash] parameters optional parameters used to identify an entry
+  # @param [Hash] conditions optional conditions that place constraints or detail instructions for storing an entry
+  # @return [TrueClass] the ability of the store to write an entry based on the key, parameters, and conditions
+  # @raise [NotImplementedError] API method has not been implemented
+  def writable?(key, parameters = {}, conditions = {})
+    raise NotImplementedError
+  end
+
+  # gets the data from the store identified by the key & parameters.
+  # return nil if the entry does not exist.
+  #
+  # @param [#to_s] key the key used to identify an entry
+  # @param [Hash] parameters optional parameters used to identify an entry
+  # @return [Object, NilClass] the match entry, or nil if no entry exists matching the key and parameters
+  # @raise [NotImplementedError] API method has not been implemented
+  def read(key, parameters = {})
+    raise NotImplementedError
+  end
+
+  # persists the data so that it can be retrieved by the key & parameters.
+  # returns nil if it is unable to persist the data.
+  # returns true if successful.
+  #
+  # @param [#to_s] key the key used to identify an entry
+  # @param data the object to persist as an entry
+  # @param [Hash] parameters optional parameters used to identify an entry
+  # @param [Hash] conditions optional conditions that place constraints or detail instructions for storing an entry
+  # @return [TrueClass, NilClass] true if the entry was successfully written, otherwise nil
+  # @raise [NotImplementedError] API method has not been implemented
+  def write(key, data = nil, parameters = {}, conditions = {})
+    raise NotImplementedError
+  end
+
+  # @param [#to_s] key the key used to identify an entry
+  # @param data the object to persist as an entry
+  # @param [Hash] parameters optional parameters used to identify an entry
+  # @param [Hash] conditions optional conditions that place constraints or detail instructions for storing an entry
+  # @return [TrueClass, NilClass] true if the entry was successfully written, otherwise nil
+  # @raise [NotImplementedError] API method has not been implemented
+  def write_all(key, data = nil, parameters = {}, conditions = {})
+    write(key, data, parameters, conditions)
+  end
+
+  # tries to read the data from the store.  If that fails, it calls
+  # the block parameter and persists the result.
+  #
+  # @param [#to_s] key the key used to identify an entry
+  # @param [Hash] parameters optional parameters used to identify an entry
+  # @param [Hash] conditions optional conditions that place constraints or detail instructions for storing an entry
+  # @return [Object, NilClass] the match entry or the result of the block call, or nil if the entry is not successfully written
+  # @raise [NotImplementedError] API method has not been implemented
+  def fetch(key, parameters = {}, conditions = {}, &blk)
+    raise NotImplementedError
+  end
+
+  # returns true/false/nil based on if data identified by the key & parameters
+  # is persisted in the store.
+  #
+  # @param [#to_s] key the key used to identify an entry
+  # @param [Hash] parameters optional parameters used to identify an entry
+  # @return [TrueClass] true if the key and parameters match an entry in the store, false otherwise
+  # @raise [NotImplementedError] API method has not been implemented
+  def exists?(key, parameters = {})
+    raise NotImplementedError
+  end
+
+  # deletes the entry for the key & parameter from the store.
+  #
+  # @param [#to_s] key the key used to identify an entry
+  # @param [Hash] parameters optional parameters used to identify an entry
+  # @raise [TrueClass] true if the an entry matching the key and parameters is successfully deleted, false otherwise
+  # @raise [NotImplementedError] API method has not been implemented
+  def delete(key, parameters = {})
+    raise NotImplementedError
+  end
+
+  # deletes all entries for the key & parameters for the store.
+  #
+  # @return [TrueClass] true if all entries in the store are erased, false otherwise
+  # @raise [NotImplementedError] API method has not been implemented
+  def delete_all
+    raise NotImplementedError
+  end
+
+  # dangerous version of delete_all.  Used by strategy stores, which may delete entries not associated with the strategy
+  # store making the call.
+  #
+  # @return [TrueClass] true if all entries in the store are erased, false otherwise
+  # @raise [NotImplementedError] API method has not been implemented
+  def delete_all!
+    delete_all
+  end
+end

data/lib/merb-cache/stores/fundamental/file_store.rb

@@ -0,0 +1,112 @@
+module Merb::Cache
+  # Cache store that uses files. Usually this is good for fragment
+  # and page caching but not object caching.
+  #
+  # By default cached files are stored in tmp/cache under Merb.root directory.
+  # To use other location pass :dir option to constructor.
+  #
+  # File caching does not support expiration time.
+  class FileStore < AbstractStore
+    attr_accessor :dir
+
+    # Creates directory for cached files unless it exists.
+    def initialize(config = {})
+      @dir = config[:dir] || Merb.root_path(:tmp / :cache)
+
+      create_path(@dir)
+    end
+
+    # File caching does not support expiration time.
+    def writable?(key, parameters = {}, conditions = {})
+      case key
+      when String, Numeric, Symbol
+        !conditions.has_key?(:expire_in)
+      else nil
+      end
+    end
+
+    # Reads cached template from disk if it exists.
+    def read(key, parameters = {})
+      if exists?(key, parameters)
+        read_file(pathify(key, parameters))
+      end
+    end
+
+    # Writes cached template to disk, creating cache directory
+    # if it does not exist.
+    def write(key, data = nil, parameters = {}, conditions = {})
+      if writable?(key, parameters, conditions)
+        if File.file?(path = pathify(key, parameters))
+          write_file(path, data)
+        else
+          create_path(path) && write_file(path, data)
+        end
+      end
+    end
+
+    # Fetches cached data by key if it exists. If it does not,
+    # uses passed block to get new cached value and writes it
+    # using given key.
+    def fetch(key, parameters = {}, conditions = {}, &blk)
+      read(key, parameters) || (writable?(key, parameters, conditions) && write(key, value = blk.call, parameters, conditions) && value)
+    end
+
+    # Checks if cached template with given key exists.
+    def exists?(key, parameters = {})
+      File.file?(pathify(key, parameters))
+    end
+
+    # Deletes cached template by key using FileUtils#rm.
+    def delete(key, parameters = {})
+      if File.file?(path = pathify(key, parameters))
+        FileUtils.rm(path)
+      end
+    end
+
+    def delete_all
+      raise NotSupportedError
+    end
+
+    def pathify(key, parameters = {})
+      if key.to_s =~ /^\//
+        path = "#{@dir}#{key}"
+      else
+        path = "#{@dir}/#{key}"
+      end
+
+      path << "--#{parameters.to_sha2}" unless parameters.empty?
+      path
+    end
+    
+    protected
+
+    def create_path(path)
+      FileUtils.mkdir_p(File.dirname(path))
+    end
+
+    # Reads file content. Access to the file
+    # uses file locking.
+    def read_file(path)
+      data = nil
+      File.open(path, "r") do |file|
+        file.flock(File::LOCK_EX)
+        data = file.read
+        file.flock(File::LOCK_UN)
+      end
+
+      data
+    end
+
+    # Writes file content. Access to the file
+    # uses file locking.    
+    def write_file(path, data)
+      File.open(path, "w+") do |file|
+        file.flock(File::LOCK_EX)
+        file.write(data)
+        file.flock(File::LOCK_UN)
+      end
+
+      true
+    end
+  end
+end

data/lib/merb-cache/stores/fundamental/memcached_store.rb

@@ -0,0 +1,112 @@
+require 'memcached'
+
+module Merb::Cache
+  # Memcached store uses one or several Memcached
+  # servers for caching. It's flexible and can be used
+  # for fragment caching, action caching, page caching
+  # or object caching.
+  class MemcachedStore < AbstractStore
+    attr_accessor :namespace, :servers, :memcached
+
+    def initialize(config = {})
+      @namespace = config[:namespace]
+      @servers = config[:servers] || ["127.0.0.1:11211"]
+
+      connect(config)
+    end
+
+    # Memcached store consideres all keys and parameters
+    # writable.
+    def writable?(key, parameters = {}, conditions = {})
+      true
+    end
+
+    # Reads key from the cache.
+    def read(key, parameters = {})
+      begin
+        @memcached.get(normalize(key, parameters))
+      rescue Memcached::NotFound, Memcached::Stored
+        nil
+      end
+    end
+
+    # Writes data to the cache using key, parameters and conditions.
+    def write(key, data = nil, parameters = {}, conditions = {})
+      if writable?(key, parameters, conditions)
+        begin
+          @memcached.set(normalize(key, parameters), data, expire_time(conditions))
+          true
+        rescue
+          nil
+        end
+      end
+    end
+
+    # Fetches cached data by key if it exists. If it does not,
+    # uses passed block to get new cached value and writes it
+    # using given key.
+    def fetch(key, parameters = {}, conditions = {}, &blk)
+      read(key, parameters) || (writable?(key, parameters, conditions) && write(key, value = blk.call, parameters, conditions) && value)
+    end
+
+    # returns true/false/nil based on if data identified by the key & parameters
+    # is persisted in the store.
+    #
+    # With Memcached 1.2 protocol the only way to
+    # find if key exists in the cache is to read it.
+    # It is very fast and shouldn't be a concern.
+    def exists?(key, parameters = {})
+      begin
+        @memcached.get(normalize(key, parameters)) && true
+      rescue  Memcached::Stored
+        true
+      rescue Memcached::NotFound
+        nil
+      end
+    end
+
+    # Deletes entry from cached by key.
+    def delete(key, parameters = {})
+      begin
+        @memcached.delete(normalize(key, parameters))
+      rescue Memcached::NotFound
+        nil
+      end
+    end
+
+    # Flushes the cache.
+    def delete_all
+      @memcached.flush
+    end
+
+    def clone
+      twin = super
+      twin.memcached = @memcached.clone
+      twin
+    end
+
+    # Establishes connection to Memcached.
+    #
+    # Use :buffer_requests option to use bufferring,
+    # :no_block to use non-blocking async I/O.
+    def connect(config = {})
+      @memcached = ::Memcached.new(@servers, config.only(:buffer_requests, :no_block).merge(:namespace => @namespace))
+    end
+
+    # Returns cache key calculated from base key
+    # and SHA2 hex from parameters.
+    def normalize(key, parameters = {})
+      parameters.empty? ? "#{key}" : "#{key}--#{parameters.to_sha2}"
+    end
+
+    # Returns expiration timestamp if :expire_in key is
+    # given.
+    def expire_time(conditions = {})
+      if t = conditions[:expire_in]
+        Time.now + t
+      else
+        0
+      end
+    end
+  end
+end

data/lib/merb-cache/stores/strategy/abstract_strategy_store.rb

@@ -0,0 +1,123 @@
+# -*- coding: undecided -*-
+module Merb::Cache
+  # A strategy store wraps one or
+  # more fundamental stores, acting as a middle man between caching
+  # requests.
+  #
+  # For example, if you need to save memory on your Memcache server,
+  # you could wrap your MemcachedStore with a GzipStore. This would
+  # automatically compress the cached data when put into the cache, and
+  # decompress it on the way out. You can even wrap strategy caches
+  # with other strategy caches. If your key was comprised of sensitive
+  # information, like a SSN, you might want to encrypt the key before
+  # storage. Wrapping your GzipStore in a SHA1Store would take
+  # care of that for you.
+  #
+  # The AbstractStore class defines 9 methods as the API:
+  # 
+  # writable?(key, parameters = {}, conditions = {})
+  # exists?(key, parameters = {})
+  # read(key, parameters = {})
+  # write(key, data = nil, parameters = {}, conditions = {})
+  # write_all(key, data = nil, parameters = {}, conditions = {})
+  # fetch(key, parameters = {}, conditions = {}, &blk)
+  # delete(key, parameters = {})
+  # delete_all
+  # delete_all!
+  # 
+  # AbstractStrategyStore implements all of these with the exception
+  # of delete_all. If a strategy store can guarantee that calling
+  # delete_all on it’s wrapped store(s) will only delete entries
+  # populated by the strategy store, it may define the safe
+  # version of delete_all. However, this is usually not the
+  # case, hence delete_all is not part of the
+  # public API for AbstractStrategyStore.
+  class AbstractStrategyStore < AbstractStore
+    # START: interface for creating strategy stores.  This should/might change.
+    def self.contextualize(*stores)
+        Class.new(self) do
+          cattr_accessor :contextualized_stores
+
+          self.contextualized_stores = stores
+        end
+      end
+
+      class << self
+        alias_method :[], :contextualize
+      end
+
+      attr_accessor :stores
+
+      def initialize(config = {})
+        @stores = contextualized_stores.map do |cs|
+          case cs
+          when Symbol
+            Merb::Cache[cs]
+          when Class
+            cs.new(config)
+          end
+        end
+      end
+
+    # END: interface for creating strategy stores.
+
+    attr_accessor :stores
+
+    # determines if the store is able to persist data identified by the key & parameters
+    # with the given conditions.
+    def writable?(key, parameters = {}, conditions = {})
+      raise NotImplementedError
+    end
+
+    # gets the data from the store identified by the key & parameters.
+    # return nil if the entry does not exist.
+    def read(key, parameters = {})
+      raise NotImplementedError
+    end
+
+    # persists the data so that it can be retrieved by the key & parameters.
+    # returns nil if it is unable to persist the data.
+    # returns true if successful.
+    def write(key, data = nil, parameters = {}, conditions = {})
+      raise NotImplementedError
+    end
+
+    # persists the data to all context stores.
+    # returns nil if none of the stores were able to persist the data.
+    # returns true if at least one write was successful.
+    def write_all(key, data = nil, parameters = {}, conditions = {})
+      raise NotImplementedError
+    end
+
+    # tries to read the data from the store.  If that fails, it calls
+    # the block parameter and persists the result.
+    def fetch(key, parameters = {}, conditions = {}, &blk)
+      raise NotImplementedError
+    end
+
+    # returns true/false/nil based on if data identified by the key & parameters
+    # is persisted in the store.
+    def exists?(key, parameters = {})
+      raise NotImplementedError
+    end
+
+    # deletes the entry for the key & parameter from the store.
+    def delete(key, parameters = {})
+      raise NotImplementedError
+    end
+
+    # deletes all entries for the key & parameters for the store.
+    # considered dangerous because strategy stores which call delete_all!
+    # on their context stores could delete other store's entrees.
+    def delete_all!
+      raise NotImplementedError
+    end
+
+    def clone
+      twin = super
+      twin.stores = self.stores.map {|s| s.clone}
+      twin
+    end
+    
+  end
+end

data/lib/merb-cache/stores/strategy/action_store.rb

@@ -0,0 +1,56 @@
+module Merb::Cache
+  # Store well suited for action caching.
+  class ActionStore < AbstractStrategyStore
+    def writable?(dispatch, parameters = {}, conditions = {})
+      case dispatch
+      when Merb::Controller
+        @stores.any?{|s| s.writable?(normalize(dispatch), parameters, conditions)}
+      else false
+      end
+    end
+
+    def read(dispatch, parameters = {})
+      if writable?(dispatch, parameters)
+        @stores.capture_first {|s| s.read(normalize(dispatch), parameters)}
+      end
+    end
+
+    def write(dispatch, data = nil, parameters = {}, conditions = {})
+      if writable?(dispatch, parameters, conditions)
+        @stores.capture_first {|s| s.write(normalize(dispatch), data || dispatch.body, parameters, conditions)}
+      end
+    end
+
+    def write_all(dispatch, data = nil, parameters = {}, conditions = {})
+      if writable?(dispatch, parameters, conditions)
+        @stores.map {|s| s.write_all(normalize(dispatch), data || dispatch.body, parameters, conditions)}.all?
+      end
+    end
+
+    def fetch(dispatch, parameters = {}, conditions = {}, &blk)
+      if writable?(dispatch, parameters, conditions)
+        read(dispatch, parameters) || @stores.capture_first {|s| s.fetch(normalize(dispatch), data || dispatch.body, parameters, conditions, &blk)}
+      end
+    end
+
+    def exists?(dispatch, parameters = {})
+      if writable?(dispatch, parameters)
+        @stores.capture_first {|s| s.exists?(normalize(dispatch), parameters)}
+      end
+    end
+
+    def delete(dispatch, parameters = {})
+      if writable?(dispatch, parameters)
+        @stores.map {|s| s.delete(normalize(dispatch), parameters)}.any?
+      end
+    end
+
+    def delete_all!
+      @stores.map {|s| s.delete_all!}.all?
+    end
+
+    def normalize(dispatch)
+      "#{dispatch.class.name}##{dispatch.action_name}" unless dispatch.class.name.blank? || dispatch.action_name.blank?
+    end
+  end
+end