RubyGems - actionpack - Versions diffs - 1.2.0 → 1.3.0 - Mend

actionpack 1.2.0 → 1.3.0

Potentially problematic release.

This version of actionpack might be problematic. Click here for more details.

Files changed (40) hide show

data/CHANGELOG +78 -0
data/README +1 -1
data/install.rb +4 -2
data/lib/action_controller.rb +3 -0
data/lib/action_controller/base.rb +16 -8
data/lib/action_controller/caching.rb +401 -0
data/lib/action_controller/cgi_process.rb +2 -1
data/lib/action_controller/cookies.rb +3 -3
data/lib/action_controller/filters.rb +94 -24
data/lib/action_controller/layout.rb +63 -21
data/lib/action_controller/session/mem_cache_store.rb +1 -1
data/lib/action_controller/support/binding_of_caller.rb +72 -68
data/lib/action_controller/support/breakpoint.rb +526 -524
data/lib/action_controller/support/class_inheritable_attributes.rb +105 -29
data/lib/action_controller/support/core_ext.rb +1 -0
data/lib/action_controller/support/core_ext/hash.rb +5 -0
data/lib/action_controller/support/core_ext/hash/keys.rb +35 -0
data/lib/action_controller/support/core_ext/numeric.rb +7 -0
data/lib/action_controller/support/core_ext/numeric/bytes.rb +33 -0
data/lib/action_controller/support/core_ext/numeric/time.rb +59 -0
data/lib/action_controller/support/core_ext/string.rb +5 -0
data/lib/action_controller/support/core_ext/string/inflections.rb +41 -0
data/lib/action_controller/support/dependencies.rb +1 -14
data/lib/action_controller/support/inflector.rb +6 -6
data/lib/action_controller/support/misc.rb +0 -24
data/lib/action_controller/templates/rescues/_request_and_response.rhtml +7 -4
data/lib/action_controller/test_process.rb +9 -0
data/lib/action_controller/url_rewriter.rb +13 -5
data/lib/action_view/helpers/active_record_helper.rb +10 -3
data/lib/action_view/helpers/cache_helper.rb +10 -0
data/lib/action_view/helpers/form_helper.rb +25 -2
data/lib/action_view/helpers/form_options_helper.rb +1 -2
data/lib/action_view/helpers/url_helper.rb +8 -5
data/lib/action_view/partials.rb +2 -2
data/rakefile +6 -3
data/test/controller/filters_test.rb +118 -3
data/test/controller/render_test.rb +5 -0
data/test/controller/send_file_test.rb +24 -0
data/test/controller/url_test.rb +47 -2
metadata +16 -2

data/CHANGELOG CHANGED

@@ -1,3 +1,81 @@
+*1.3.0* (January 17th, 2005)
+* Added an extensive caching module that offers three levels of granularity (page, action, fragment) and a variety of stores.
+  Read more in ActionController::Caching.
+* Added the option of passing a block to ActiveRecordHelper#form in order to add more to the auto-generated form #469 [dom@sisna.com]
+    form("entry", :action => "sign") do |form|
+      form << content_tag("b", "Department")
+      form << collection_select("department", "id", @departments, "id", "name")
+    end
+* Added arrays as a value option for params in url_for and friends #467 [Eric Anderson]. Example:
+    url_for(:controller => 'user', :action => 'delete', :params => { 'username' =>  %( paul john steve ) } )
+    # => /user/delete?username[]=paul&username[]=john&username[]=steve
+* Fixed that controller tests can now assert on the use of cookies #466 [Alexey]
+* Fixed that send_file would "remember" all the files sent by adding to the headers again and again #458 [bitsweat]
+* Fixed url rewriter confusion when the controller or action name was a substring of the controller_prefix or action_prefix
+* Added conditional layouts like <tt>layout "weblog_standard", :except => :rss</tt> #452 [Marcel Molina]
+* Fixed that MemCacheStore wasn't included by default and added default MemCache object pointing to localhost #447 [Lucas Carlson]
+* Added fourth argument to render_collection_of_partials that allows you to specify local_assigns -- just like render_partial #432 [zenspider]
+* Fixed that host would choke when cgi.host returned nil #432 [Tobias Luetke]
+* Added that form helpers now take an index option #448 [Tim Bates]
+  Example:
+    text_field "person", "name", "index" => 3
+  Becomes:
+    <input type="text" name="person[3][name]" id="person_3_name" value="<%= @person.name %>" />
+* Fixed three issues with retrying breakpoints #417 [Florian Gross]
+  1. Don't screw up pages that use multiple values for the same parameter (?foo=bar&foo=qux was converted to ?foo=barqux)
+  2. Don't screw up all forms when you click the "Retry with Breakpoint" link multiple times instead of reloading
+     (This caused the parameters to be added multiple times for GET forms leading to trouble.)
+  3. Don't add ?BP-RETRY=1 multiple times
+* Added that all renders and redirects now return false, so they can be used as the last line in before_filters to stop execution.
+  Before:
+    def authenticate
+      unless @session[:authenticated]
+        redirect_to :controller => "account", :action => "login"
+        return false
+      end
+    end
+  After:
+    def authenticate
+      redirect_to(:controller => "account", :action => "login") unless @session[:authenticated]
+    end
+* Added conditional filters #431 [Marcel]. Example:
+    class JournalController < ActionController::Base
+      # only require authentication if the current action is edit or delete
+      before_filter :authorize, :only_on => [ :edit, :delete ]
+      private
+        def authorize
+          # redirect to login unless authenticated
+        end
+    end
+* Added Base#render_nothing as a cleaner way of doing render_text "" when you're not interested in returning anything but an empty response.
+* Added the possibility of passing nil to UrlHelper#link_to to use the link itself as the name
 *1.2.0* (January 4th, 2005)
 * Added MemCacheStore for storing session data in Danga's MemCache system [Bob Cottrell]

data/README CHANGED

@@ -145,7 +145,7 @@ A short rundown of the major features:
     Result of running hello_world action:
       <html><body><h1>Hello world</h1></body></html>
-  Learn more in link:classes/ActionController/Layout.html
+  Learn more in link:classes/ActionController/Layout/ClassMethods.html
 * Advanced redirection that makes pretty urls easy

data/install.rb CHANGED

@@ -19,7 +19,7 @@ unless $sitedir
 end
 makedirs = %w{ action_controller/assertions action_controller/cgi_ext
-               action_controller/session action_controller/support
+               action_controller/session action_controller/support action_controller/support/core_ext
                action_controller/templates action_controller/templates/rescues
                action_controller/templates/scaffolds
                action_view/helpers action_view/vendor action_view/vendor/builder
@@ -41,6 +41,7 @@ files = %w-
  action_controller/cgi_ext/cgi_ext.rb
  action_controller/cgi_ext/cgi_methods.rb
  action_controller/cgi_ext/cookie_performance_fix.rb
+ action_controller/caching.rb
  action_controller/cgi_process.rb
  action_controller/cookies.rb
  action_controller/dependencies.rb
@@ -60,7 +61,8 @@ files = %w-
  action_controller/support/class_inheritable_attributes.rb
  action_controller/support/class_attribute_accessors.rb
  action_controller/support/clean_logger.rb
- action_controller/support/cookie_performance_fix.rb
+ action_controller/support/core_ext/hash_ext.rb
+ action_controller/support/core_ext.rb
  action_controller/support/inflector.rb
  action_controller/support/binding_of_caller.rb
  action_controller/support/breakpoint.rb

data/lib/action_controller.rb CHANGED

@@ -23,6 +23,7 @@
 $:.unshift(File.dirname(__FILE__))
+require 'action_controller/support/core_ext'
 require 'action_controller/support/clean_logger'
 require 'action_controller/support/misc'
 require 'action_controller/support/dependencies'
@@ -39,6 +40,7 @@ require 'action_controller/scaffolding'
 require 'action_controller/helpers'
 require 'action_controller/cookies'
 require 'action_controller/cgi_process'
+require 'action_controller/caching'
 ActionController::Base.class_eval do
   include ActionController::Filters
@@ -51,6 +53,7 @@ ActionController::Base.class_eval do
   include ActionController::Helpers
   include ActionController::Cookies
   include ActionController::Session
+  include ActionController::Caching
 end
 require 'action_view'

data/lib/action_controller/base.rb CHANGED

@@ -4,6 +4,7 @@ require 'action_controller/url_rewriter'
 require 'action_controller/support/class_attribute_accessors'
 require 'action_controller/support/class_inheritable_attributes'
 require 'action_controller/support/inflector'
+require 'drb'
 module ActionController #:nodoc:
   class ActionControllerError < StandardError #:nodoc:
@@ -177,12 +178,11 @@ module ActionController #:nodoc:
     DEFAULT_RENDER_STATUS_CODE = "200 OK"
     DEFAULT_SEND_FILE_OPTIONS = {
-      :type         => 'application/octet_stream',
-      :disposition  => 'attachment',
+      :type         => 'application/octet_stream'.freeze,
+      :disposition  => 'attachment'.freeze,
       :stream       => true,
       :buffer_size  => 4096
-    }
+    }.freeze
     # Determines whether the view has access to controller internals @request, @response, @session, and @template.
     # By default, it does.
@@ -359,7 +359,7 @@ module ActionController #:nodoc:
       # <tt>render_action "show_many"</tt> in WeblogController#display will render "#{template_root}/weblog/show_many.rhtml" or
       # "#{template_root}/weblog/show_many.rxml".
       def render_action(action_name, status = nil) #:doc:
-        render default_template_name(action_name), status
+        render(default_template_name(action_name), status)
       end
       # Works like render, but disregards the template_root and requires a full path to the template that needs to be rendered. Can be
@@ -389,6 +389,13 @@ module ActionController #:nodoc:
         @response.headers["Status"] = status || DEFAULT_RENDER_STATUS_CODE
         @response.body = block_given? ? block : text
         @performed_render = true
+        return false
+      end
+      # Renders an empty response that can be used when the request is only interested in triggering an effect. Do note that good
+      # HTTP manners mandate that you don't use GET requests to trigger data changes.
+      def render_nothing(status = nil)
+        render_text "", status
       end
       # Sends the file by streaming it 4096 bytes at a time. This way the
@@ -434,7 +441,7 @@ module ActionController #:nodoc:
       # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9
       # for the Cache-Control header spec.
       def send_file(path, options = {}) #:doc:
-        raise MissingFile, path unless File.file?(path) and File.readable?(path)
+        raise MissingFile, "Cannot read file #{path}" unless File.file?(path) and File.readable?(path)
         options[:length]   ||= File.size(path)
         options[:filename] ||= File.basename(path)
@@ -537,6 +544,7 @@ module ActionController #:nodoc:
         logger.info("Redirected to #{url}") unless logger.nil?
         @response.redirect(url, permanently)
         @performed_redirect = true
+        return false
       end
       # Resets the session by clearsing out all the objects stored within and initializing a new session object.
@@ -596,7 +604,7 @@ module ActionController #:nodoc:
       def action_methods
         action_controller_classes = self.class.ancestors.reject{ |a| [Object, Kernel].include?(a) }
-        action_controller_classes.inject([]) { |action_methods, klass| action_methods + klass.instance_methods(false) }
+        action_controller_classes.inject([]) { |action_methods, klass| action_methods + klass.public_instance_methods(false) }
       end
       def add_variables_to_assigns
@@ -656,7 +664,7 @@ module ActionController #:nodoc:
           raise ArgumentError, ":#{arg} option required" if options[arg].nil?
         end
-        disposition = options[:disposition] || 'attachment'
+        disposition = options[:disposition].dup || 'attachment'
         disposition <<= %(; filename="#{options[:filename]}") if options[:filename]
         @headers.update(

data/lib/action_controller/caching.rb ADDED

@@ -0,0 +1,401 @@
+require 'fileutils'
+module ActionController #:nodoc:
+  # Caching is a cheap way of speeding up slow applications by keeping the result of calculations, renderings, and database calls
+  # around for subsequent requests. Action Controller affords you three approaches in varying levels of granularity: Page, Action, Fragment.
+  #
+  # You can read more about each approach and the sweeping assistance by clicking the modules below.
+  #
+  # Note: To turn off all caching and sweeping, set Base.perform_caching = false.
+  module Caching
+    def self.append_features(base) #:nodoc:
+      super
+      base.send(:include, Pages, Actions, Fragments, Sweeping)
+      base.class_eval do
+        @@perform_caching = true
+        cattr_accessor :perform_caching
+      end
+    end
+    # Page caching is an approach to caching where the entire action output of is stored as a HTML file that the web server
+    # can serve without going through the Action Pack. This can be as much as 100 times faster than going the process of dynamically
+    # generating the content. Unfortunately, this incredible speed-up is only available to stateless pages where all visitors
+    # are treated the same. Content management systems -- including weblogs and wikis -- have many pages that are a great fit
+    # for this approach, but account-based systems where people log in and manipulate their own data are often less likely candidates.
+    #
+    # Specifying which actions to cach is done through the <tt>caches</tt> class method:
+    #
+    #   class WeblogController < ActionController::Base
+    #     caches_page :show, :new
+    #   end
+    #
+    # This will generate cache files such as weblog/show/5 and weblog/new, which match the URLs used to trigger the dynamic
+    # generation. This is how the web server is able pick up a cache file when it exists and otherwise let the request pass on to
+    # the Action Pack to generate it.
+    #
+    # Expiration of the cache is handled by deleting the cached file, which results in a lazy regeneration approach where the cache
+    # is not restored before another hit is made against it. The API for doing so mimics the options from url_for and friends:
+    #
+    #   class WeblogController < ActionController::Base
+    #     def update
+    #       List.update(@params["list"]["id"], @params["list"])
+    #       expire_page :action => "show", :id => @params["list"]["id"]
+    #       redirect_to :action => "show", :id => @params["list"]["id"]
+    #     end
+    #   end
+    #
+    # Additionally, you can expire caches using Sweepers that act on changes in the model to determine when a cache is supposed to be
+    # expired.
+    #
+    # == Setting the cache directory
+    #
+    # The cache directory should be the document root for the web server and is set using Base.page_cache_directory = "/document/root".
+    # For Rails, this directory has already been set to RAILS_ROOT + "/public".
+    module Pages
+      def self.append_features(base) #:nodoc:
+        super
+        base.extend(ClassMethods)
+        base.class_eval do
+          @@page_cache_directory = defined?(RAILS_ROOT) ? "#{RAILS_ROOT}/public" : ""
+          cattr_accessor :page_cache_directory
+        end
+      end
+      module ClassMethods
+        # Expires the page that was cached with the +path+ as a key. Example:
+        #   expire_page "/lists/show"
+        def expire_page(path)
+          return unless perform_caching
+          File.delete(page_cache_path(path)) if File.exists?(page_cache_path(path))
+          logger.info "Expired page: #{path}" unless logger.nil?
+        end
+        # Manually cache the +content+ in the key determined by +path+. Example:
+        #   cache_page "I'm the cached content", "/lists/show"
+        def cache_page(content, path)
+          return unless perform_caching
+          FileUtils.makedirs(File.dirname(page_cache_path(path)))
+          File.open(page_cache_path(path), "w+") { |f| f.write(content) }
+          logger.info "Cached page: #{path}" unless logger.nil?
+        end
+        # Caches the +actions+ using the page-caching approach that'll store the cache in a path within the page_cache_directory that
+        # matches the triggering url.
+        def caches_page(*actions)
+          return unless perform_caching
+          actions.each do |action|
+            class_eval "after_filter { |c| c.cache_page if c.action_name == '#{action}' }"
+          end
+        end
+        private
+          def page_cache_path(path)
+            if path[-1,1] == '/'
+              page_cache_directory + path + '/index'
+            else
+              page_cache_directory + path
+            end
+          end
+      end
+      # Expires the page that was cached with the +options+ as a key. Example:
+      #   expire_page :controller => "lists", :action => "show"
+      def expire_page(options = {})
+        return unless perform_caching
+        if options[:action].is_a?(Array)
+          options[:action].dup.each do |action|
+            self.class.expire_page(url_for(options.merge({ :only_path => true, :action => action })))
+          end
+        else
+          self.class.expire_page(url_for(options.merge({ :only_path => true })))
+        end
+      end
+      # Manually cache the +content+ in the key determined by +options+. If no content is provided, the contents of @response.body is used
+      # If no options are provided, the current +options+ for this action is used. Example:
+      #   cache_page "I'm the cached content", :controller => "lists", :action => "show"
+      def cache_page(content = nil, options = {})
+        return unless perform_caching && caching_allowed
+        self.class.cache_page(content || @response.body, url_for(options.merge({ :only_path => true })))
+      end
+      private
+        def caching_allowed
+          !@request.method.post? && (@request.parameters.reject {|k, v| ['id', 'action', 'controller'].include?(k)}).empty?
+        end
+    end
+    # Action caching is similar to page caching by the fact that the entire output of the response is cached, but unlike page caching,
+    # every request still goes through the Action Pack. The key benefit of this is that filters are run before the cache is served, which
+    # allows for authentication and other restrictions on whether someone are supposed to see the cache. Example:
+    #
+    #   class ListsController < ApplicationController
+    #     before_filter :authenticate, :except => :public
+    #     caches_page   :public
+    #     caches_action :show, :feed
+    #   end
+    #
+    # In this example, the public action doesn't require authentication, so it's possible to use the faster page caching method. But both the
+    # show and feed action are to be shielded behind the authenticate filter, so we need to implement those as action caches.
+    #
+    # Action caching internally uses the fragment caching and an around filter to do the job. The fragment cache is named according to both
+    # the current host and the path. So a page that is accessed at http://david.somewhere.com/lists/show/1 will result in a fragment named
+    # "david.somewhere.com/lists/show/1". This allows the cacher to differentiate between "david.somewhere.com/lists/" and
+    # "jamis.somewhere.com/lists/" -- which is a helpful way of assisting the subdomain-as-account-key pattern.
+    module Actions
+      def self.append_features(base) #:nodoc:
+        super
+        base.extend(ClassMethods)
+        base.send(:attr_accessor, :rendered_action_cache)
+      end
+      module ClassMethods #:nodoc:
+        def caches_action(*actions)
+          return unless perform_caching
+          around_filter(ActionCacheFilter.new(*actions))
+        end
+      end
+      def expire_action(options = {})
+        return unless perform_caching
+        if options[:action].is_a?(Array)
+          options[:action].dup.each do |action|
+            expire_fragment(url_for(options.merge({ :action => action })).split("://").last)
+          end
+        else
+          expire_fragment(url_for(options).split("://").last)
+        end
+      end
+      class ActionCacheFilter #:nodoc:
+        def initialize(*actions)
+          @actions = actions
+        end
+        def before(controller)
+          return unless @actions.include?(controller.action_name.intern)
+          if cache = controller.read_fragment(controller.url_for.split("://").last)
+            controller.rendered_action_cache = true
+            controller.send(:render_text, cache)
+            false
+          end
+        end
+        def after(controller)
+          return if !@actions.include?(controller.action_name.intern) || controller.rendered_action_cache
+          controller.write_fragment(controller.url_for.split("://").last, controller.response.body)
+        end
+      end
+    end
+    # Fragment caching is used for caching various blocks within templates without caching the entire action as a whole. This is useful when
+    # certain elements of an action change frequently or depend on complicated state while other parts rarely change or can be shared amongst multiple
+    # parties. The caching is doing using the cache helper available in the Action View. A template with caching might look something like:
+    #
+    #   <b>Hello <%= @name %></b>
+    #   <% cache(binding) do %>
+    #     All the topics in the system:
+    #     <%= render_collection_of_partials "topic", Topic.find_all %>
+    #   <% end %>
+    #
+    # This cache will bind to the name of action that called it. So you would be able to invalidate it using
+    # <tt>expire_fragment(:controller => "topics", :action => "list")</tt> -- if that was the controller/action used. This is not too helpful
+    # if you need to cache multiple fragments per action or if the action itself is cached using <tt>caches_action</tt>. So instead we should
+    # qualify the name of the action used with something like:
+    #
+    #   <% cache(binding, :action => "list", :action_suffix => "all_topics") do %>
+    #
+    # That would result in a name such as "/topics/list/all_topics", which wouldn't conflict with any action cache and neither with another
+    # fragment using a different suffix. Note that the URL doesn't have to really exist or be callable. We're just using the url_for system
+    # to generate unique cache names that we can refer to later for expirations. The expiration call for this example would be
+    # <tt>expire_fragment(:controller => "topics", :action => "list", :action_suffix => "all_topics")</tt>.
+    #
+    # == Fragment stores
+    #
+    # In order to use the fragment caching, you need to designate where the caches should be stored. This is done by assigning a fragment store
+    # of which there are four different kinds:
+    #
+    # * FileStore: Keeps the fragments on disk in the +cache_path+, which works well for all types of environments and share the fragments for
+    #   all the web server processes running off the same application directory.
+    # * MemoryStore: Keeps the fragments in memory, which is fine for WEBrick and for FCGI (if you don't care that each FCGI process holds its
+    #   own fragment store). It's not suitable for CGI as the process is thrown away at the end of each request. It can potentially also take
+    #   up a lot of memory since each process keeps all the caches in memory.
+    # * DRbStore: Keeps the fragments in the memory of a separate, shared DRb process. This works for all environments and only keeps one cache
+    #   around for all processes, but requires that you run and manage a separate DRb process.
+    # * MemCachedStore: Works like DRbStore, but uses Danga's MemCached instead.
+    #
+    # Configuration examples (MemoryStore is the default):
+    #
+    #   ActionController::Base.fragment_cache_store =
+    #     ActionController::Caching::Fragments::MemoryStore.new
+    #
+    #   ActionController::Base.fragment_cache_store =
+    #     ActionController::Caching::Fragments::FileStore.new("/path/to/cache/directory")
+    #
+    #   ActionController::Base.fragment_cache_store =
+    #     ActionController::Caching::Fragments::DRbStore.new("druby://localhost:9192")
+    #
+    #   ActionController::Base.fragment_cache_store =
+    #     ActionController::Caching::Fragments::FileStore.new("localhost")
+    module Fragments
+      def self.append_features(base) #:nodoc:
+        super
+        base.class_eval do
+          @@cache_store = MemoryStore.new
+          cattr_accessor :fragment_cache_store
+        end
+      end
+      # Called by CacheHelper#cache
+      def cache_erb_fragment(binding, name = {}, options = {})
+        unless perform_caching then yield; return end
+        buffer = eval("_erbout", binding)
+        if cache = read_fragment(name, options)
+          buffer.concat(cache)
+        else
+          pos = buffer.length
+          yield
+          write_fragment(name, buffer[pos..-1], options)
+        end
+      end
+      def write_fragment(name, content, options = {})
+        name = url_for(name).split("://").last if name.is_a?(Hash)
+        fragment_cache_store.write(name, content, options)
+        logger.info "Cached fragment: #{name}" unless logger.nil?
+        content
+      end
+      def read_fragment(name, options = {})
+        name = url_for(name).split("://").last if name.is_a?(Hash)
+        if cache = fragment_cache_store.read(name, options)
+          logger.info "Fragment hit: #{name}" unless logger.nil?
+          cache
+        else
+          false
+        end
+      end
+      def expire_fragment(name, options = {})
+        name = url_for(name).split("://").last if name.is_a?(Hash)
+        fragment_cache_store.delete(name, options)
+        logger.info "Expired fragment: #{name}" unless logger.nil?
+      end
+      class MemoryStore #:nodoc:
+        def initialize
+          @data, @mutex = { }, Mutex.new
+        end
+        def read(name, options = {}) #:nodoc:
+          begin
+            @mutex.synchronize { @data[name] }
+          rescue
+            nil
+          end
+        end
+        def write(name, value, options = {}) #:nodoc:
+          @mutex.synchronize { @data[name] = value }
+        end
+        def delete(name, options = {}) #:nodoc:
+          @mutex.synchronize { @data.delete(name) }
+        end
+      end
+      class DRbStore < MemoryStore #:nodoc:
+        def initialize(address = 'druby://localhost:9192')
+          @data = DRbObject.new(nil, address)
+        end
+      end
+      class MemCacheStore < MemoryStore #:nodoc:
+        def initialize(address = 'localhost')
+          @data = MemCache.new(address)
+        end
+      end
+      class FileStore #:nodoc:
+        def initialize(cache_path)
+          @cache_path = cache_path
+        end
+        def write(name, value, options = {}) #:nodoc:
+          begin
+            ensure_cache_path(File.dirname(real_file_path(name)))
+            File.open(real_file_path(name), "w+") { |f| f.write(value) }
+          rescue => e
+            Base.logger.info "Couldn't create cache directory: #{name} (#{e.message})" unless Base.logger.nil?
+          end
+        end
+        def read(name, options = {}) #:nodoc:
+          begin
+            IO.read(real_file_path(name))
+          rescue
+            nil
+          end
+        end
+        def delete(name, options) #:nodoc:
+          File.delete(real_file_path(name)) if File.exist?(real_file_path(name))
+        end
+        private
+          def real_file_path(name)
+            "#{@cache_path}/#{name}"
+          end
+          def ensure_cache_path(path)
+            FileUtils.makedirs(path) unless File.exists?(path)
+          end
+      end
+    end
+    # Sweepers are the terminators of the caching world and responsible for expiring caches when model objects change.
+    # They do this by being half-observers, half-filters and implementing callbacks for both roles. A Sweeper example:
+    #
+    #   class ListSweeper < ActiveRecord::Observer
+    #     observe List, Item
+    #
+    #     def after_save(record)
+    #       @list = record.is_a?(List) ? record : record.list
+    #     end
+    #
+    #     def filter(controller)
+    #       controller.expire_page(:controller => "lists", :action => %w( show public feed ), :id => @list.id)
+    #       controller.expire_action(:controller => "lists", :action => "all")
+    #       @list.shares.each { |share| controller.expire_page(:controller => "lists", :action => "show", :id => share.url_key) }
+    #     end
+    #   end
+    #
+    # The sweeper is assigned on the controllers that wish to have its job performed using the <tt>cache_sweeper</tt> class method:
+    #
+    #   class ListsController < ApplicationController
+    #     caches_action :index, :show, :public, :feed
+    #     cache_sweeper :list_sweeper, :only => [ :edit, :destroy, :share ]
+    #   end
+    #
+    # In the example above, four actions are cached and three actions are responsible of expiring those caches.
+    module Sweeping
+      def self.append_features(base) #:nodoc:
+        super
+        base.extend(ClassMethods)
+      end
+      module ClassMethods #:nodoc:
+        def cache_sweeper(*sweepers)
+          return unless perform_caching
+          configuration = sweepers.last.is_a?(Hash) ? sweepers.pop : {}
+          sweepers.each do |sweeper|
+            observer(sweeper)
+            after_filter(Object.const_get(Inflector.classify(sweeper)).instance, :only => configuration[:only])
+          end
+        end
+      end
+    end
+  end
+end