actionpack-action-caching-1.1.1/ 0000755 0001750 0001750 00000000000 12400151144 016675 5 ustar terceiro terceiro actionpack-action-caching-1.1.1/CHANGELOG.md 0000644 0001750 0001750 00000001147 12400151144 020511 0 ustar terceiro terceiro ## 1.1.1
* Fix load order problem with other gems
*Andrew White*
## 1.1.0
* Allow to use non-proc object in `cache_path` option. You can pass an object that
responds to a `call` method.
Example:
class CachePath
def call(controller)
controller.id
end
end
class TestController < ApplicationController
caches_action :index, :cache_path => CachePath.new
def index; end
end
*Piotr Niełacny*
## 1.0.0 (February 28, 2013)
* Extract Action Pack - Action Caching from Rails core.
*Francesco Rodriguez*
actionpack-action-caching-1.1.1/.travis.yml 0000644 0001750 0001750 00000001160 12400151144 021004 0 ustar terceiro terceiro language: ruby
before_install:
- gem install bundler
rvm:
- 1.9.3
- 2.0.0
gemfile:
- Gemfile
- gemfiles/Gemfile-edge
- gemfiles/Gemfile-4-0-stable
matrix:
allow_failures:
- gemfile: gemfiles/Gemfile-edge
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="
actionpack-action-caching-1.1.1/lib/ 0000755 0001750 0001750 00000000000 12400151144 017443 5 ustar terceiro terceiro actionpack-action-caching-1.1.1/lib/actionpack/ 0000755 0001750 0001750 00000000000 12400151144 021557 5 ustar terceiro terceiro actionpack-action-caching-1.1.1/lib/actionpack/action_caching.rb 0000644 0001750 0001750 00000000053 12400151144 025033 0 ustar terceiro terceiro require 'action_controller/action_caching'
actionpack-action-caching-1.1.1/lib/actionpack/action_caching/ 0000755 0001750 0001750 00000000000 12400151144 024510 5 ustar terceiro terceiro actionpack-action-caching-1.1.1/lib/actionpack/action_caching/railtie.rb 0000644 0001750 0001750 00000000451 12400151144 026466 0 ustar terceiro terceiro require 'rails/railtie'
module ActionPack
module ActionCaching
class Railtie < Rails::Railtie
initializer 'action_pack.action_caching' do
ActiveSupport.on_load(:action_controller) do
require 'action_controller/action_caching'
end
end
end
end
end
actionpack-action-caching-1.1.1/lib/action_controller/ 0000755 0001750 0001750 00000000000 12400151144 023163 5 ustar terceiro terceiro actionpack-action-caching-1.1.1/lib/action_controller/action_caching.rb 0000644 0001750 0001750 00000000366 12400151144 026446 0 ustar terceiro terceiro require 'action_controller/caching/actions'
module ActionController
module Caching
eager_autoload do
autoload :Actions
end
include Actions
end
end
ActionController::Base.send(:include, ActionController::Caching::Actions)
actionpack-action-caching-1.1.1/lib/action_controller/caching/ 0000755 0001750 0001750 00000000000 12400151144 024557 5 ustar terceiro terceiro actionpack-action-caching-1.1.1/lib/action_controller/caching/actions.rb 0000644 0001750 0001750 00000017573 12400151144 026561 0 ustar terceiro terceiro 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
# 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: 'lists', 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.
# If an object that responds to call is given, it'll be 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 CachePathCreator
# def initialize(name)
# @name = name
# end
#
# def call(controller)
# "cache-path-#{@name}"
# end
# end
#
#
# 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
#
# caches_action :posts, cache_path: CachePathCreator.new('posts')
# 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.
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.is_a?(Proc)
controller.instance_exec(controller, &@cache_path)
elsif @cache_path.respond_to?(:call)
@cache_path.call(controller)
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
actionpack-action-caching-1.1.1/LICENSE.txt 0000644 0001750 0001750 00000002071 12400151144 020520 0 ustar terceiro terceiro 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.
actionpack-action-caching-1.1.1/.gitignore 0000644 0001750 0001750 00000000232 12400151144 020662 0 ustar terceiro terceiro *.gem
*.rbc
.bundle
.config
.yardoc
Gemfile.lock
InstalledFiles
_yardoc
coverage
doc/
lib/bundler/man
pkg
rdoc
spec/reports
test/tmp
test/version_tmp
tmp
actionpack-action-caching-1.1.1/README.md 0000644 0001750 0001750 00000010400 12400151144 020147 0 ustar terceiro terceiro actionpack-action_caching
=========================
Action caching for Action Pack (removed from core in Rails 4.0).
**NOTE:** It will continue to be officially maintained until Rails 4.1.
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.
Code Status
-----------
* [](https://travis-ci.org/rails/actionpack-action_caching)
* [](https://gemnasium.com/rails/actionpack-action_caching)
actionpack-action-caching-1.1.1/test/ 0000755 0001750 0001750 00000000000 12400151144 017654 5 ustar terceiro terceiro actionpack-action-caching-1.1.1/test/fixtures/ 0000755 0001750 0001750 00000000000 12400151144 021525 5 ustar terceiro terceiro actionpack-action-caching-1.1.1/test/fixtures/layouts/ 0000755 0001750 0001750 00000000000 12400151144 023225 5 ustar terceiro terceiro actionpack-action-caching-1.1.1/test/fixtures/layouts/talk_from_action.erb 0000644 0001750 0001750 00000000074 12400151144 027233 0 ustar terceiro terceiro <%= @title || yield(:title) %>
<%= yield -%>
actionpack-action-caching-1.1.1/test/caching_test.rb 0000644 0001750 0001750 00000034372 12400151144 022645 0 ustar terceiro terceiro 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 CachePath
def call(controller)
['controller', controller.params[:id]].compact.join('-')
end
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 :custom_cache_path, cache_path: CachePath.new
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 :custom_cache_path, :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_action_cache_with_custom_cache_path_with_custom_object
get :custom_cache_path
assert_response :success
assert fragment_exist?('controller')
get :custom_cache_path, id: 1
assert_response :success
assert fragment_exist?('controller-1')
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
actionpack-action-caching-1.1.1/test/abstract_unit.rb 0000644 0001750 0001750 00000001342 12400151144 023043 0 ustar terceiro terceiro 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
actionpack-action-caching-1.1.1/Gemfile 0000644 0001750 0001750 00000000064 12400151144 020170 0 ustar terceiro terceiro source 'https://rubygems.org'
gemspec
gem 'rails'
actionpack-action-caching-1.1.1/actionpack-action_caching.gemspec 0000644 0001750 0001750 00000001613 12400151144 025306 0 ustar terceiro terceiro # -*- encoding: utf-8 -*-
Gem::Specification.new do |gem|
gem.name = 'actionpack-action_caching'
gem.version = '1.1.1'
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.license = 'MIT'
gem.add_dependency 'actionpack', '>= 4.0.0', '< 5.0'
gem.add_development_dependency 'mocha'
gem.add_development_dependency 'activerecord', '>= 4.0.0.beta', '< 5'
end
actionpack-action-caching-1.1.1/gemfiles/ 0000755 0001750 0001750 00000000000 12400151144 020470 5 ustar terceiro terceiro actionpack-action-caching-1.1.1/gemfiles/Gemfile-edge 0000644 0001750 0001750 00000000150 12400151144 022661 0 ustar terceiro terceiro source 'https://rubygems.org'
gemspec path: '..'
gem 'rails', github: 'rails/rails', branch: 'master'
actionpack-action-caching-1.1.1/gemfiles/Gemfile-4-0-stable 0000644 0001750 0001750 00000000154 12400151144 023531 0 ustar terceiro terceiro source 'https://rubygems.org'
gemspec path: '..'
gem 'rails', github: 'rails/rails', branch: '4-0-stable'
actionpack-action-caching-1.1.1/Rakefile 0000644 0001750 0001750 00000000311 12400151144 020335 0 ustar terceiro terceiro #!/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
actionpack-action-caching-1.1.1/metadata.yml 0000644 0001750 0001750 00000005563 12400151144 021211 0 ustar terceiro terceiro --- !ruby/object:Gem::Specification
name: actionpack-action_caching
version: !ruby/object:Gem::Version
version: 1.1.1
platform: ruby
authors:
- David Heinemeier Hansson
autorequire:
bindir: bin
cert_chain: []
date: 2014-01-02 00:00:00.000000000 Z
dependencies:
- !ruby/object:Gem::Dependency
name: actionpack
requirement: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: 4.0.0
- - "<"
- !ruby/object:Gem::Version
version: '5.0'
type: :runtime
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: 4.0.0
- - "<"
- !ruby/object:Gem::Version
version: '5.0'
- !ruby/object:Gem::Dependency
name: mocha
requirement: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: '0'
type: :development
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: '0'
- !ruby/object:Gem::Dependency
name: activerecord
requirement: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: 4.0.0.beta
- - "<"
- !ruby/object:Gem::Version
version: '5'
type: :development
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: 4.0.0.beta
- - "<"
- !ruby/object:Gem::Version
version: '5'
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"
- CHANGELOG.md
- Gemfile
- LICENSE.txt
- README.md
- Rakefile
- actionpack-action_caching.gemspec
- gemfiles/Gemfile-4-0-stable
- gemfiles/Gemfile-edge
- lib/action_controller/action_caching.rb
- lib/action_controller/caching/actions.rb
- lib/actionpack/action_caching.rb
- lib/actionpack/action_caching/railtie.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:
- MIT
metadata: {}
post_install_message:
rdoc_options: []
require_paths:
- lib
required_ruby_version: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: '0'
required_rubygems_version: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: '0'
requirements: []
rubyforge_project:
rubygems_version: 2.2.0
signing_key:
specification_version: 4
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