cache_fu 0.1.2

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,102 @@
+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
+      ::ActionController::Base.cache_store = CACHE
+    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)
+          @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)
+        end
+
+        # override to skip caching/rendering on evaluated if option
+        def before(controller)
+          return unless @actions.include?(controller.action_name.intern)
+
+          if @options
+            action_cache_path = ActionController::Caching::Actions::ActionCachePath.new(controller, path_options_for(controller, @options))
+          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/railtie.rb

@@ -0,0 +1,13 @@
+require 'cache_fu'
+require 'rails'
+
+module ActsAsCached
+  class Railtie < Rails::Railtie
+    initializer 'cache_fu:extends' do
+    end
+
+    rake_tasks do
+      load 'tasks/memcached.rb'
+    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/cache_fu.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/acts_as_cached/config'
+require File.dirname(__FILE__) + '/acts_as_cached/cache_methods'
+require File.dirname(__FILE__) + '/acts_as_cached/fragment_cache'
+require File.dirname(__FILE__) + '/acts_as_cached/benchmarking'
+require File.dirname(__FILE__) + '/acts_as_cached/disabled'
+require File.dirname(__FILE__) + '/acts_as_cached/local_cache'
+require File.dirname(__FILE__) + '/acts_as_cached/railtie' if defined?(Rails::Railtie)
+
+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
+
+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!
+  end
+  ActsAsCached.config = YAML.load(ERB.new(IO.read(config_file)).result)
+end

data/lib/cache_fu.rb~

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/acts_as_cached/config'
+require File.dirname(__FILE__) + '/acts_as_cached/cache_methods'
+require File.dirname(__FILE__) + '/acts_as_cached/fragment_cache'
+require File.dirname(__FILE__) + '/acts_as_cached/benchmarking' 
+require File.dirname(__FILE__) + '/acts_as_cached/disabled'
+require File.dirname(__FILE__) + '/acts_as_cached/local_cache'
+require File.dirname(__FILE__) + '/acts_as_cached/railtie' if defined?(Rails::Railtie)
+
+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
+
+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!
+end
+
+ActsAsCached.config = YAML.load(ERB.new(IO.read(config_file)).result)

data/lib/cache_fu.rb~5453d1247ce57bb1ea5ad70936b97707d5dbdab0

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/acts_as_cached'

data/lib/cache_fu.rb~5453d1247ce57bb1ea5ad70936b97707d5dbdab0_0

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/acts_as_cached'

data/lib/tasks/memcached.rake

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

data/rails/init.rb

@@ -0,0 +1,34 @@
+begin
+  require 'memcache'
+rescue LoadError
+end
+
+begin
+  require 'memcached'
+rescue LoadError
+end
+
+begin
+  require 'mem_cache_with_consistent_hashing'
+rescue LoadError
+end
+
+puts "=> You should be using the `dalli' or `memcache-client' gem.  You're using RubyMemcache!" if Object.const_defined?(:RubyMemcache)
+
+require 'cache_fu'
+
+Object.send :include, ActsAsCached::Mixin
+
+unless File.exists?(config_file = Rails.root.join('config', 'memcached.yml'))
+  error = "No config file found.  Make sure you used `script/plugin install' and have memcached.yml in your config directory."
+  puts error
+  logger.error error
+  exit!
+end
+
+ActsAsCached.config = YAML.load(ERB.new(IO.read(config_file)).result)
+
+begin
+  require 'extensions'
+rescue LoadError
+end

data/test/benchmarking_test.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), 'helper')
+
+ActsAsCached.config.clear
+config = YAML.load_file(File.join(File.dirname(__FILE__), '../defaults/memcached.yml.default'))
+config['test'] = config['development']
+ActsAsCached.config = config
+Story.send :acts_as_cached
+
+context "When benchmarking is enabled" do
+  specify "ActionController::Base should respond to rendering_runtime_with_memcache" do
+    ActionController::Base.new.should.respond_to :rendering_runtime_with_memcache
+  end
+
+  specify "cachable Ruby classes should be respond to :logger" do
+    Story.should.respond_to :logger
+  end
+
+  specify "a cached object should gain a fetch_cache with and without benchmarking methods" do
+    Story.should.respond_to :fetch_cache_with_benchmarking
+    Story.should.respond_to :fetch_cache_without_benchmarking
+  end
+
+  specify "cache_benchmark should yield and time any action" do
+    ActsAsCached::Benchmarking.cache_runtime.should.equal 0.0
+
+    level = Class.new { |k| def k.method_missing(*args) true end }
+    Story.stubs(:logger).returns(level)
+
+    Story.cache_benchmark("Seriously, nothing.", true) {
+      sleep 0.01
+     "Nothing."
+    }.should.equal "Nothing."
+
+    ActsAsCached::Benchmarking.cache_runtime.should.be > 0.0
+  end
+end