module AbstractController::Caching::Fragments

def combined_fragment_cache_key(key)

values, ending with the specified `key` value.
`ENV["RAILS_APP_VERSION"]` if set, followed by any controller-wide key prefix
with `:views`, followed by `ENV["RAILS_CACHE_ID"]` or
for use in reading, writing, or expiring a cached fragment. All keys begin
Given a key (as described in `expire_fragment`), returns a key array suitable

def combined_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
  cache_key = [:views, ENV["RAILS_CACHE_ID"] || ENV["RAILS_APP_VERSION"], head, tail]
  cache_key.flatten!(1)
  cache_key.compact!
  cache_key
end

def expire_fragment(key, options = nil)

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

on caches that can iterate over all keys (unlike memcached).
`./cache/filename/path.cache`. Note: Regexp expiration is only supported
or `$`) because the actual filename matched looks like
might remove all notes. Make sure you don't use anchors in the regex (`^`
* Regexp - Will remove any fragment that matches, so `%r{pages/\d*/notes}`
'pages', action: 'notes', id: 45}`
* Hash - Treated as an implicit call to `url_for`, like `{ controller:
`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 = combined_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_exist?(key, options = nil)

`expire_fragment` for acceptable formats).
Check if a cached fragment from the location signified by `key` exists (see

def fragment_exist?(key, options = nil)
  return unless cache_configured?
  key = combined_fragment_cache_key(key)
  instrument_fragment_cache :exist_fragment?, key do
    cache_store.exist?(key, options)
  end
end

def instrument_fragment_cache(name, key, &block) # :nodoc:

:nodoc:

def instrument_fragment_cache(name, key, &block) # :nodoc:
  ActiveSupport::Notifications.instrument("#{name}.#{instrument_name}", instrument_payload(key), &block)
end

def read_fragment(key, options = nil)

`expire_fragment` for acceptable formats).
Reads a cached fragment from the location signified by `key` (see

def read_fragment(key, options = nil)
  return unless cache_configured?
  key = combined_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)

acceptable formats).
Writes `content` to the location signified by `key` (see `expire_fragment` for

def write_fragment(key, content, options = nil)
  return content unless cache_configured?
  key = combined_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