actionpack-page-caching-1.0.2/ 0000755 0001750 0001750 00000000000 12433636401 017422 5 ustar balasankarc balasankarc actionpack-page-caching-1.0.2/Gemfile 0000644 0001750 0001750 00000000064 12433636401 020715 0 ustar balasankarc balasankarc source 'https://rubygems.org'
gemspec
gem 'rails'
actionpack-page-caching-1.0.2/gemfiles/ 0000755 0001750 0001750 00000000000 12433636401 021215 5 ustar balasankarc balasankarc actionpack-page-caching-1.0.2/gemfiles/Gemfile-edge 0000644 0001750 0001750 00000000150 12433636401 023406 0 ustar balasankarc balasankarc source 'https://rubygems.org'
gemspec path: '..'
gem 'rails', github: 'rails/rails', branch: 'master'
actionpack-page-caching-1.0.2/gemfiles/Gemfile-4-0-stable 0000644 0001750 0001750 00000000154 12433636401 024256 0 ustar balasankarc balasankarc source 'https://rubygems.org'
gemspec path: '..'
gem 'rails', github: 'rails/rails', branch: '4-0-stable'
actionpack-page-caching-1.0.2/.gitignore 0000644 0001750 0001750 00000000232 12433636401 021407 0 ustar balasankarc balasankarc *.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-page-caching-1.0.2/Rakefile 0000644 0001750 0001750 00000000311 12433636401 021062 0 ustar balasankarc balasankarc #!/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-page-caching-1.0.2/LICENSE.txt 0000644 0001750 0001750 00000002071 12433636401 021245 0 ustar balasankarc balasankarc 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-page-caching-1.0.2/metadata.yml 0000644 0001750 0001750 00000004502 12433636401 021726 0 ustar balasankarc balasankarc --- !ruby/object:Gem::Specification
name: actionpack-page_caching
version: !ruby/object:Gem::Version
version: 1.0.2
platform: ruby
authors:
- David Heinemeier Hansson
autorequire:
bindir: bin
cert_chain: []
date: 2013-11-15 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'
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'
- !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'
description: Static page 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-page_caching.gemspec
- gemfiles/Gemfile-4-0-stable
- gemfiles/Gemfile-edge
- lib/action_controller/caching/pages.rb
- lib/action_controller/page_caching.rb
- lib/actionpack/page_caching.rb
- lib/actionpack/page_caching/railtie.rb
- test/abstract_unit.rb
- test/caching_test.rb
- test/log_subscriber_test.rb
homepage: https://github.com/rails/actionpack-page_caching
licenses: []
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.0.3
signing_key:
specification_version: 4
summary: Static page caching for Action Pack (removed from core in Rails 4.0)
test_files:
- test/abstract_unit.rb
- test/caching_test.rb
- test/log_subscriber_test.rb
actionpack-page-caching-1.0.2/lib/ 0000755 0001750 0001750 00000000000 12433636401 020170 5 ustar balasankarc balasankarc actionpack-page-caching-1.0.2/lib/actionpack/ 0000755 0001750 0001750 00000000000 12433636401 022304 5 ustar balasankarc balasankarc actionpack-page-caching-1.0.2/lib/actionpack/page_caching.rb 0000644 0001750 0001750 00000000052 12433636401 025216 0 ustar balasankarc balasankarc require 'actionpack/page_caching/railtie'
actionpack-page-caching-1.0.2/lib/actionpack/page_caching/ 0000755 0001750 0001750 00000000000 12433636401 024674 5 ustar balasankarc balasankarc actionpack-page-caching-1.0.2/lib/actionpack/page_caching/railtie.rb 0000644 0001750 0001750 00000000767 12433636401 026664 0 ustar balasankarc balasankarc require 'rails/railtie'
module ActionPack
module PageCaching
class Railtie < Rails::Railtie
initializer 'action_pack.page_caching' do
ActiveSupport.on_load(:action_controller) do
require 'action_controller/page_caching'
end
end
initializer 'action_pack.page_caching.set_config', before: 'action_controller.set_configs' do |app|
app.config.action_controller.page_cache_directory ||= app.config.paths['public'].first
end
end
end
end
actionpack-page-caching-1.0.2/lib/action_controller/ 0000755 0001750 0001750 00000000000 12433636401 023710 5 ustar balasankarc balasankarc actionpack-page-caching-1.0.2/lib/action_controller/page_caching.rb 0000644 0001750 0001750 00000000356 12433636401 026631 0 ustar balasankarc balasankarc require 'action_controller/caching/pages'
module ActionController
module Caching
eager_autoload do
autoload :Pages
end
include Pages
end
end
ActionController::Base.send(:include, ActionController::Caching::Pages)
actionpack-page-caching-1.0.2/lib/action_controller/caching/ 0000755 0001750 0001750 00000000000 12433636401 025304 5 ustar balasankarc balasankarc actionpack-page-caching-1.0.2/lib/action_controller/caching/pages.rb 0000644 0001750 0001750 00000017334 12433636401 026740 0 ustar balasankarc balasankarc require 'fileutils'
require 'active_support/core_ext/class/attribute_accessors'
module ActionController
module Caching
# Page caching is an approach to caching where the entire action output of is
# stored as a HTML file that the web server can serve without going through
# Action Pack. This is the fastest way to cache your content as opposed to going
# dynamically through the process of generating the content. Unfortunately, this
# incredible speed-up is only available to stateless pages where all visitors are
# treated the same. Content management systems -- including weblogs and wikis --
# have many pages that are a great fit for this approach, but account-based systems
# where people log in and manipulate their own data are often less likely candidates.
#
# Specifying which actions to cache is done through the +caches_page+ class method:
#
# class WeblogController < ActionController::Base
# caches_page :show, :new
# end
#
# This will generate cache files such as weblog/show/5.html and
# weblog/new.html, which match the URLs used that would normally trigger
# dynamic page generation. Page caching works by configuring a web server to first
# check for the existence of files on disk, and to serve them directly when found,
# without passing the request through to Action Pack. This is much faster than
# handling the full dynamic request in the usual way.
#
# Expiration of the cache is handled by deleting the cached file, which results
# in a lazy regeneration approach where the cache is not restored before another
# hit is made against it. The API for doing so mimics the options from +url_for+ and friends:
#
# class WeblogController < ActionController::Base
# def update
# List.update(params[:list][:id], params[:list])
# expire_page action: 'show', id: params[:list][:id]
# redirect_to action: 'show', id: params[:list][:id]
# end
# end
#
# Additionally, you can expire caches using Sweepers that act on changes in
# the model to determine when a cache is supposed to be expired.
module Pages
extend ActiveSupport::Concern
included do
# The cache directory should be the document root for the web server and is
# set using Base.page_cache_directory = "/document/root". For Rails,
# this directory has already been set to Rails.public_path (which is usually
# set to Rails.root + "/public"). Changing this setting can be useful
# to avoid naming conflicts with files in public/, but doing so will
# likely require configuring your web server to look in the new location for
# cached files.
class_attribute :page_cache_directory
self.page_cache_directory ||= ''
# The compression used for gzip. If +false+ (default), the page is not compressed.
# If can be a symbol showing the ZLib compression method, for example, :best_compression
# or :best_speed or an integer configuring the compression level.
class_attribute :page_cache_compression
self.page_cache_compression ||= false
end
module ClassMethods
# Expires the page that was cached with the +path+ as a key.
#
# expire_page '/lists/show'
def expire_page(path)
return unless perform_caching
path = page_cache_path(path)
instrument_page_cache :expire_page, path do
File.delete(path) if File.exist?(path)
File.delete(path + '.gz') if File.exist?(path + '.gz')
end
end
# Manually cache the +content+ in the key determined by +path+.
#
# cache_page "I'm the cached content", '/lists/show'
def cache_page(content, path, extension = nil, gzip = Zlib::BEST_COMPRESSION)
return unless perform_caching
path = page_cache_path(path, extension)
instrument_page_cache :write_page, path do
FileUtils.makedirs(File.dirname(path))
File.open(path, 'wb+') { |f| f.write(content) }
if gzip
Zlib::GzipWriter.open(path + '.gz', gzip) { |f| f.write(content) }
end
end
end
# Caches the +actions+ using the page-caching approach that'll store
# the cache in a path within the +page_cache_directory+ that
# matches the triggering url.
#
# You can also pass a :gzip option to override the class configuration one.
#
# # cache the index action
# caches_page :index
#
# # cache the index action except for JSON requests
# caches_page :index, if: Proc.new { !request.format.json? }
#
# # don't gzip images
# caches_page :image, gzip: false
def caches_page(*actions)
return unless perform_caching
options = actions.extract_options!
gzip_level = options.fetch(:gzip, page_cache_compression)
gzip_level = case gzip_level
when Symbol
Zlib.const_get(gzip_level.upcase)
when Fixnum
gzip_level
when false
nil
else
Zlib::BEST_COMPRESSION
end
after_filter({only: actions}.merge(options)) do |c|
c.cache_page(nil, nil, gzip_level)
end
end
private
def page_cache_file(path, extension)
name = (path.empty? || path == '/') ? '/index' : URI.parser.unescape(path.chomp('/'))
unless (name.split('/').last || name).include? '.'
name << (extension || self.default_static_extension)
end
return name
end
def page_cache_path(path, extension = nil)
page_cache_directory.to_s + page_cache_file(path, extension)
end
def instrument_page_cache(name, path)
ActiveSupport::Notifications.instrument("#{name}.action_controller", path: path){ yield }
end
end
# Expires the page that was cached with the +options+ as a key.
#
# expire_page controller: 'lists', action: 'show'
def expire_page(options = {})
return unless self.class.perform_caching
if options.is_a?(Hash)
if options[:action].is_a?(Array)
options[:action].each do |action|
self.class.expire_page(url_for(options.merge(only_path: true, action: action)))
end
else
self.class.expire_page(url_for(options.merge(only_path: true)))
end
else
self.class.expire_page(options)
end
end
# Manually cache the +content+ in the key determined by +options+. If no content is provided,
# the contents of response.body is used. If no options are provided, the url of the current
# request being handled is used.
#
# cache_page "I'm the cached content", controller: 'lists', action: 'show'
def cache_page(content = nil, options = nil, gzip = Zlib::BEST_COMPRESSION)
return unless self.class.perform_caching && caching_allowed?
path = case options
when Hash
url_for(options.merge(only_path: true, format: params[:format]))
when String
options
else
request.path
end
if (type = Mime::LOOKUP[self.content_type]) && (type_symbol = type.symbol).present?
extension = ".#{type_symbol}"
end
self.class.cache_page(content || response.body, path, extension, gzip)
end
def caching_allowed?
(request.get? || request.head?) && response.status == 200
end
end
end
end
actionpack-page-caching-1.0.2/.travis.yml 0000644 0001750 0001750 00000001160 12433636401 021531 0 ustar balasankarc balasankarc language: ruby
before_install:
- gem install bundler
rvm:
- 1.9.3
- 2.0.0
gemfile:
- Gemfile
- gemfiles/Gemfile-4-0-stable
- gemfiles/Gemfile-edge
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: "eRCx+FMvH50pmLu0GZTF7NN+2X+CesgodYUlHvCr5EXQ0ZO/YUmeW8vAh/N8\njSrLWYpk/4P/JA63JGWsvFor/zpkTnfwzX3LWgw04GV0V3T9jsn9CD2Coiu6\nFll5u4fUCUwpfbB4RlCkjvFdQmW+F9mmbRGMCDO5CmuPHOyyPH0="
actionpack-page-caching-1.0.2/actionpack-page_caching.gemspec 0000644 0001750 0001750 00000001453 12433636401 025474 0 ustar balasankarc balasankarc # -*- encoding: utf-8 -*-
Gem::Specification.new do |gem|
gem.name = 'actionpack-page_caching'
gem.version = '1.0.2'
gem.author = 'David Heinemeier Hansson'
gem.email = 'david@loudthinking.com'
gem.description = 'Static page caching for Action Pack (removed from core in Rails 4.0)'
gem.summary = 'Static page caching for Action Pack (removed from core in Rails 4.0)'
gem.homepage = 'https://github.com/rails/actionpack-page_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', '< 5'
gem.add_development_dependency 'mocha'
end
actionpack-page-caching-1.0.2/test/ 0000755 0001750 0001750 00000000000 12433636401 020401 5 ustar balasankarc balasankarc actionpack-page-caching-1.0.2/test/caching_test.rb 0000644 0001750 0001750 00000015450 12433636401 023366 0 ustar balasankarc balasankarc 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 CachingMetalController < ActionController::Metal
abstract!
include ActionController::Caching
self.page_cache_directory = FILE_STORE_PATH
self.cache_store = :file_store, FILE_STORE_PATH
end
class PageCachingMetalTestController < CachingMetalController
caches_page :ok
def ok
self.response_body = 'ok'
end
end
class PageCachingMetalTest < ActionController::TestCase
tests PageCachingMetalTestController
def setup
super
FileUtils.rm_rf(File.dirname(FILE_STORE_PATH))
FileUtils.mkdir_p(FILE_STORE_PATH)
end
def teardown
FileUtils.rm_rf(File.dirname(FILE_STORE_PATH))
end
def test_should_cache_get_with_ok_status
get :ok
assert_response :ok
assert File.exist?("#{FILE_STORE_PATH}/page_caching_metal_test/ok.html"), 'get with ok status should have been cached'
end
end
ActionController::Base.page_cache_directory = FILE_STORE_PATH
class CachingController < ActionController::Base
abstract!
self.cache_store = :file_store, FILE_STORE_PATH
end
class PageCachingTestController < CachingController
self.page_cache_compression = :best_compression
caches_page :ok, :no_content, if: Proc.new { |c| !c.request.format.json? }
caches_page :found, :not_found
caches_page :about_me
caches_page :default_gzip
caches_page :no_gzip, gzip: false
caches_page :gzip_level, gzip: :best_speed
def ok
head :ok
end
def no_content
head :no_content
end
def found
redirect_to action: 'ok'
end
def not_found
head :not_found
end
def custom_path
render text: 'Super soaker'
cache_page('Super soaker', '/index.html')
end
def default_gzip
render text: 'Text'
end
def no_gzip
render text: 'PNG'
end
def gzip_level
render text: 'Big text'
end
def expire_custom_path
expire_page('/index.html')
head :ok
end
def trailing_slash
render text: 'Sneak attack'
end
def about_me
respond_to do |format|
format.html { render text: 'I am html' }
format.xml { render text: 'I am xml' }
end
end
end
class PageCachingTest < ActionController::TestCase
def setup
super
@request = ActionController::TestRequest.new
@request.host = 'hostname.com'
@request.env.delete('PATH_INFO')
@controller = PageCachingTestController.new
@controller.perform_caching = true
@controller.cache_store = :file_store, FILE_STORE_PATH
@response = ActionController::TestResponse.new
@params = { controller: 'posts', action: 'index', only_path: true }
FileUtils.rm_rf(File.dirname(FILE_STORE_PATH))
FileUtils.mkdir_p(FILE_STORE_PATH)
end
def teardown
FileUtils.rm_rf(File.dirname(FILE_STORE_PATH))
@controller.perform_caching = false
end
def test_page_caching_resources_saves_to_correct_path_with_extension_even_if_default_route
with_routing do |set|
set.draw do
get 'posts.:format', to: 'posts#index', as: :formatted_posts
get '/', to: 'posts#index', as: :main
end
@params[:format] = 'rss'
assert_equal '/posts.rss', @routes.url_for(@params)
@params[:format] = nil
assert_equal '/', @routes.url_for(@params)
end
end
def test_should_cache_head_with_ok_status
head :ok
assert_response :ok
assert_page_cached :ok, 'head with ok status should have been cached'
end
def test_should_cache_get_with_ok_status
get :ok
assert_response :ok
assert_page_cached :ok, 'get with ok status should have been cached'
end
def test_should_cache_with_custom_path
get :custom_path
assert File.exist?("#{FILE_STORE_PATH}/index.html")
end
def test_should_expire_cache_with_custom_path
get :custom_path
assert File.exist?("#{FILE_STORE_PATH}/index.html")
get :expire_custom_path
assert !File.exist?("#{FILE_STORE_PATH}/index.html")
end
def test_should_gzip_cache
get :custom_path
assert File.exist?("#{FILE_STORE_PATH}/index.html.gz")
get :expire_custom_path
assert !File.exist?("#{FILE_STORE_PATH}/index.html.gz")
end
def test_should_allow_to_disable_gzip
get :no_gzip
assert File.exist?("#{FILE_STORE_PATH}/page_caching_test/no_gzip.html")
assert !File.exist?("#{FILE_STORE_PATH}/page_caching_test/no_gzip.html.gz")
end
def test_should_use_config_gzip_by_default
@controller.expects(:cache_page).with(nil, nil, Zlib::BEST_COMPRESSION)
get :default_gzip
end
def test_should_set_gzip_level
@controller.expects(:cache_page).with(nil, nil, Zlib::BEST_SPEED)
get :gzip_level
end
def test_should_cache_without_trailing_slash_on_url
@controller.class.cache_page 'cached content', '/page_caching_test/trailing_slash'
assert File.exist?("#{FILE_STORE_PATH}/page_caching_test/trailing_slash.html")
end
def test_should_obey_http_accept_attribute
@request.env['HTTP_ACCEPT'] = 'text/xml'
get :about_me
assert File.exist?("#{FILE_STORE_PATH}/page_caching_test/about_me.xml")
assert_equal 'I am xml', @response.body
end
def test_cached_page_should_not_have_trailing_slash_even_if_url_has_trailing_slash
@controller.class.cache_page 'cached content', '/page_caching_test/trailing_slash/'
assert File.exist?("#{FILE_STORE_PATH}/page_caching_test/trailing_slash.html")
end
def test_should_cache_ok_at_custom_path
@request.env['PATH_INFO'] = '/index.html'
get :ok
assert_response :ok
assert File.exist?("#{FILE_STORE_PATH}/index.html")
end
[:ok, :no_content, :found, :not_found].each do |status|
[:get, :post, :patch, :put, :delete].each do |method|
unless method == :get && status == :ok
define_method "test_shouldnt_cache_#{method}_with_#{status}_status" do
send(method, status)
assert_response status
assert_page_not_cached status, "#{method} with #{status} status shouldn't have been cached"
end
end
end
end
def test_page_caching_conditional_options
get :ok, format: 'json'
assert_page_not_cached :ok
end
def test_page_caching_directory_set_as_pathname
begin
ActionController::Base.page_cache_directory = Pathname.new(FILE_STORE_PATH)
get :ok
assert_response :ok
assert_page_cached :ok
ensure
ActionController::Base.page_cache_directory = FILE_STORE_PATH
end
end
private
def assert_page_cached(action, message = "#{action} should have been cached")
assert page_cached?(action), message
end
def assert_page_not_cached(action, message = "#{action} shouldn't have been cached")
assert !page_cached?(action), message
end
def page_cached?(action)
File.exist? "#{FILE_STORE_PATH}/page_caching_test/#{action}.html"
end
end
actionpack-page-caching-1.0.2/test/abstract_unit.rb 0000644 0001750 0001750 00000000637 12433636401 023576 0 ustar balasankarc balasankarc require 'bundler/setup'
require 'minitest/autorun'
require 'action_controller'
require 'action_controller/page_caching'
SharedTestRoutes = ActionDispatch::Routing::RouteSet.new
module ActionController
class Base
include SharedTestRoutes.url_helpers
end
class TestCase
def setup
@routes = SharedTestRoutes
@routes.draw do
get ':controller(/:action)'
end
end
end
end
actionpack-page-caching-1.0.2/test/log_subscriber_test.rb 0000644 0001750 0001750 00000002422 12433636401 024771 0 ustar balasankarc balasankarc require 'abstract_unit'
require 'active_support/log_subscriber/test_helper'
require 'action_controller/log_subscriber'
module Another
class LogSubscribersController < ActionController::Base
abstract!
self.perform_caching = true
def with_page_cache
cache_page('Super soaker', '/index.html')
render nothing: true
end
end
end
class ACLogSubscriberTest < ActionController::TestCase
tests Another::LogSubscribersController
include ActiveSupport::LogSubscriber::TestHelper
def setup
super
@routes = SharedTestRoutes
@routes.draw do
get ':controller(/:action)'
end
@cache_path = File.expand_path('../temp/test_cache', File.dirname(__FILE__))
ActionController::Base.page_cache_directory = @cache_path
@controller.cache_store = :file_store, @cache_path
ActionController::LogSubscriber.attach_to :action_controller
end
def teardown
ActiveSupport::LogSubscriber.log_subscribers.clear
FileUtils.rm_rf(@cache_path)
end
def set_logger(logger)
ActionController::Base.logger = logger
end
def test_with_page_cache
get :with_page_cache
wait
logs = @logger.logged(:info)
assert_equal 3, logs.size
assert_match(/Write page/, logs[1])
assert_match(/\/index\.html/, logs[1])
end
end
actionpack-page-caching-1.0.2/README.md 0000644 0001750 0001750 00000006015 12433636401 020703 0 ustar balasankarc balasankarc actionpack-page_caching
=======================
Static page 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-page_caching'
And then execute:
$ bundle
Or install it yourself as:
$ gem install actionpack-page_caching
Usage
-----
Page caching is an approach to caching where the entire action output of is
stored as a HTML file that the web server can serve without going through
Action Pack. This is the fastest way to cache your content as opposed to going
dynamically through the process of generating the content. Unfortunately, this
incredible speed-up is only available to stateless pages where all visitors are
treated the same. Content management systems -- including weblogs and wikis --
have many pages that are a great fit for this approach, but account-based systems
where people log in and manipulate their own data are often less likely candidates.
First you need to set `page_cache_directory` in your configuration file:
config.action_controller.page_cache_directory = "#{Rails.root.to_s}/public/deploy"
Specifying which actions to cache is done through the `caches_page` class method:
class WeblogController < ActionController::Base
caches_page :show, :new
end
This will generate cache files such as `weblog/show/5.html` and
`weblog/new.html`, which match the URLs used that would normally trigger
dynamic page generation. Page caching works by configuring a web server to first
check for the existence of files on disk, and to serve them directly when found,
without passing the request through to Action Pack. This is much faster than
handling the full dynamic request in the usual way.
Expiration of the cache is handled by deleting the cached file, which results
in a lazy regeneration approach where the cache is not restored before another
hit is made against it. The API for doing so mimics the options from `url_for`
and friends:
class WeblogController < ActionController::Base
def update
List.update(params[:list][:id], params[:list])
expire_page action: 'show', id: params[:list][:id]
redirect_to action: 'show', id: params[:list][:id]
end
end
Additionally, you can expire caches using [Sweepers](https://github.com/rails/rails-observers#action-controller-sweeper)
that act on changes in the model to determine when a cache is supposed to be expired.
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/page_caching)
* [](https://gemnasium.com/rails/actionpack-page_caching)
actionpack-page-caching-1.0.2/CHANGELOG.md 0000644 0001750 0001750 00000000255 12433636401 021235 0 ustar balasankarc balasankarc # 1.0.2
* Fix load order problem with other gems.
# 1.0.1
* Add Railtie to set `page_cache_directory` by default to `public` folder. (Fixes #5)
# 1.0.0
* First Release