module AbstractController::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)
  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.
with the specified +key+ value. The key is expanded using
followed by any controller-wide key prefix values, ending
cached fragment. All keys begin with views/,
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)
  head = self.class.fragment_cache_keys.map { |k| instance_exec(&k) }
  tail = key.is_a?(Hash) ? url_for(key).split("://").last : key
  ActiveSupport::Cache.expand_cache_key([*head, *tail], :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) # :nodoc:

:nodoc:

def instrument_fragment_cache(name, key) # :nodoc:
  payload = instrument_payload(key)
  ActiveSupport::Notifications.instrument("#{name}.#{instrument_name}", payload) { 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

Modules

Classes