module ActionController::Caching::Fragments

def expire_fragment(key, options = nil)

method (or delete_matched, for Regexp keys.)
+options+ is passed through to the cache store's delete

memcached).
only supported on caches that can iterate over all keys (unlike
./cache/filename/path.cache. Note: Regexp expiration is
the actual filename matched looks like
don't use anchors in the regex (^ or $) because
%r{pages/\d*/notes} might remove all notes. Make sure you
* Regexp - Will remove any fragment that matches, so
{:controller => "pages", :action => "notes", :id => 45}
* Hash - Treated as an implicit call to +url_for+, like
pages/45/notes.
* String - This would normally take the form of a path, like

+key+ can take one of three forms:

Removes fragments from the cache. 
def expire_fragment(key, options = nil)
  return unless cache_configured?
  key = fragment_cache_key(key) unless key.is_a?(Regexp)
  message = nil
  instrument_fragment_cache :expire_fragment, key do
    if key.is_a?(Regexp)
      cache_store.delete_matched(key, options)
    else
      cache_store.delete(key, options)
    end
  end
end

def fragment_cache_key(key)

ActiveSupport::Cache.expand_cache_key for the expansion.
All keys are prefixed with views/ and uses
return value of url_for on that hash (without the protocol).
cached fragment. If the key is a hash, the generated key is the
a key suitable for use in reading, writing, or expiring a
Given a key (as described in expire_fragment), returns 
def fragment_cache_key(key)
  ActiveSupport::Cache.expand_cache_key(key.is_a?(Hash) ? url_for(key).split("://").last : key, :views)
end

def fragment_exist?(key, options = nil)

key exists (see expire_fragment for acceptable formats)
Check if a cached fragment from the location signified by 
def fragment_exist?(key, options = nil)
  return unless cache_configured?
  key = fragment_cache_key(key)
  instrument_fragment_cache :exist_fragment?, key do
    cache_store.exist?(key, options)
  end
end

def instrument_fragment_cache(name, key) 

def instrument_fragment_cache(name, key)
  ActiveSupport::Notifications.instrument("#{name}.action_controller", :key => key){ yield }
end

def read_fragment(key, options = nil)

(see expire_fragment for acceptable formats).
Reads a cached fragment from the location signified by key 
def read_fragment(key, options = nil)
  return unless cache_configured?
  key = fragment_cache_key(key)
  instrument_fragment_cache :read_fragment, key do
    result = cache_store.read(key, options)
    result.respond_to?(:html_safe) ? result.html_safe : result
  end
end

def write_fragment(key, content, options = nil)

key (see expire_fragment for acceptable formats).
Writes content to the location signified by 
def write_fragment(key, content, options = nil)
  return content unless cache_configured?
  key = fragment_cache_key(key)
  instrument_fragment_cache :write_fragment, key do
    content = content.to_str
    cache_store.write(key, content, options)
  end
  content
end