vendor/rails/actionpack/lib/action_controller/caching/fragments.rb

   1 module ActionController #:nodoc:
   2   module Caching
   3     # Fragment caching is used for caching various blocks within templates without caching the entire action as a whole. This is useful when
   4     # certain elements of an action change frequently or depend on complicated state while other parts rarely change or can be shared amongst multiple
   5     # parties. The caching is done using the cache helper available in the Action View. A template with caching might look something like:
   6     #
   7     #   <b>Hello <%= @name %></b>
   8     #   <% cache do %>
   9     #     All the topics in the system:
  10     #     <%= render :partial => "topic", :collection => Topic.find(:all) %>
  11     #   <% end %>
  12     #
  13     # This cache will bind to the name of the action that called it, so if this code was part of the view for the topics/list action, you would
  14     # be able to invalidate it using <tt>expire_fragment(:controller => "topics", :action => "list")</tt>.
  15     #
  16     # This default behavior is of limited use if you need to cache multiple fragments per action or if the action itself is cached using
  17     # <tt>caches_action</tt>, so we also have the option to qualify the name of the cached fragment with something like:
  18     #
  19     #   <% cache(:action => "list", :action_suffix => "all_topics") do %>
  20     #
  21     # That would result in a name such as "/topics/list/all_topics", avoiding conflicts with the action cache and with any fragments that use a
  22     # different suffix. Note that the URL doesn't have to really exist or be callable - the url_for system is just used to generate unique
  23     # cache names that we can refer to when we need to expire the cache.
  24     #
  25     # The expiration call for this example is:
  26     #
  27     #   expire_fragment(:controller => "topics", :action => "list", :action_suffix => "all_topics")
  28     module Fragments
  29       # Given a key (as described in <tt>expire_fragment</tt>), returns a key suitable for use in reading,
  30       # writing, or expiring a cached fragment. If the key is a hash, the generated key is the return
  31       # value of url_for on that hash (without the protocol). All keys are prefixed with "views/" and uses
  32       # ActiveSupport::Cache.expand_cache_key for the expansion.
  33       def fragment_cache_key(key)
  34         ActiveSupport::Cache.expand_cache_key(key.is_a?(Hash) ? url_for(key).split("://").last : key, :views)
  35       end
  36
  37       def fragment_for(buffer, name = {}, options = nil, &block) #:nodoc:
  38         if perform_caching
  39           if cache = read_fragment(name, options)
  40             buffer.concat(cache)
  41           else
  42             pos = buffer.length
  43             block.call
  44             write_fragment(name, buffer[pos..-1], options)
  45           end
  46         else
  47           block.call
  48         end
  49       end
  50
  51       # Writes <tt>content</tt> to the location signified by <tt>key</tt> (see <tt>expire_fragment</tt> for acceptable formats)
  52       def write_fragment(key, content, options = nil)
  53         return content unless cache_configured?
  54
  55         key = fragment_cache_key(key)
  56
  57         self.class.benchmark "Cached fragment miss: #{key}" do
  58           cache_store.write(key, content, options)
  59         end
  60
  61         content
  62       end
  63
  64       # Reads a cached fragment from the location signified by <tt>key</tt> (see <tt>expire_fragment</tt> for acceptable formats)
  65       def read_fragment(key, options = nil)
  66         return unless cache_configured?
  67
  68         key = fragment_cache_key(key)
  69
  70         self.class.benchmark "Cached fragment hit: #{key}" do
  71           cache_store.read(key, options)
  72         end
  73       end
  74
  75       # Check if a cached fragment from the location signified by <tt>key</tt> exists (see <tt>expire_fragment</tt> for acceptable formats)
  76       def fragment_exist?(key, options = nil)
  77         return unless cache_configured?
  78
  79         key = fragment_cache_key(key)
  80
  81         self.class.benchmark "Cached fragment exists?: #{key}" do
  82           cache_store.exist?(key, options)
  83         end
  84       end
  85
  86       # Removes fragments from the cache.
  87       #
  88       # +key+ can take one of three forms:
  89       # * String - This would normally take the form of a path, like
  90       #   <tt>"pages/45/notes"</tt>.
  91       # * Hash - Treated as an implicit call to +url_for+, like
  92       #   <tt>{:controller => "pages", :action => "notes", :id => 45}</tt>
  93       # * Regexp - Will remove any fragment that matches, so
  94       #   <tt>%r{pages/\d*/notes}</tt> might remove all notes. Make sure you
  95       #   don't use anchors in the regex (<tt>^</tt> or <tt>$</tt>) because
  96       #   the actual filename matched looks like
  97       #   <tt>./cache/filename/path.cache</tt>. Note: Regexp expiration is
  98       #   only supported on caches that can iterate over all keys (unlike
  99       #   memcached).
 100       #
 101       # +options+ is passed through to the cache store's <tt>delete</tt>
 102       # method (or <tt>delete_matched</tt>, for Regexp keys.)
 103       def expire_fragment(key, options = nil)
 104         return unless cache_configured?
 105
 106         key = key.is_a?(Regexp) ? key : fragment_cache_key(key)
 107
 108         if key.is_a?(Regexp)
 109           self.class.benchmark "Expired fragments matching: #{key.source}" do
 110             cache_store.delete_matched(key, options)
 111           end
 112         else
 113           self.class.benchmark "Expired fragment: #{key}" do
 114             cache_store.delete(key, options)
 115           end
 116         end
 117       end
 118     end
 119   end
 120 end