actionpack-action_caching 1.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,17 @@
+language: ruby
+before_install:
+  - gem install bundler
+rvm:
+  - 1.9.3
+notifications:
+  email: false
+  irc:
+    on_success: change
+    on_failure: always
+    channels:
+      - "irc.freenode.org#rails-contrib"
+  campfire:
+    on_success: change
+    on_failure: always
+    rooms:
+      - secure: "WikBuknvGGTx/fNGc4qE+8WK+Glt+H+yZKhHXmavRV2zrN3hC0pTPwuGZhNs\nvkc6N9WKud7un2DtWu1v77BgFhIYjfJTRkmoZ8hoNsoHpe93W/a3s8LU30/l\nzDCKoTrqlHT5hJTmEKpNVqkhfFBPiXRFMgFWALUHiA8Q4Z9BUIc="

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rails', '~> 4.0.0.beta1'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 David Heinemeier Hansson
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,115 @@
+actionpack-action_caching
+=========================
+
+Action caching for Action Pack (removed from core in Rails 4.0)
+
+Installation
+------------
+
+Add this line to your application's Gemfile:
+
+    gem 'actionpack-action_caching'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install actionpack-action_caching
+
+Usage
+-----
+
+Action caching is similar to page caching by the fact that the entire
+output of the response is cached, but unlike page caching, every
+request still goes through Action Pack. The key benefit of this is
+that filters run before the cache is served, which allows for
+authentication and other restrictions on whether someone is allowed
+to execute such action.
+
+    class ListsController < ApplicationController
+      before_filter :authenticate, except: :public
+
+      caches_page   :public
+      caches_action :index, :show
+    end
+
+In this example, the `public` action doesn't require authentication
+so it's possible to use the faster page caching. On the other hand
+`index` and `show` require authentication. They can still be cached,
+but we need action caching for them.
+
+Action caching uses fragment caching internally and an around
+filter to do the job. The fragment cache is named according to
+the host and path of the request. A page that is accessed at
+`http://david.example.com/lists/show/1` will result in a fragment named
+`david.example.com/lists/show/1`. This allows the cacher to
+differentiate between `david.example.com/lists/` and
+`jamis.example.com/lists/` -- which is a helpful way of assisting
+the subdomain-as-account-key pattern.
+
+Different representations of the same resource, e.g.
+`http://david.example.com/lists` and
+`http://david.example.com/lists.xml`
+are treated like separate requests and so are cached separately.
+Keep in mind when expiring an action cache that
+`action: 'lists'` is not the same as
+`action: 'list', format: :xml`.
+
+You can modify the default action cache path by passing a
+`:cache_path` option. This will be passed directly to
+`ActionCachePath.new`. This is handy for actions with
+multiple possible routes that should be cached differently. If a
+block is given, it is called with the current controller instance.
+
+And you can also use `:if` (or `:unless`) to pass a
+proc that specifies when the action should be cached.
+
+As of Rails 3.0, you can also pass `:expires_in` with a time
+interval (in seconds) to schedule expiration of the cached item.
+
+The following example depicts some of the points made above:
+
+    class ListsController < ApplicationController
+      before_filter :authenticate, except: :public
+
+      caches_page :public
+
+      caches_action :index, if: Proc.new do
+        !request.format.json?  # cache if is not a JSON request
+      end
+
+      caches_action :show, cache_path: { project: 1 },
+        expires_in: 1.hour
+
+      caches_action :feed, cache_path: Proc.new do
+        if params[:user_id]
+          user_list_url(params[:user_id, params[:id])
+        else
+          list_url(params[:id])
+        end
+      end
+    end
+
+If you pass `layout: false`, it will only cache your action
+content. That's useful when your layout has dynamic information.
+
+Warning: If the format of the request is determined by the Accept HTTP
+header the Content-Type of the cached response could be wrong because
+no information about the MIME type is stored in the cache key. So, if
+you first ask for MIME type M in the Accept header, a cache entry is
+created, and then perform a second request to the same resource asking
+for a different MIME type, you'd get the content cached for M.
+
+The `:format` parameter is taken into account though. The safest
+way to cache by MIME type is to pass the format in the route.
+
+Contributing
+------------
+
+1. Fork it.
+2. Create your feature branch (`git checkout -b my-new-feature`).
+3. Commit your changes (`git commit -am 'Add some feature'`).
+4. Push to the branch (`git push origin my-new-feature`).
+5. Create a new Pull Request.

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs = ['test']
+  t.pattern = 'test/**/*_test.rb'
+  t.ruby_opts = ['-w']
+end
+
+task default: :test

data/actionpack-action_caching.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.name          = 'actionpack-action_caching'
+  gem.version       = '1.0.0'
+  gem.author        = 'David Heinemeier Hansson'
+  gem.email         = 'david@loudthinking.com'
+  gem.description   = 'Action caching for Action Pack (removed from core in Rails 4.0)'
+  gem.summary       = 'Action caching for Action Pack (removed from core in Rails 4.0)'
+  gem.homepage      = 'https://github.com/rails/actionpack-action_caching'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'actionpack', '>= 4.0.0.beta', '< 5.0'
+
+  gem.add_development_dependency 'mocha'
+  gem.add_development_dependency 'activerecord', '>= 4.0.0.beta', '< 5.0'
+end

data/lib/action_controller/action_caching.rb

@@ -0,0 +1,9 @@
+module ActionController
+  module Caching
+    eager_autoload do
+      autoload :Actions
+    end
+
+    include Actions
+  end
+end

data/lib/action_controller/caching/actions.rb

@@ -0,0 +1,193 @@
+require 'set'
+
+module ActionController
+  module Caching
+    # Action caching is similar to page caching by the fact that the entire
+    # output of the response is cached, but unlike page caching, every
+    # request still goes through Action Pack. The key benefit of this is
+    # that filters run before the cache is served, which allows for
+    # authentication and other restrictions on whether someone is allowed
+    # to execute such action.
+    #
+    #   class ListsController < ApplicationController
+    #     before_filter :authenticate, except: :public
+    #
+    #     caches_page   :public
+    #     caches_action :index, :show
+    #   end
+    #
+    # In this example, the +public+ action doesn't require authentication
+    # so it's possible to use the faster page caching. On the other hand
+    # +index+ and +show+ require authentication. They can still be cached,
+    # but we need action caching for them.
+    #
+    # Action caching uses fragment caching internally and an around
+    # filter to do the job. The fragment cache is named according to
+    # the host and path of the request. A page that is accessed at
+    # <tt>http://david.example.com/lists/show/1</tt> will result in a fragment named
+    # <tt>david.example.com/lists/show/1</tt>. This allows the cacher to
+    # differentiate between <tt>david.example.com/lists/</tt> and
+    # <tt>jamis.example.com/lists/</tt> -- which is a helpful way of assisting
+    # the subdomain-as-account-key pattern.
+    #
+    # Different representations of the same resource, e.g.
+    # <tt>http://david.example.com/lists</tt> and
+    # <tt>http://david.example.com/lists.xml</tt>
+    # are treated like separate requests and so are cached separately.
+    # Keep in mind when expiring an action cache that
+    # <tt>action: 'lists'</tt> is not the same as
+    # <tt>action: 'list', format: :xml</tt>.
+    #
+    # You can modify the default action cache path by passing a
+    # <tt>:cache_path</tt> option. This will be passed directly to
+    # <tt>ActionCachePath.new</tt>. This is handy for actions with
+    # multiple possible routes that should be cached differently. If a
+    # block is given, it is called with the current controller instance.
+    #
+    # And you can also use <tt>:if</tt> (or <tt>:unless</tt>) to pass a
+    # proc that specifies when the action should be cached.
+    #
+    # As of Rails 3.0, you can also pass <tt>:expires_in</tt> with a time
+    # interval (in seconds) to schedule expiration of the cached item.
+    #
+    # The following example depicts some of the points made above:
+    #
+    #   class ListsController < ApplicationController
+    #     before_filter :authenticate, except: :public
+    #
+    #     caches_page :public
+    #
+    #     caches_action :index, if: Proc.new do
+    #       !request.format.json?  # cache if is not a JSON request
+    #     end
+    #
+    #     caches_action :show, cache_path: { project: 1 },
+    #       expires_in: 1.hour
+    #
+    #     caches_action :feed, cache_path: Proc.new do
+    #       if params[:user_id]
+    #         user_list_url(params[:user_id, params[:id])
+    #       else
+    #         list_url(params[:id])
+    #       end
+    #     end
+    #   end
+    #
+    # If you pass <tt>layout: false</tt>, it will only cache your action
+    # content. That's useful when your layout has dynamic information.
+    #
+    # Warning: If the format of the request is determined by the Accept HTTP
+    # header the Content-Type of the cached response could be wrong because
+    # no information about the MIME type is stored in the cache key. So, if
+    # you first ask for MIME type M in the Accept header, a cache entry is
+    # created, and then perform a second request to the same resource asking
+    # for a different MIME type, you'd get the content cached for M.
+    #
+    # The <tt>:format</tt> parameter is taken into account though. The safest
+    # way to cache by MIME type is to pass the format in the route.
+    module Actions
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Declares that +actions+ should be cached.
+        # See ActionController::Caching::Actions for details.
+        def caches_action(*actions)
+          return unless cache_configured?
+          options = actions.extract_options!
+          options[:layout] = true unless options.key?(:layout)
+          filter_options = options.extract!(:if, :unless).merge(only: actions)
+          cache_options  = options.extract!(:layout, :cache_path).merge(store_options: options)
+
+          around_filter ActionCacheFilter.new(cache_options), filter_options
+        end
+      end
+
+      def _save_fragment(name, options)
+        content = ''
+        response_body.each do |parts|
+          content << parts
+        end
+
+        if caching_allowed?
+          write_fragment(name, content, options)
+        else
+          content
+        end
+      end
+
+      def caching_allowed?
+        (request.get? || request.head?) && response.status == 200
+      end
+
+    protected
+      def expire_action(options = {})
+        return unless cache_configured?
+
+        if options.is_a?(Hash) && options[:action].is_a?(Array)
+          options[:action].each { |action| expire_action(options.merge(action: action)) }
+        else
+          expire_fragment(ActionCachePath.new(self, options, false).path)
+        end
+      end
+
+      class ActionCacheFilter # :nodoc:
+        def initialize(options, &block)
+          @cache_path, @store_options, @cache_layout =
+            options.values_at(:cache_path, :store_options, :layout)
+        end
+
+        def around(controller)
+          cache_layout = @cache_layout.respond_to?(:call) ? @cache_layout.call(controller) : @cache_layout
+
+          path_options = if @cache_path.respond_to?(:call)
+            controller.instance_exec(controller, &@cache_path)
+          else
+            @cache_path
+          end
+
+          cache_path = ActionCachePath.new(controller, path_options || {})
+
+          body = controller.read_fragment(cache_path.path, @store_options)
+
+          unless body
+            controller.action_has_layout = false unless cache_layout
+            yield
+            controller.action_has_layout = true
+            body = controller._save_fragment(cache_path.path, @store_options)
+          end
+
+          body = controller.render_to_string(text: body, layout: true) unless cache_layout
+
+          controller.response_body = body
+          controller.content_type = Mime[cache_path.extension || :html]
+        end
+      end
+
+      class ActionCachePath
+        attr_reader :path, :extension
+
+        # If +infer_extension+ is +true+, the cache path extension is looked up from the request's
+        # path and format. This is desirable when reading and writing the cache, but not when
+        # expiring the cache - +expire_action+ should expire the same files regardless of the
+        # request format.
+        def initialize(controller, options = {}, infer_extension = true)
+          if infer_extension
+            @extension = controller.params[:format]
+            options.reverse_merge!(format: @extension) if options.is_a?(Hash)
+          end
+
+          path = controller.url_for(options).split('://', 2).last
+          @path = normalize!(path)
+        end
+
+      private
+        def normalize!(path)
+          ext = URI.parser.escape(extension) if extension
+          path << 'index' if path[-1] == ?/
+          path << ".#{ext}" if extension and !path.split('?', 2).first.ends_with?(".#{ext}")
+          URI.parser.unescape(path)
+        end
+      end
+    end
+  end
+end

data/lib/actionpack/action_caching.rb

@@ -0,0 +1 @@
+require 'action_controller/action_caching'

data/test/abstract_unit.rb

@@ -0,0 +1,40 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'action_controller'
+require 'active_record'
+require 'action_controller/action_caching'
+
+FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), 'fixtures')
+
+SharedTestRoutes = ActionDispatch::Routing::RouteSet.new
+
+module ActionController
+  class Base
+    include SharedTestRoutes.url_helpers
+
+    self.view_paths = FIXTURE_LOAD_PATH
+  end
+
+  class TestCase
+    def setup
+      @routes = SharedTestRoutes
+
+      @routes.draw do
+        get ':controller(/:action)'
+      end
+    end
+  end
+end
+
+module RackTestUtils
+  def body_to_string(body)
+    if body.respond_to?(:each)
+      str = ''
+      body.each {|s| str << s }
+      str
+    else
+      body
+    end
+  end
+  extend self
+end

data/test/caching_test.rb

@@ -0,0 +1,510 @@
+require 'abstract_unit'
+
+CACHE_DIR = 'test_cache'
+# Don't change '/../temp/' cavalierly or you might hose something you don't want hosed
+FILE_STORE_PATH = File.join(File.dirname(__FILE__), '/../temp/', CACHE_DIR)
+
+class CachingController < ActionController::Base
+  abstract!
+
+  self.cache_store = :file_store, FILE_STORE_PATH
+end
+
+class ActionCachingTestController < CachingController
+  rescue_from(Exception) { head 500 }
+  rescue_from(ActionController::UnknownFormat) { head :not_acceptable }
+  if defined? ActiveRecord
+    rescue_from(ActiveRecord::RecordNotFound) { head :not_found }
+  end
+
+  # Eliminate uninitialized ivar warning
+  before_filter { @title = nil }
+
+  caches_action :index, :redirected, :forbidden, if: Proc.new { |c| c.request.format && !c.request.format.json? }, expires_in: 1.hour
+  caches_action :show, cache_path: 'http://test.host/custom/show'
+  caches_action :edit, cache_path: Proc.new { |c| c.params[:id] ? "http://test.host/#{c.params[:id]};edit" : 'http://test.host/edit' }
+  caches_action :with_layout
+  caches_action :with_format_and_http_param, cache_path: Proc.new { |c| { key: 'value' } }
+  caches_action :layout_false, layout: false
+  caches_action :with_layout_proc_param, layout: Proc.new { |c| c.params[:layout] }
+  caches_action :record_not_found, :four_oh_four, :simple_runtime_error
+  caches_action :streaming
+  caches_action :invalid
+
+  layout 'talk_from_action'
+
+  def index
+    @cache_this = MockTime.now.to_f.to_s
+    render text: @cache_this
+  end
+
+  def redirected
+    redirect_to action: 'index'
+  end
+
+  def forbidden
+    render text: 'Forbidden'
+    response.status = '403 Forbidden'
+  end
+
+  def with_layout
+    @cache_this = MockTime.now.to_f.to_s
+    @title = nil
+    render text: @cache_this, layout: true
+  end
+
+  def with_format_and_http_param
+    @cache_this = MockTime.now.to_f.to_s
+    render text: @cache_this
+  end
+
+  def record_not_found
+    raise ActiveRecord::RecordNotFound, 'oops!'
+  end
+
+  def four_oh_four
+    render text: "404'd!", status: 404
+  end
+
+  def simple_runtime_error
+    raise 'oops!'
+  end
+
+  alias_method :show, :index
+  alias_method :edit, :index
+  alias_method :destroy, :index
+  alias_method :layout_false, :with_layout
+  alias_method :with_layout_proc_param, :with_layout
+
+  def expire
+    expire_action controller: 'action_caching_test', action: 'index'
+    render nothing: true
+  end
+
+  def expire_xml
+    expire_action controller: 'action_caching_test', action: 'index', format: 'xml'
+    render nothing: true
+  end
+
+  def expire_with_url_string
+    expire_action url_for(controller: 'action_caching_test', action: 'index')
+    render nothing: true
+  end
+
+  def streaming
+    render text: 'streaming', stream: true
+  end
+
+  def invalid
+    @cache_this = MockTime.now.to_f.to_s
+
+    respond_to do |format|
+      format.json{ render json: @cache_this }
+    end
+  end
+end
+
+class MockTime < Time
+  # Let Time spicy to assure that Time.now != Time.now
+  def to_f
+    super+rand
+  end
+end
+
+class ActionCachingMockController
+  attr_accessor :mock_url_for
+  attr_accessor :mock_path
+
+  def initialize
+    yield self if block_given?
+  end
+
+  def url_for(*args)
+    @mock_url_for
+  end
+
+  def params
+    request.parameters
+  end
+
+  def request
+    Object.new.instance_eval(<<-EVAL)
+      def path; '#{@mock_path}' end
+      def format; 'all' end
+      def parameters; { format: nil }; end
+      self
+    EVAL
+  end
+end
+
+class ActionCacheTest < ActionController::TestCase
+  tests ActionCachingTestController
+
+  def setup
+    super
+    @request.host = 'hostname.com'
+    FileUtils.mkdir_p(FILE_STORE_PATH)
+    @path_class = ActionController::Caching::Actions::ActionCachePath
+    @mock_controller = ActionCachingMockController.new
+  end
+
+  def teardown
+    super
+    FileUtils.rm_rf(File.dirname(FILE_STORE_PATH))
+  end
+
+  def test_simple_action_cache_with_http_head
+    head :index
+    assert_response :success
+    cached_time = content_to_cache
+    assert_equal cached_time, @response.body
+    assert fragment_exist?('hostname.com/action_caching_test')
+
+    head :index
+    assert_response :success
+    assert_equal cached_time, @response.body
+  end
+
+  def test_simple_action_cache
+    get :index
+    assert_response :success
+    cached_time = content_to_cache
+    assert_equal cached_time, @response.body
+    assert fragment_exist?('hostname.com/action_caching_test')
+
+    get :index
+    assert_response :success
+    assert_equal cached_time, @response.body
+  end
+
+  def test_simple_action_not_cached
+    get :destroy
+    assert_response :success
+    cached_time = content_to_cache
+    assert_equal cached_time, @response.body
+    assert !fragment_exist?('hostname.com/action_caching_test/destroy')
+
+    get :destroy
+    assert_response :success
+    assert_not_equal cached_time, @response.body
+  end
+
+  include RackTestUtils
+
+  def test_action_cache_with_layout
+    get :with_layout
+    assert_response :success
+    cached_time = content_to_cache
+    assert_not_equal cached_time, @response.body
+    assert fragment_exist?('hostname.com/action_caching_test/with_layout')
+
+    get :with_layout
+    assert_response :success
+    assert_not_equal cached_time, @response.body
+    body = body_to_string(read_fragment('hostname.com/action_caching_test/with_layout'))
+    assert_equal @response.body, body
+  end
+
+  def test_action_cache_with_layout_and_layout_cache_false
+    get :layout_false
+    assert_response :success
+    cached_time = content_to_cache
+    assert_not_equal cached_time, @response.body
+    assert fragment_exist?('hostname.com/action_caching_test/layout_false')
+
+    get :layout_false
+    assert_response :success
+    assert_not_equal cached_time, @response.body
+    body = body_to_string(read_fragment('hostname.com/action_caching_test/layout_false'))
+    assert_equal cached_time, body
+  end
+
+  def test_action_cache_with_layout_and_layout_cache_false_via_proc
+    get :with_layout_proc_param, layout: false
+    assert_response :success
+    cached_time = content_to_cache
+    assert_not_equal cached_time, @response.body
+    assert fragment_exist?('hostname.com/action_caching_test/with_layout_proc_param')
+
+    get :with_layout_proc_param, layout: false
+    assert_response :success
+    assert_not_equal cached_time, @response.body
+    body = body_to_string(read_fragment('hostname.com/action_caching_test/with_layout_proc_param'))
+    assert_equal cached_time, body
+  end
+
+  def test_action_cache_with_layout_and_layout_cache_true_via_proc
+    get :with_layout_proc_param, layout: true
+    assert_response :success
+    cached_time = content_to_cache
+    assert_not_equal cached_time, @response.body
+    assert fragment_exist?('hostname.com/action_caching_test/with_layout_proc_param')
+
+    get :with_layout_proc_param, layout: true
+    assert_response :success
+    assert_not_equal cached_time, @response.body
+    body = body_to_string(read_fragment('hostname.com/action_caching_test/with_layout_proc_param'))
+    assert_equal @response.body, body
+  end
+
+  def test_action_cache_conditional_options
+    @request.env['HTTP_ACCEPT'] = 'application/json'
+    get :index
+    assert_response :success
+    assert !fragment_exist?('hostname.com/action_caching_test')
+  end
+
+  def test_action_cache_with_format_and_http_param
+    get :with_format_and_http_param, format: 'json'
+    assert_response :success
+    assert !fragment_exist?('hostname.com/action_caching_test/with_format_and_http_param.json?key=value.json')
+    assert fragment_exist?('hostname.com/action_caching_test/with_format_and_http_param.json?key=value')
+  end
+
+  def test_action_cache_with_store_options
+    MockTime.expects(:now).returns(12345).once
+    @controller.expects(:read_fragment).with('hostname.com/action_caching_test', expires_in: 1.hour).once
+    @controller.expects(:write_fragment).with('hostname.com/action_caching_test', '12345.0', expires_in: 1.hour).once
+    get :index
+    assert_response :success
+  end
+
+  def test_action_cache_with_custom_cache_path
+    get :show
+    assert_response :success
+    cached_time = content_to_cache
+    assert_equal cached_time, @response.body
+    assert fragment_exist?('test.host/custom/show')
+
+    get :show
+    assert_response :success
+    assert_equal cached_time, @response.body
+  end
+
+  def test_action_cache_with_custom_cache_path_in_block
+    get :edit
+    assert_response :success
+    assert fragment_exist?('test.host/edit')
+
+    get :edit, id: 1
+    assert_response :success
+    assert fragment_exist?('test.host/1;edit')
+  end
+
+  def test_cache_expiration
+    get :index
+    assert_response :success
+    cached_time = content_to_cache
+
+    get :index
+    assert_response :success
+    assert_equal cached_time, @response.body
+
+    get :expire
+    assert_response :success
+
+    get :index
+    assert_response :success
+    new_cached_time = content_to_cache
+    assert_not_equal cached_time, @response.body
+
+    get :index
+    assert_response :success
+    assert_equal new_cached_time, @response.body
+  end
+
+  def test_cache_expiration_isnt_affected_by_request_format
+    get :index
+    cached_time = content_to_cache
+
+    @request.request_uri = "/action_caching_test/expire.xml"
+    get :expire, format: :xml
+    assert_response :success
+
+    get :index
+    assert_response :success
+    assert_not_equal cached_time, @response.body
+  end
+
+  def test_cache_expiration_with_url_string
+    get :index
+    cached_time = content_to_cache
+
+    @request.request_uri = "/action_caching_test/expire_with_url_string"
+    get :expire_with_url_string
+    assert_response :success
+
+    get :index
+    assert_response :success
+    assert_not_equal cached_time, @response.body
+  end
+
+  def test_cache_is_scoped_by_subdomain
+    @request.host = 'jamis.hostname.com'
+    get :index
+    assert_response :success
+    jamis_cache = content_to_cache
+
+    @request.host = 'david.hostname.com'
+    get :index
+    assert_response :success
+    david_cache = content_to_cache
+    assert_not_equal jamis_cache, @response.body
+
+    @request.host = 'jamis.hostname.com'
+    get :index
+    assert_response :success
+    assert_equal jamis_cache, @response.body
+
+    @request.host = 'david.hostname.com'
+    get :index
+    assert_response :success
+    assert_equal david_cache, @response.body
+  end
+
+  def test_redirect_is_not_cached
+    get :redirected
+    assert_response :redirect
+    get :redirected
+    assert_response :redirect
+  end
+
+  def test_forbidden_is_not_cached
+    get :forbidden
+    assert_response :forbidden
+    get :forbidden
+    assert_response :forbidden
+  end
+
+  def test_xml_version_of_resource_is_treated_as_different_cache
+    with_routing do |set|
+      set.draw do
+        get ':controller(/:action(.:format))'
+      end
+
+      get :index, format: 'xml'
+      assert_response :success
+      cached_time = content_to_cache
+      assert_equal cached_time, @response.body
+      assert fragment_exist?('hostname.com/action_caching_test/index.xml')
+
+      get :index, format: 'xml'
+      assert_response :success
+      assert_equal cached_time, @response.body
+      assert_equal 'application/xml', @response.content_type
+
+      get :expire_xml
+      assert_response :success
+
+      get :index, format: 'xml'
+      assert_response :success
+      assert_not_equal cached_time, @response.body
+    end
+  end
+
+  def test_correct_content_type_is_returned_for_cache_hit
+    # run it twice to cache it the first time
+    get :index, id: 'content-type', format: 'xml'
+    get :index, id: 'content-type', format: 'xml'
+    assert_response :success
+    assert_equal 'application/xml', @response.content_type
+  end
+
+  def test_correct_content_type_is_returned_for_cache_hit_on_action_with_string_key
+    # run it twice to cache it the first time
+    get :show, format: 'xml'
+    get :show, format: 'xml'
+    assert_response :success
+    assert_equal 'application/xml', @response.content_type
+  end
+
+  def test_correct_content_type_is_returned_for_cache_hit_on_action_with_string_key_from_proc
+    # run it twice to cache it the first time
+    get :edit, id: 1, format: 'xml'
+    get :edit, id: 1, format: 'xml'
+    assert_response :success
+    assert_equal 'application/xml', @response.content_type
+  end
+
+  def test_empty_path_is_normalized
+    @mock_controller.mock_url_for = 'http://example.org/'
+    @mock_controller.mock_path    = '/'
+
+    assert_equal 'example.org/index', @path_class.new(@mock_controller, {}).path
+  end
+
+  def test_file_extensions
+    get :index, id: 'kitten.jpg'
+    get :index, id: 'kitten.jpg'
+
+    assert_response :success
+  end
+
+  if defined? ActiveRecord
+    def test_record_not_found_returns_404_for_multiple_requests
+      get :record_not_found
+      assert_response 404
+      get :record_not_found
+      assert_response 404
+    end
+  end
+
+  def test_four_oh_four_returns_404_for_multiple_requests
+    get :four_oh_four
+    assert_response 404
+    get :four_oh_four
+    assert_response 404
+  end
+
+  def test_four_oh_four_renders_content
+    get :four_oh_four
+    assert_equal "404'd!", @response.body
+  end
+
+  def test_simple_runtime_error_returns_500_for_multiple_requests
+    get :simple_runtime_error
+    assert_response 500
+    get :simple_runtime_error
+    assert_response 500
+  end
+
+  def test_action_caching_plus_streaming
+    get :streaming
+    assert_response :success
+    assert_match(/streaming/, @response.body)
+    assert fragment_exist?('hostname.com/action_caching_test/streaming')
+  end
+
+  def test_invalid_format_returns_not_acceptable
+    get :invalid, format: 'json'
+    assert_response :success
+    cached_time = content_to_cache
+    assert_equal cached_time, @response.body
+
+    assert fragment_exist?("hostname.com/action_caching_test/invalid.json")
+
+    get :invalid, format: 'json'
+    assert_response :success
+    assert_equal cached_time, @response.body
+
+    get :invalid, format: 'xml'
+    assert_response :not_acceptable
+
+    get :invalid, format: '\xC3\x83'
+    assert_response :not_acceptable
+  end
+
+  private
+
+    def content_to_cache
+      assigns(:cache_this)
+    end
+
+    def fragment_exist?(path)
+      @controller.fragment_exist?(path)
+    end
+
+    def read_fragment(path)
+      @controller.read_fragment(path)
+    end
+end

data/test/fixtures/layouts/talk_from_action.erb

@@ -0,0 +1,2 @@
+<title><%= @title || yield(:title) %></title>
+<%= yield -%>

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: actionpack-action_caching
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- David Heinemeier Hansson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.0.beta
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.0.beta
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.0.beta
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.0.beta
+    - - <
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Action caching for Action Pack (removed from core in Rails 4.0)
+email: david@loudthinking.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- actionpack-action_caching.gemspec
+- lib/action_controller/action_caching.rb
+- lib/action_controller/caching/actions.rb
+- lib/actionpack/action_caching.rb
+- test/abstract_unit.rb
+- test/caching_test.rb
+- test/fixtures/layouts/talk_from_action.erb
+homepage: https://github.com/rails/actionpack-action_caching
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Action caching for Action Pack (removed from core in Rails 4.0)
+test_files:
+- test/abstract_unit.rb
+- test/caching_test.rb
+- test/fixtures/layouts/talk_from_action.erb
+has_rdoc: