revo-cache_fu 1.0.0

data/lib/acts_as_cached/cache_methods.rb

@@ -0,0 +1,305 @@
+module ActsAsCached
+  module ClassMethods
+    @@nil_sentinel = :_nil
+
+    def cache_config
+      config = ActsAsCached::Config.class_config[cache_name] ||= {}
+      if name == cache_name
+        config
+      else
+        # sti
+        ActsAsCached::Config.class_config[name] ||= config.dup
+      end
+    end
+
+    def cache_options
+      cache_config[:options] ||= {}
+    end
+
+    def get_cache(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      args    = args.flatten
+
+      ##
+      # head off to get_caches if we were passed multiple cache_ids
+      if args.size > 1 
+        return get_caches(args, options) 
+      else
+        cache_id = args.first
+      end
+
+      if (item = fetch_cache(cache_id)).nil?
+        set_cache(cache_id, block_given? ? yield : fetch_cachable_data(cache_id), options[:ttl])
+      else
+        @@nil_sentinel == item ? nil : item
+      end
+    end
+
+    ##
+    # This method accepts an array of cache_ids which it will use to call 
+    # get_multi on your cache store.  Any misses will be fetched and saved to 
+    # the cache, and a hash keyed by cache_id will ultimately be returned.
+    #
+    # If your cache store does not support #get_multi an exception will be raised.
+    def get_caches(*args)
+      raise NoGetMulti unless cache_store.respond_to? :get_multi
+
+      options   = args.last.is_a?(Hash) ? args.pop : {}
+      cache_ids = args.flatten.map(&:to_s)
+      keys      = cache_keys(cache_ids)
+
+      # Map memcache keys to object cache_ids in { memcache_key => object_id } format
+      keys_map = Hash[*keys.zip(cache_ids).flatten]
+
+      # Call get_multi and figure out which keys were missed based on what was a hit
+      hits = ActsAsCached.config[:disabled] ? {} : (cache_store(:get_multi, *keys) || {})
+
+      # Misses can take the form of key => nil
+      hits.delete_if { |key, value| value.nil? }
+
+      misses = keys - hits.keys
+      hits.each { |k, v| hits[k] = nil if v == @@nil_sentinel }
+
+      # Return our hash if there are no misses
+      return hits.values.index_by(&:cache_id) if misses.empty?
+
+      # Find any missed records
+      needed_ids     = keys_map.values_at(*misses)
+      missed_records = Array(fetch_cachable_data(needed_ids))
+
+      # Cache the missed records
+      missed_records.each { |missed_record| missed_record.set_cache(options[:ttl]) }
+
+      # Return all records as a hash indexed by object cache_id
+      (hits.values + missed_records).index_by(&:cache_id)
+    end
+
+    # simple wrapper for get_caches that
+    # returns the items as an ordered array
+    def get_caches_as_list(*args)
+      cache_ids = args.last.is_a?(Hash) ? args.first : args
+      cache_ids = [cache_ids].flatten
+      hash      = get_caches(*args)
+      
+      cache_ids.map do |key|
+        hash[key]
+      end
+    end
+
+    def set_cache(cache_id, value, ttl = nil)
+      returning(value) do |v|
+        v = @@nil_sentinel if v.nil?
+        cache_store(:set, cache_key(cache_id), v, ttl || cache_config[:ttl] || 1500)
+      end
+    end
+
+    def expire_cache(cache_id = nil)
+      cache_store(:delete, cache_key(cache_id)) 
+      true
+    end
+    alias :clear_cache :expire_cache
+
+    def reset_cache(cache_id = nil)
+      set_cache(cache_id, fetch_cachable_data(cache_id))
+    end
+
+    ##
+    # Encapsulates the pattern of writing custom cache methods
+    # which do nothing but wrap custom finders.
+    #
+    #   => Story.caches(:find_popular)
+    #
+    #   is the same as
+    #
+    #   def self.cached_find_popular
+    #     get_cache(:find_popular) { find_popular }
+    #   end
+    #
+    #  The method also accepts both a :ttl and/or a :with key.
+    #  Obviously the :ttl value controls how long this method will
+    #  stay cached, while the :with key's value will be passed along
+    #  to the method.  The hash of the :with key will be stored with the key,
+    #  making two near-identical #caches calls with different :with values utilize
+    #  different caches.
+    #
+    #  => Story.caches(:find_popular, :with => :today)
+    #
+    #  is the same as
+    #
+    #   def self.cached_find_popular
+    #     get_cache("find_popular:today") { find_popular(:today) }
+    #   end
+    #   
+    # If your target method accepts multiple parameters, pass :withs an array.
+    #
+    # => Story.caches(:find_popular, :withs => [ :one, :two ])
+    #
+    # is the same as
+    #
+    #   def self.cached_find_popular
+    #     get_cache("find_popular:onetwo") { find_popular(:one, :two) }
+    #   end
+    def caches(method, options = {})
+      if options.keys.include?(:with) 
+        with = options.delete(:with)
+        get_cache("#{method}:#{with}", options) { send(method, with) }
+      elsif withs = options.delete(:withs)
+        get_cache("#{method}:#{withs}", options) { send(method, *withs) }
+      else
+        get_cache(method, options) { send(method) }
+      end
+    end
+    alias :cached :caches
+
+    def cached?(cache_id = nil)
+      fetch_cache(cache_id).nil? ? false : true
+    end
+    alias :is_cached? :cached?
+
+    def fetch_cache(cache_id)
+      return if ActsAsCached.config[:skip_gets]
+
+      autoload_missing_constants do 
+        cache_store(:get, cache_key(cache_id))
+      end
+    end
+
+    def fetch_cachable_data(cache_id = nil)
+      finder = cache_config[:finder] || :find
+      return send(finder) unless cache_id
+
+      args = [cache_id]
+      args << cache_options.dup unless cache_options.blank?
+      send(finder, *args)
+    end
+    
+    def cache_namespace
+      cache_store(:namespace)
+    end
+    
+    # Memcache-client automatically prepends the namespace, plus a colon, onto keys, so we take that into account for the max key length.
+    # Rob Sanheim
+    def max_key_length
+      unless @max_key_length
+        key_size = cache_config[:key_size] || 250
+        @max_key_length = cache_namespace ? (key_size - cache_namespace.length - 1) : key_size
+      end
+      @max_key_length 
+    end
+
+    def cache_name
+      @cache_name ||= respond_to?(:base_class) ? base_class.name : name
+    end
+
+    def cache_keys(*cache_ids)
+      cache_ids.flatten.map { |cache_id| cache_key(cache_id) }
+    end
+
+    def cache_key(cache_id)
+      [cache_name, cache_config[:version], cache_id].compact.join(':').gsub(' ', '_')[0..(max_key_length - 1)]
+    end
+
+    def cache_store(method = nil, *args)
+      return cache_config[:store] unless method
+
+      load_constants = %w( get get_multi ).include? method.to_s
+
+      swallow_or_raise_cache_errors(load_constants) do
+        cache_config[:store].send(method, *args)
+      end
+    end
+
+    def swallow_or_raise_cache_errors(load_constants = false, &block)
+      load_constants ? autoload_missing_constants(&block) : yield
+    rescue TypeError => error
+      if error.to_s.include? 'Proc' 
+        raise MarshalError, "Most likely an association callback defined with a Proc is triggered, see http://ar.rubyonrails.com/classes/ActiveRecord/Associations/ClassMethods.html (Association Callbacks) for details on converting this to a method based callback" 
+      else
+        raise error
+      end
+    rescue Exception => error
+      if ActsAsCached.config[:raise_errors]
+        raise error
+      else
+        RAILS_DEFAULT_LOGGER.debug "MemCache Error: #{error.message}" rescue nil
+        nil
+      end      
+    end
+
+    def autoload_missing_constants
+      yield
+    rescue ArgumentError, MemCache::MemCacheError => error
+      lazy_load ||= Hash.new { |hash, hash_key| hash[hash_key] = true; false }
+      if error.to_s[/undefined class|referred/] && !lazy_load[error.to_s.split.last.constantize] then retry
+      else raise error end
+    end
+  end
+
+  module InstanceMethods
+    def self.included(base)
+      base.send :delegate, :cache_config,  :to => 'self.class'
+      base.send :delegate, :cache_options, :to => 'self.class'
+    end
+
+    def get_cache(key = nil, options = {}, &block)
+      self.class.get_cache(cache_id(key), options, &block)
+    end
+
+    def set_cache(ttl = nil)
+      self.class.set_cache(cache_id, self, ttl)
+    end
+
+    def reset_cache(key = nil)
+      self.class.reset_cache(cache_id(key))
+    end
+
+    def expire_cache(key = nil)
+      self.class.expire_cache(cache_id(key))
+    end
+    alias :clear_cache :expire_cache
+
+    def cached?(key = nil)
+      self.class.cached? cache_id(key)
+    end
+
+    def cache_key
+      self.class.cache_key(cache_id)
+    end
+    
+    def cache_id(key = nil)
+      id = send(cache_config[:cache_id] || :id)
+      key.nil? ? id : "#{id}:#{key}"
+    end
+
+    def caches(method, options = {})
+      key = "#{id}:#{method}"
+      if options.keys.include?(:with)
+        with = options.delete(:with)
+        self.class.get_cache("#{key}:#{with}", options) { send(method, with) }
+      elsif withs = options.delete(:withs)
+        self.class.get_cache("#{key}:#{withs}", options) { send(method, *withs) }
+      else
+        self.class.get_cache(key, options) { send(method) }
+      end
+    end
+    alias :cached :caches
+
+    # Ryan King
+    def set_cache_with_associations
+      Array(cache_options[:include]).each do |assoc|
+        send(assoc).reload
+      end if cache_options[:include]
+      set_cache
+    end
+
+    # Lourens Naud
+    def expire_cache_with_associations(*associations_to_sweep)
+      (Array(cache_options[:include]) + associations_to_sweep).flatten.uniq.compact.each do |assoc|
+        Array(send(assoc)).compact.each { |item| item.expire_cache if item.respond_to?(:expire_cache) }
+      end 
+      expire_cache
+    end
+  end
+  
+  class MarshalError < StandardError; end
+end

data/lib/acts_as_cached/config.rb

@@ -0,0 +1,97 @@
+module ActsAsCached
+  module Config
+    extend self
+
+    @@class_config = {}
+    mattr_reader :class_config
+
+    def valued_keys
+      [ :store, :version, :pages, :per_page, :ttl, :finder, :cache_id, :find_by, :key_size ]
+    end
+
+    def setup(options)
+      config = options['defaults']
+
+      case options[RAILS_ENV]
+      when Hash   then config.update(options[RAILS_ENV]) 
+      when String then config[:disabled] = true 
+      end
+
+      config.symbolize_keys!
+
+      setup_benchmarking! if config[:benchmarking] && !config[:disabled]
+
+      setup_cache_store! config
+      config
+    end
+
+    def setup_benchmarking!
+      Benchmarking.inject_into_logs!
+    end
+
+    def setup_cache_store!(config)
+      config[:store] = 
+        if config[:store].nil?
+          setup_memcache config
+        elsif config[:store].respond_to? :constantize
+          config[:store].constantize.new
+        else
+          config[:store]
+        end
+    end
+
+    def setup_memcache(config)
+      config[:namespace] << "-#{RAILS_ENV}"
+
+      # if someone (e.g., interlock) already set up memcached, then
+      # we need to stop here
+      return CACHE if Object.const_defined?(:CACHE)
+
+      silence_warnings do
+        Object.const_set :CACHE, memcache_client(config)
+        Object.const_set :SESSION_CACHE, memcache_client(config) if config[:session_servers]
+      end
+
+      CACHE.servers = Array(config.delete(:servers))
+      SESSION_CACHE.servers = Array(config[:session_servers]) if config[:session_servers]
+     
+      setup_session_store   if config[:sessions]
+      setup_fragment_store! if config[:fragments]
+      setup_fast_hash!      if config[:fast_hash]
+      setup_fastest_hash!   if config[:fastest_hash]
+
+      CACHE
+    end
+
+    def memcache_client(config)
+      (config[:client] || "MemCache").classify.constantize.new(config)
+    end
+
+    def setup_session_store
+      ActionController::Base.session_store = :mem_cache_store
+      ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS.update 'cache' => defined?(SESSION_CACHE) ? SESSION_CACHE : CACHE
+    end
+
+    def setup_fragment_store!
+      ActsAsCached::FragmentCache.setup!
+    end
+
+    # break compatiblity with non-ruby memcache clients in exchange for speedup.
+    # consistent across all platforms.
+    def setup_fast_hash!
+      def CACHE.hash_for(key)
+        (0...key.length).inject(0) do |sum, i|
+          sum + key[i]
+        end
+      end
+    end
+
+    # break compatiblity with non-ruby memcache clients in exchange for speedup.
+    # NOT consistent across all platforms.  Object#hash gives different results
+    # on different architectures.  only use if all your apps are running the
+    # same arch.
+    def setup_fastest_hash!
+      def CACHE.hash_for(key) key.hash end
+    end
+  end
+end

data/lib/acts_as_cached/disabled.rb

@@ -0,0 +1,30 @@
+module ActsAsCached
+  module Disabled
+    def fetch_cache_with_disabled(*args)
+      nil
+    end
+
+    def set_cache_with_disabled(*args)
+      args[1]
+    end
+
+    def expire_cache_with_disabled(*args)
+      true
+    end
+
+    def self.add_to(klass)
+      return if klass.respond_to? :fetch_cache_with_disabled
+      klass.extend self
+
+      class << klass
+        alias_method_chain :fetch_cache,  :disabled
+        alias_method_chain :set_cache,    :disabled
+        alias_method_chain :expire_cache, :disabled
+      end
+
+      class << CACHE
+        include FragmentCache::DisabledExtensions
+      end if ActsAsCached.config[:fragments] && defined?(FragmentCache::DisabledExtensions)
+    end
+  end
+end

data/lib/acts_as_cached/fragment_cache.rb

@@ -0,0 +1,124 @@
+module ActsAsCached
+  module FragmentCache
+    def self.setup!
+      class << CACHE
+        include Extensions
+      end
+      
+      setup_fragment_cache_cache
+      setup_rails_for_memcache_fragments
+      setup_rails_for_action_cache_options
+    end
+    
+    # add :ttl option to cache helper and set cache store memcache object
+    def self.setup_rails_for_memcache_fragments
+      if ::ActionView.const_defined?(:Template)
+        # Rails 2.1+
+        ::ActionController::Base.cache_store = CACHE
+      else
+        # Rails < svn r8619
+        ::ActionView::Helpers::CacheHelper.class_eval do
+          def cache(name = {}, options = nil, &block)
+            @controller.cache_erb_fragment(block, name, options)
+          end
+        end
+        ::ActionController::Base.fragment_cache_store = CACHE
+      end
+    end
+
+    def self.setup_fragment_cache_cache
+      Object.const_set(:FragmentCacheCache, Class.new { acts_as_cached :store => CACHE })
+    end
+    
+    # add :ttl option to caches_action on the per action level by passing in a hash instead of an array
+    # 
+    # Examples:
+    #  caches_action :index                                       # will use the default ttl from your memcache.yml, or 25 minutes
+    #  caches_action :index => { :ttl => 5.minutes }              # cache index action with 5 minute ttl
+    #  caches_action :page, :feed, :index => { :ttl => 2.hours }  # cache index action with 2 hours ttl, all others use default
+    #
+    def self.setup_rails_for_action_cache_options
+      ::ActionController::Caching::Actions::ActionCacheFilter.class_eval do
+        # convert all actions into a hash keyed by action named, with a value of a ttl hash (to match other cache APIs)
+        def initialize(*actions, &block)
+          if [].respond_to?(:extract_options!)
+            #edge
+            @options = actions.extract_options!
+            @actions = actions.inject(@options.except(:cache_path)) do |hsh, action|
+              action.is_a?(Hash) ? hsh.merge(action) : hsh.merge(action => { :ttl => nil })
+            end
+            @options.slice!(:cache_path)
+          else
+            #1.2.5
+            @actions = actions.inject({}) do |hsh, action|
+              action.is_a?(Hash) ? hsh.merge(action) : hsh.merge(action => { :ttl => nil })
+            end
+          end
+        end
+
+        # override to skip caching/rendering on evaluated if option
+        def before(controller)
+          return unless @actions.include?(controller.action_name.intern)
+
+          # maintaining edge and 1.2.x compatibility with this branch
+          if @options
+            action_cache_path = ActionController::Caching::Actions::ActionCachePath.new(controller, path_options_for(controller, @options))
+          else
+            action_cache_path = ActionController::Caching::Actions::ActionCachePath.new(controller)
+          end
+          
+          # should probably be like ActiveRecord::Validations.evaluate_condition.  color me lazy.
+          if conditional = @actions[controller.action_name.intern][:if]
+            conditional = conditional.respond_to?(:call) ? conditional.call(controller) : controller.send(conditional)
+          end
+          @actions.delete(controller.action_name.intern) if conditional == false
+
+          cache = controller.read_fragment(action_cache_path.path)
+          if cache && (conditional || conditional.nil?)
+            controller.rendered_action_cache = true
+            if method(:set_content_type!).arity == 2
+              set_content_type!(controller, action_cache_path.extension)
+            else
+              set_content_type!(action_cache_path)
+            end
+            controller.send(:render, :text => cache)
+            false
+          else
+            # 1.2.x compatibility
+            controller.action_cache_path = action_cache_path if controller.respond_to? :action_cache_path
+          end
+        end
+        
+        # override to pass along the ttl hash
+        def after(controller)
+          return if !@actions.include?(controller.action_name.intern) || controller.rendered_action_cache
+          # 1.2.x compatibility
+          path = controller.respond_to?(:action_cache_path) ? controller.action_cache_path.path : ActionController::Caching::Actions::ActionCachePath.path_for(controller)
+          controller.write_fragment(path, controller.response.body, action_ttl(controller))
+        end
+
+        private
+        def action_ttl(controller)
+          @actions[controller.action_name.intern]
+        end
+      end
+    end
+
+    module Extensions
+      def read(*args)
+        return if ActsAsCached.config[:skip_gets]
+        FragmentCacheCache.cache_store(:get, args.first)
+      end
+      
+      def write(name, content, options = {}) 
+        ttl = (options.is_a?(Hash) ? options[:ttl] : nil) || ActsAsCached.config[:ttl] || 25.minutes
+        FragmentCacheCache.cache_store(:set, name, content, ttl)
+      end
+    end
+
+    module DisabledExtensions
+      def read(*args) nil end
+      def write(*args) "" end
+    end
+  end
+end

data/lib/acts_as_cached/local_cache.rb

@@ -0,0 +1,44 @@
+module ActsAsCached
+  module LocalCache
+    @@local_cache = {}
+    mattr_accessor :local_cache
+
+    def fetch_cache_with_local_cache(*args)
+      @@local_cache[cache_key(args.first)] ||= fetch_cache_without_local_cache(*args)
+    end
+
+    def set_cache_with_local_cache(*args)
+      @@local_cache[cache_key(args.first)] = set_cache_without_local_cache(*args)
+    end
+
+    def expire_cache_with_local_cache(*args)
+      @@local_cache.delete(cache_key(args.first))
+      expire_cache_without_local_cache(*args)
+    end
+    alias :clear_cache_with_local_cache :expire_cache_with_local_cache
+    
+    def cached_with_local_cache?(*args)
+      !!@@local_cache[cache_key(args.first)] || cached_without_local_cache?(*args)
+    end
+
+    def self.add_to(klass)
+      return if klass.ancestors.include? self
+      klass.send :include, self
+
+      klass.class_eval do
+        %w( fetch_cache set_cache expire_cache clear_cache cached? ).each do |target|
+          alias_method_chain target, :local_cache
+        end
+      end
+    end
+  end
+end
+
+module ActionController
+  class Base
+    def local_cache_for_request
+      ActsAsCached::LocalCache.add_to ActsAsCached::ClassMethods 
+      ActsAsCached::LocalCache.local_cache = {}
+    end
+  end
+end 

data/lib/acts_as_cached/memcached_rails.rb

@@ -0,0 +1,17 @@
+class Memcached
+  # A legacy compatibility wrapper for the Memcached class. It has basic compatibility with the <b>memcache-client</b> API.
+  class Rails < ::Memcached
+    def initialize(config)
+      super(config.delete(:servers), config.slice(DEFAULTS.keys))
+    end   
+
+    def servers=(servers)
+      
+    end
+    
+    def delete(key, expiry = 0)
+      super(key)
+    rescue NotFound
+    end
+  end
+end

data/lib/acts_as_cached/recipes.rb

@@ -0,0 +1,8 @@
+Capistrano.configuration(:must_exist).load do
+  %w(start stop restart kill status).each do |cmd|
+    desc "#{cmd} your memcached servers"
+    task "memcached_#{cmd}".to_sym, :roles => :app do
+      run "RAILS_ENV=production #{ruby} #{current_path}/script/memcached_ctl #{cmd}"
+    end
+  end
+end

data/lib/acts_as_cached.rb

@@ -0,0 +1,51 @@
+require 'acts_as_cached/config'
+require 'acts_as_cached/cache_methods'
+require 'acts_as_cached/fragment_cache'
+require 'acts_as_cached/benchmarking' 
+require 'acts_as_cached/disabled'
+require 'acts_as_cached/local_cache'
+require 'acts_as_cached/memcached_rails'
+
+module ActsAsCached
+  @@config = {}
+  mattr_reader :config
+
+  def self.config=(options)
+    @@config = Config.setup options
+  end
+
+  def self.skip_cache_gets=(boolean)
+    ActsAsCached.config[:skip_gets] = boolean
+  end
+
+  module Mixin
+    def acts_as_cached(options = {})
+      extend  ClassMethods
+      include InstanceMethods
+
+      extend  Extensions::ClassMethods    if defined? Extensions::ClassMethods
+      include Extensions::InstanceMethods if defined? Extensions::InstanceMethods
+
+      options.symbolize_keys!
+
+      options[:store] ||= ActsAsCached.config[:store] 
+      options[:ttl]   ||= ActsAsCached.config[:ttl] 
+
+      # convert the find_by shorthand
+      if find_by = options.delete(:find_by)
+        options[:finder]   = "find_by_#{find_by}".to_sym
+        options[:cache_id] = find_by
+      end
+      
+      cache_config.replace  options.reject { |key,| not Config.valued_keys.include? key }
+      cache_options.replace options.reject { |key,| Config.valued_keys.include? key }
+
+      Disabled.add_to self and return if ActsAsCached.config[:disabled]
+      Benchmarking.add_to self if ActsAsCached.config[:benchmarking]
+    end
+  end
+
+  class CacheException < StandardError; end
+  class NoCacheStore   < CacheException; end
+  class NoGetMulti     < CacheException; end
+end