module ActionController::ConditionalGet

def combine_etags(validator, options)
  [validator, *etaggers.map { |etagger| instance_exec(options, &etagger) }].compact
end

The method will also ensure an HTTP Date header for client compatibility.

expires_in 3.hours, public: true, "s-maxage": 3.hours, "no-transform": true

Any additional key-value pairs are concatenated onto the Cache-Control header in the response:
HTTP Cache-Control Extensions other values: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control

expires_in 3.hours, public: true, stale_while_revalidate: 60.seconds, stale_if_error: 5.minutes
expires_in 3.hours, public: true, stale_while_revalidate: 60.seconds

It helps to cache an asset and serve it while is being revalidated and/or returning with an error.
HTTP Cache-Control Extensions for Stale Content. See https://tools.ietf.org/html/rfc5861

See https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html for more possibilities.
This method will overwrite an existing Cache-Control header.

expires_in 3.hours, public: true, must_revalidate: true
expires_in 3.hours, public: true
expires_in 20.minutes

instruction, so that intermediate caches must not cache the response.
Sets an HTTP 1.1 Cache-Control header. Defaults to issuing a +private+

def expires_in(seconds, options = {})
  response.cache_control.delete(:no_store)
  response.cache_control.merge!(
    max_age: seconds,
    public: options.delete(:public),
    must_revalidate: options.delete(:must_revalidate),
    stale_while_revalidate: options.delete(:stale_while_revalidate),
    stale_if_error: options.delete(:stale_if_error),
  )
  options.delete(:private)
  response.cache_control[:extras] = options.map { |k, v| "#{k}=#{v}" }
  response.date = Time.now unless response.date?
end

Intermediate/browser caches may still store the asset.
resource will be marked as stale, so clients must always revalidate.
Sets an HTTP 1.1 Cache-Control header of no-cache. This means the

def expires_now
  response.cache_control.replace(no_cache: true)
end

before_action { fresh_when @article, template: 'widgets/show' }

style, you can indicate which digest to include in the ETag:
When rendering a different template than the default controller/action

This will set in the response Cache-Control = public, no-cache.

end
fresh_when(@article, public: true, cache_control: { no_cache: true })
@article = Article.find(params[:id])
def show

When overwriting Cache-Control header:

end
fresh_when(@article, public: true)
@article = Article.find(params[:id])
def show

When passing a record or a collection, you can still set the public header:

end
fresh_when(@articles)
@articles = Article.all
def index

most recently updated record) and the +etag+ by passing the object itself.
calling maximum(:updated_at) on the collection (the timestamp of the
collection of active records. In this case +last_modified+ will be set by
You can also pass an object that responds to +maximum+, such as a

end
fresh_when(@article)
@article = Article.find(params[:id])
def show

by calling +updated_at+ and +etag+ by passing the object itself.
You can also just pass a record. In this case +last_modified+ will be set

If-Modified-Since header and just a 304 Not Modified response if there's a match.
This will render the show template if the request isn't sending a matching ETag or

end
fresh_when(etag: @article, last_modified: @article.updated_at, public: true)
@article = Article.find(params[:id])
def show

=== Example:

to skip any attempt to check for a template digest.
doesn't render a template at all, you can pass template: false
different template, you can include its digest instead. If the action
controller/action is included in ETags. If the action renders a
* :template By default, the template digest for the current
See https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html for more possibilities.
* :cache_control When given will overwrite an existing Cache-Control header.
+true+ if you want your application to be cacheable by other devices (proxy caches).
* :public By default the Cache-Control header is private, set this to
304 Not Modified response if last_modified <= If-Modified-Since.
response. Subsequent requests that set If-Modified-Since may return a
* :last_modified Sets a "weak" last-update validator on the
for compatibility with some CDNs that don't support weak ETags.
doing Range requests within a large video or PDF file, for example, or
equality: the response must match byte for byte. This is necessary for
response if it matches the ETag exactly. A strong ETag implies exact
Requests that set If-None-Match header may return a 304 Not Modified
* :strong_etag Sets a "strong" ETag validator on the response.
must be byte-identical, like serving Range requests within a PDF file.
HTML pages in browser caches. They can't be used for responses that
equivalence, not byte-for-byte equality, so they're good for caching
response if it matches the ETag exactly. A weak ETag indicates semantic
Requests that set If-None-Match header may return a 304 Not Modified
* :weak_etag Sets a "weak" ETag validator on the response.
+:weak_etag+ option.
* :etag Sets a "weak" ETag validator on the response. See the

=== Parameters:

304 Not Modified response if the request is already fresh.
Sets the +etag+, +last_modified+, or both on the response and renders a

def fresh_when(object = nil, etag: nil, weak_etag: nil, strong_etag: nil, last_modified: nil, public: false, cache_control: {}, template: nil)
  response.cache_control.delete(:no_store)
  weak_etag ||= etag || object unless strong_etag
  last_modified ||= object.try(:updated_at) || object.try(:maximum, :updated_at)
  if strong_etag
    response.strong_etag = combine_etags strong_etag,
      last_modified: last_modified, public: public, template: template
  elsif weak_etag || template
    response.weak_etag = combine_etags weak_etag,
      last_modified: last_modified, public: public, template: template
  end
  response.last_modified = last_modified if last_modified
  response.cache_control[:public] = true if public
  response.cache_control.merge!(cache_control)
  head :not_modified if request.fresh?(response)
end

indicate that they can serve the cached response to all users.
user's web browser. To allow proxies to cache the response, set +true+ to
* +public+: By default, HTTP responses are private, cached only on the

and the browser and proxies should cache it indefinitely.
You can use this method when you have an HTTP response that never changes,

Cache or yield the block. The cache is supposed to never expire.

def http_cache_forever(public: false)
  expires_in 100.years, public: public
  yield if stale?(etag: request.fullpath,
                  last_modified: Time.new(2011, 1, 1).utc,
                  public: public)
end

resource may not be stored in any cache.
Sets an HTTP 1.1 Cache-Control header of no-store. This means the

def no_store
  response.cache_control.replace(no_store: true)
end

end
super if stale? @article, template: 'widgets/show'
def show

style, you can indicate which digest to include in the ETag:
When rendering a different template than the default controller/action

This will set in the response Cache-Control = public, no-cache.

end
end
end
# all the supported formats
respond_to do |format|
@statistics = @articles.really_expensive_call
if stale?(@article, public: true, cache_control: { no_cache: true })

@article = Article.find(params[:id])
def show

When overwriting Cache-Control header:

end
end
end
# all the supported formats
respond_to do |format|
@statistics = @article.really_expensive_call
if stale?(@article, public: true)

@article = Article.find(params[:id])
def show

When passing a record or a collection, you can still set the public header:

end
end
end
# all the supported formats
respond_to do |format|
@statistics = @articles.really_expensive_call
if stale?(@articles)

@articles = Article.all
def index

most recently updated record) and the +etag+ by passing the object itself.
calling maximum(:updated_at) on the collection (the timestamp of the
collection of active records. In this case +last_modified+ will be set by
You can also pass an object that responds to +maximum+, such as a

end
end
end
# all the supported formats
respond_to do |format|
@statistics = @article.really_expensive_call
if stale?(@article)

@article = Article.find(params[:id])
def show

by calling +updated_at+ and +etag+ by passing the object itself.
You can also just pass a record. In this case +last_modified+ will be set

end
end
end
# all the supported formats
respond_to do |format|
@statistics = @article.really_expensive_call
if stale?(etag: @article, last_modified: @article.updated_at)

@article = Article.find(params[:id])
def show

=== Example:

to skip any attempt to check for a template digest.
doesn't render a template at all, you can pass template: false
different template, you can include its digest instead. If the action
controller/action is included in ETags. If the action renders a
* :template By default, the template digest for the current
See https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html for more possibilities.
* :cache_control When given will overwrite an existing Cache-Control header.
+true+ if you want your application to be cacheable by other devices (proxy caches).
* :public By default the Cache-Control header is private, set this to
304 Not Modified response if last_modified <= If-Modified-Since.
response. Subsequent requests that set If-Modified-Since may return a
* :last_modified Sets a "weak" last-update validator on the
for compatibility with some CDNs that don't support weak ETags.
doing Range requests within a large video or PDF file, for example, or
equality: the response must match byte for byte. This is necessary for
response if it matches the ETag exactly. A strong ETag implies exact
Requests that set If-None-Match header may return a 304 Not Modified
* :strong_etag Sets a "strong" ETag validator on the response.
must be byte-identical, like serving Range requests within a PDF file.
HTML pages in browser caches. They can't be used for responses that
equivalence, not byte-for-byte equality, so they're good for caching
response if it matches the ETag exactly. A weak ETag indicates semantic
Requests that set If-None-Match header may return a 304 Not Modified
* :weak_etag Sets a "weak" ETag validator on the response.
+:weak_etag+ option.
* :etag Sets a "weak" ETag validator on the response. See the

=== Parameters:

it's fresh and we don't need to generate anything and a reply of 304 Not Modified is sent.
request is considered stale and should be generated from scratch. Otherwise,
the client request. If the request doesn't match the options provided, the
Sets the +etag+ and/or +last_modified+ on the response and checks it against

def stale?(object = nil, **freshness_kwargs)
  fresh_when(object, **freshness_kwargs)
  !request.fresh?(response)
end