cache_fu 0.1.5 → 0.2.0.pre0

data/LICENSE

@@ -1,18 +1,19 @@
+Copyright (c) 2011 Kreeti Technologies
 Copyright (c) 2007 Chris Wanstrath
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of 
-this software and associated documentation files (the "Software"), to deal in 
-the Software without restriction, including without limitation the rights to 
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 
-the Software, and to permit persons to whom the Software is furnished to do so, 
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
 subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all 
+The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -3,7 +3,11 @@
 A rewrite of acts_as_cached.
 This version is only compatible with rails 3 and above.
 
-For fragment and page caching use Rails inbuilt MemCacheStore as it already provides all the functionality.
+This gem version uses Dalli.
+If you want a memcache compatible version then see the branch memcache_client or use version 0.1.5 of the gem.
+
+For fragment and page caching use Rails DalliStore as it already provides all the functionality.
+
 This gem is very useful for caching in models.
 
 == Changes from acts_as_cached 1
@@ -17,5 +21,4 @@ This gem is very useful for caching in models.
 - set_cache on an instance can take a ttl
     >> @story.set_cache(15.days)
 
-
-Chris Wanstrath [ chris[at]ozmm[dot]org ]
+Surendra Singhi [ ssinghi[at]kreeti[dot]com]

data/lib/acts_as_cached/benchmarking.rb

@@ -2,62 +2,33 @@ require 'benchmark'
 
 module ActsAsCached
   module Benchmarking #:nodoc:
-    def self.cache_runtime
-      @@cache_runtime ||= 0.0
+    def self.runtime=(value)
+      Thread.current['memcache_runtime'] = value
     end
 
-    def self.cache_reset_runtime
-      @@cache_runtime = nil
+    def self.runtime
+      Thread.current['memcache_runtime'] ||= 0.0
     end
 
-    def cache_benchmark(title, log_level = Logger::DEBUG, use_silence = true)
-      return yield unless logger && logger.level == log_level
-      result = nil
-
-      seconds = Benchmark.realtime {
-        result = use_silence ? ActionController::Base.silence { yield } : yield
-      }
-
-      @@cache_runtime ||= 0.0
-      @@cache_runtime += seconds
-
-      logger.add(log_level, "==> #{title} (#{'%.5f' % seconds})")
-      result
-    end
-
-    def fetch_cache_with_benchmarking(*args)
-      cache_benchmark "Got #{cache_key args.first} from cache." do
-        fetch_cache_without_benchmarking(*args)
-      end
-    end
-
-    def set_cache_with_benchmarking(*args)
-      cache_benchmark "Set #{cache_key args.first} to cache." do
-        set_cache_without_benchmarking(*args)
-      end
-    end
-
-    def expire_cache_with_benchmarking(*args)
-      cache_benchmark "Deleted #{cache_key args.first} from cache." do
-        expire_cache_without_benchmarking(*args)
-      end
+    def self.reset_runtime
+      rt, self.runtime = runtime, 0
+      rt
     end
 
-    def self.add_to(klass)
-      return if klass.respond_to? :fetch_cache_with_benchmarking
-      klass.extend self
+    def self.benchmark(event)
+      self.runtime += event.duration
+      return unless Rails.logger && Rails.logger.debug?
 
-      class << klass
-        alias_method_chain :fetch_cache,  :benchmarking
-        alias_method_chain :set_cache,    :benchmarking
-        alias_method_chain :expire_cache, :benchmarking
-
-        def logger; Rails.logger end unless respond_to? :logger
-      end
+      Rails.logger.debug("Cache #{event.name.sub('cache_','').sub('.active_support','')} ==> #{event.payload[:key]} (#{'%.1fms' % event.duration}) #{'HIT' if event.payload[:hit]}#{'MISS' if event.payload[:miss]}")
     end
   end
 end
 
+ActiveSupport::Notifications.subscribe /cache/ do |*args|
+  event =  ActiveSupport::Notifications::Event.new(*args)
+  ActsAsCached::Benchmarking.benchmark(event)
+end
+
 module ActsAsCached
   module MemcacheRuntime
     extend ActiveSupport::Concern
@@ -65,8 +36,8 @@ module ActsAsCached
 
     def append_info_to_payload(payload)
       super
-      payload[:memcache_runtime] = ActsAsCached::Benchmarking.cache_runtime
-      ActsAsCached::Benchmarking.cache_reset_runtime
+      payload[:memcache_runtime] = ActsAsCached::Benchmarking.runtime
+      ActsAsCached::Benchmarking.reset_runtime
     end
 
     module ClassMethods

data/lib/acts_as_cached/cache_methods.rb

@@ -29,7 +29,7 @@ module ActsAsCached
       end
 
       if (item = fetch_cache(cache_id)).nil?
-        set_cache(cache_id, block_given? ? yield : fetch_cachable_data(cache_id), options[:ttl])
+        set_cache(cache_id, block_given? ? yield : fetch_cachable_data(cache_id), options)
       else
         @@nil_sentinel == item ? nil : item
       end
@@ -40,10 +40,7 @@ module ActsAsCached
     # 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)
@@ -52,7 +49,7 @@ module ActsAsCached
       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) || {})
+      hits = ActsAsCached.config[:disabled] ? {} : (Rails.cache.read_multi(*keys) || {})
 
       # Misses can take the form of key => nil
       hits.delete_if { |key, value| value.nil? }
@@ -68,7 +65,7 @@ module ActsAsCached
       missed_records = Array(fetch_cachable_data(needed_ids))
 
       # Cache the missed records
-      missed_records.each { |missed_record| missed_record.set_cache(options[:ttl]) }
+      missed_records.each { |missed_record| missed_record.set_cache(options) }
 
       # Return all records as a hash indexed by object cache_id
       (hits.values + missed_records).index_by(&:cache_id)
@@ -86,15 +83,15 @@ module ActsAsCached
       end
     end
 
-    def set_cache(cache_id, value, ttl = nil)
+    def set_cache(cache_id, value, options = nil)
       value.tap do |v|
         v = @@nil_sentinel if v.nil?
-        cache_store(:set, cache_key(cache_id), v, ttl || cache_config[:ttl] || 1500)
+        Rails.cache.write(cache_key(cache_id), v, options)
       end
     end
 
     def expire_cache(cache_id = nil)
-      cache_store(:delete, cache_key(cache_id))
+      Rails.cache.delete(cache_key(cache_id))
       true
     end
     alias :clear_cache :expire_cache
@@ -152,16 +149,14 @@ module ActsAsCached
     alias :cached :caches
 
     def cached?(cache_id = nil)
-      fetch_cache(cache_id).nil? ? false : true
+      return false if ActsAsCached.config[:skip_gets]
+      Rails.cache.exist?(cache_key(cache_id))
     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
+      Rails.cache.read(cache_key(cache_id))
     end
 
     def fetch_cachable_data(cache_id = nil)
@@ -174,7 +169,7 @@ module ActsAsCached
     end
 
     def cache_namespace
-      cache_store.respond_to?(:namespace) ? cache_store(:namespace) : (CACHE.instance_variable_get('@options') && CACHE.instance_variable_get('@options')[:namespace])
+      Rails.cache.respond_to?(:namespace) ? Rails.cache.namespace : ActsAsCached.config[:namespace]
     end
 
     # Memcache-client automatically prepends the namespace, plus a colon, onto keys, so we take that into account for the max key length.
@@ -196,42 +191,7 @@ module ActsAsCached
     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.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.sub(/::$/, '').constantize] then retry
-      else raise error end
+      [cache_name, cache_config[:version], cache_id].compact.join('/').gsub(' ', '_')[0..(max_key_length - 1)]
     end
   end
 
@@ -245,8 +205,8 @@ module ActsAsCached
       self.class.get_cache(cache_id(key), options, &block)
     end
 
-    def set_cache(ttl = nil)
-      self.class.set_cache(cache_id, self, ttl)
+    def set_cache(options = nil)
+      self.class.set_cache(cache_id, self, options)
     end
 
     def reset_cache(key = nil)
@@ -262,22 +222,17 @@ module ActsAsCached
       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}"
+      key.nil? ? self.cache_key : "#{self.cache_key}/#{key}"
     end
 
     def caches(method, options = {})
-      key = "#{id}:#{method}"
+      key = "#{self.cache_key}/#{method}"
       if options.keys.include?(:with)
         with = options.delete(:with)
-        self.class.get_cache("#{key}:#{with}", options) { send(method, 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) }
+        self.class.get_cache("#{key}/#{withs}", options) { send(method, *withs) }
       else
         self.class.get_cache(key, options) { send(method) }
       end
@@ -300,8 +255,4 @@ module ActsAsCached
       expire_cache
     end
   end
-
-  class MarshalError < StandardError; end
-  class MemCache; end
-  class MemCache::MemCacheError < StandardError; end
 end

data/lib/acts_as_cached/railtie.rb

@@ -3,12 +3,14 @@ require 'rails'
 
 module ActsAsCached
   class Railtie < Rails::Railtie
-    initializer 'cache_fu:extends' do
-      ActiveSupport.on_load(:active_record) { extend ActsAsCached::Mixin }
-    end
+    initializer 'cache_fu.extends' do
+      ActiveSupport.on_load :active_record do
+        extend ActsAsCached::Mixin
+      end
 
-    rake_tasks do
-      load 'tasks/memcached.rake'
+      ActiveSupport.on_load :action_controller do
+        include ActsAsCached::MemcacheRuntime
+      end
     end
   end
 end

data/lib/cache_fu.rb

@@ -1,60 +1,46 @@
-require File.dirname(__FILE__) + '/acts_as_cached/config'
 require File.dirname(__FILE__) + '/acts_as_cached/cache_methods'
 require File.dirname(__FILE__) + '/acts_as_cached/benchmarking'
 require File.dirname(__FILE__) + '/acts_as_cached/disabled'
-require File.dirname(__FILE__) + '/acts_as_cached/railtie' if defined?(Rails::Railtie)
+require File.dirname(__FILE__) + '/acts_as_cached/railtie' if defined?(Rails)
 
 module ActsAsCached
   @@config = {}
   mattr_reader :config
 
   def self.config=(options)
-    @@config = Config.setup options
+    @@config = options
   end
 
   def self.skip_cache_gets=(boolean)
     ActsAsCached.config[:skip_gets] = boolean
   end
 
+  def self.valued_keys
+    [:version, :pages, :per_page, :finder, :cache_id, :find_by, :key_size]
+  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]
+      cache_config.replace  options.reject { |key,| not ActsAsCached.valued_keys.include? key }
+      cache_options.replace options.reject { |key,| ActsAsCached.valued_keys.include? key }
     end
   end
-
-  class CacheException < StandardError; end
-  class NoCacheStore   < CacheException; end
-  class NoGetMulti     < CacheException; end
 end
 
 Rails::Application.initializer("cache_fu") do
-  Object.send :include, ActsAsCached::Mixin
-  unless File.exists?(config_file = Rails.root.join('config', 'memcached.yml'))
-    error = "No config file found. If you used plugin version make sure you used `script/plugin install' or `rake memcached:cache_fu_install' if gem version and have memcached.yml in your config directory."
-    puts error
-    logger.error error
-    exit!
+  if File.exists?(config_file = Rails.root.join('config', 'memcached.yml'))
+    ActsAsCached.config = YAML.load(ERB.new(IO.read(config_file)).result)
   end
-  ActsAsCached.config = YAML.load(ERB.new(IO.read(config_file)).result)
+  ActsAsCached.config = {}
 end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: cache_fu
 version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.1.5
+  prerelease: 6
+  version: 0.2.0.pre0
 platform: ruby
 authors: 
 - Surendra Singhi
@@ -47,12 +47,8 @@ extra_rdoc_files: []
 files: 
 - lib/acts_as_cached/benchmarking.rb
 - lib/acts_as_cached/cache_methods.rb
-- lib/acts_as_cached/config.rb
-- lib/acts_as_cached/disabled.rb
 - lib/acts_as_cached/railtie.rb
-- lib/acts_as_cached/recipes.rb
 - lib/cache_fu.rb
-- lib/tasks/memcached.rake
 - test/benchmarking_test.rb
 - test/cache_test.rb
 - test/config_test.rb
@@ -62,9 +58,6 @@ files:
 - test/helper.rb
 - test/local_cache_test.rb
 - test/sti_test.rb
-- defaults/extensions.rb.default
-- defaults/memcached.yml.default
-- defaults/memcached_ctl.default
 - LICENSE
 - README
 has_rdoc: true
@@ -85,9 +78,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      version: "0"
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: 

data/defaults/extensions.rb.default

@@ -1,40 +0,0 @@
-##
-# Copy this file to vendor/plugins/acts_as_cached/extensions.rb if you 
-# wish to extend acts_as_cached with your own instance or class methods.
-#
-# You can, of course, do this directly in your cached classes,
-# but keeping your custom methods here allows you to define
-# methods for all cached objects DRYly.
-module ActsAsCached
-  module Extensions
-    module ClassMethods
-      ##
-      # All acts_as_cached classes will be extended with 
-      # this method.
-      #
-      # >> Story.multi_get_cache(13, 353, 1231, 505)
-      # => [<Story:13>, <Story:353>, ...]
-      def multi_get_cache(*ids)
-        ids.flatten.map { |id| get_cache(id) }
-      end
-    end
-
-    module InstanceMethods
-      ##
-      # All instances of a acts_as_cached class will be 
-      # extended with this method.
-      #
-      # => story = Story.get_cache(1)
-      # => <Story:1>
-      # >> story.reset_included_caches
-      # => true
-      def reset_included_caches
-        return false unless associations = cache_config[:include]
-        associations.each do |association| 
-          Array(send(association)).each { |item| item.reset_cache }
-        end
-        true
-      end
-    end
-  end
-end

data/defaults/memcached.yml.default

@@ -1,32 +0,0 @@
-defaults:
-  ttl: 1800
-  readonly: false
-  urlencode: false
-  c_threshold: 10000
-  compression: true
-  debug: false
-  namespace: app
-  sessions: false
-  memory: 64
-  servers: localhost:11211
-  benchmarking: true
-  raise_errors: true
-  fast_hash: false
-  fastest_hash: false
-
-development:
-  sessions: false
-  fragments: false
-  servers: localhost:11211
-
-# turn off caching
-test:
-  disabled: true
-
-production:
-  memory: 256
-  benchmarking: false
-  servers:
-    - 192.185.254.121:11211
-    - 192.185.254.138:11211
-    - 192.185.254.160:11211

data/defaults/memcached_ctl.default

@@ -1,81 +0,0 @@
-#!/usr/bin/env ruby
-# By atmos@atmos.org
-# this goes in your script/ directory
-# it parses your memcached.yml file and hooks you up w/ some info
-# it keeps you from having to mess w/ stale memcached daemons for whatever reason.
-require 'yaml'
-require 'timeout'
-require 'erb'
-
-class MemcachedCtl
-  attr_accessor :memcached, :memory, :pids, :servers, :ip_address, :ethernet_device
-
-  def initialize
-    env = ENV['RAILS_ENV'] || 'development'
-    self.memcached = `which memcached`.chomp
-    self.servers = [ ]
-    self.pids    = { }
-    self.ethernet_device = ENV['ETH'] || 'eth0'
-    self.ip_address = get_ip_address || '0.0.0.0'
-    self.memory = '128'
-    
-    config = YAML.load(ERB.new(IO.read((File.expand_path(File.dirname(__FILE__) + "/../config/memcached.yml")))).result)
-    self.servers = [ config['defaults']['servers'] ].flatten rescue ['127.0.0.1:11211']
-    self.servers = [ config[env]['servers'] ].flatten if config[env]['servers']
-    self.servers.reject! { |server| host,port = server.split(/:/); self.ip_address == host }
-    self.memory = config[env]['memory'] unless config[env]['memory'].nil?
-    
-    each_server do |host,port|
-      `ps auwwx | grep memcached | grep '\\-l #{ip_address} \\-p #{port}' | grep -v grep`.split(/\n/).each do |line|
-        self.pids[port] = line.split(/\s+/)[1]
-      end
-      self.pids[port] ||= 'Down'
-    end
-  end
-  
-  def execute(cmd)
-    send(cmd) rescue usage
-  end
-  
-  def restart; stop; sleep 1; start end
-  
-  def status
-    each_server { |host,port| puts "Port #{port} -> #{pids[port] =~ /\d+/ ? 'Up' : 'Down'}" }
-  end
-  
-  def kill
-    each_server { |host,port| `kill -9 #{pids[port]} > /dev/null 2>&1` if pids[port] =~ /\d+/ }
-  end
-  
-  def stop; kill end
-  
-  def start
-    each_server do |host,port|
-      `#{memcached} -d -m #{memory} -l #{ip_address} -p #{port}`
-      STDERR.puts "Try memcached_ctl status" unless $? == 0
-    end
-  end
-
-  def usage
-    methods = %w[start stop restart kill status]
-    puts "Usage: script/memcached_ctl [ " + (methods * ' | ') + " ]"
-  end
-    
-protected
-  def each_server
-    servers.each do |server|
-      host, port = server.split(/:/)
-      yield host, port
-    end
-  end
-  
-  def get_ip_address # this works on linux you might have to tweak this on other oses
-    line = `/sbin/ifconfig #{ethernet_device} | grep inet | grep -v inet6`.chomp
-    if line =~ /\s*inet addr:((\d+\.){3}\d+)\s+.*/
-      self.ip_address = $1
-    end
-  end
-end
-###########################################################################
-
-MemcachedCtl.new.execute(ARGV.first)

data/lib/acts_as_cached/config.rb

@@ -1,106 +0,0 @@
-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!
-      ActiveSupport.on_load(:action_controller) do
-        include ActsAsCached::MemcacheRuntime
-      end
-    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.respond_to?(:servers=) ? (CACHE.servers = Array(config.delete(:servers))) : CACHE.instance_variable_set('@servers', Array(config.delete(:servers)))
-      CACHE.instance_variable_get('@options')[:namespace] = config[:namespace] if CACHE.instance_variable_get('@options')
-
-      SESSION_CACHE.servers = Array(config[:session_servers]) if config[:session_servers]
-
-      setup_session_store   if config[:sessions]
-      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
-      return # Set up session store like normal in config/application.rb
-      
-      ActionController::Base.session_store = :mem_cache_store
-      cache = defined?(SESSION_CACHE) ? SESSION_CACHE : CACHE
-      ActionController::Session::AbstractStore::DEFAULT_OPTIONS.update(
-        :memcache_server => cache.servers,
-        :readonly => cache.readonly?,
-        :failover => cache.failover,
-        :timeout => cache.timeout,
-        :logger => cache.logger,
-        :namespace => cache.namespace
-      )
-    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

@@ -1,30 +0,0 @@
-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/recipes.rb

@@ -1,8 +0,0 @@
-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/tasks/memcached.rake

@@ -1,59 +0,0 @@
-require 'yaml'
-require 'erb'
-
-namespace :memcached do
-  desc "Start memcached locally"
-  task :start do
-    ActsAsCached::Config.memcached ActsAsCached::Config.config_args
-    puts "memcached started"
-  end
-
-  desc "Restart memcached locally"
-  task :restart do
-    Rake::Task['memcached:stop'].invoke
-    Rake::Task['memcached:start'].invoke
-  end
-
-  desc "Stop memcached locally"
-  task :stop do
-    `killall memcached`
-    puts "memcached killed"
-  end
-
-  desc "Adds the cache_fu config file"
-  task :cache_fu_install do
-    defaults_dir = File.join(File.dirname(__FILE__), '../../defaults')
-
-    config_yaml  = File.join('.', 'config', 'memcached.yml')
-    default_yaml = File.join(defaults_dir, 'memcached.yml.default')
-    FileUtils.cp(default_yaml, config_yaml)
-
-    memcached_ctl = File.join('.', 'script', 'memcached_ctl')
-    default_ctl   = File.join(defaults_dir, 'memcached_ctl.default')
-    FileUtils.cp(default_ctl, memcached_ctl)
-  end
-end
-
-module ActsAsCached
-  module Config
-    def self.config
-      return @config if @config
-      config  = YAML.load(ERB.new(IO.read(Rails.root.to_s + '/config/memcached.yml')).result)
-      @config = config['defaults'].merge(config['development'])
-    end
-
-    def self.config_args
-      args = {
-           '-p' => Array(config['servers']).first.split(':').last,
-           '-c' => config['c_threshold'],
-           '-m' => config['memory'],
-           '-d' => ''
-           }
-      args.to_a * ' '
-    end
-
-    def self.memcached(*args)
-      `/usr/bin/env memcached #{args * ' '}`
-    end
-  end
-end