actionpack-page-caching-1.0.2/0000755000175000017500000000000012433636401017422 5ustar balasankarcbalasankarcactionpack-page-caching-1.0.2/Gemfile0000644000175000017500000000006412433636401020715 0ustar balasankarcbalasankarcsource 'https://rubygems.org' gemspec gem 'rails' actionpack-page-caching-1.0.2/gemfiles/0000755000175000017500000000000012433636401021215 5ustar balasankarcbalasankarcactionpack-page-caching-1.0.2/gemfiles/Gemfile-edge0000644000175000017500000000015012433636401023406 0ustar balasankarcbalasankarcsource 'https://rubygems.org' gemspec path: '..' gem 'rails', github: 'rails/rails', branch: 'master' actionpack-page-caching-1.0.2/gemfiles/Gemfile-4-0-stable0000644000175000017500000000015412433636401024256 0ustar balasankarcbalasankarcsource 'https://rubygems.org' gemspec path: '..' gem 'rails', github: 'rails/rails', branch: '4-0-stable' actionpack-page-caching-1.0.2/.gitignore0000644000175000017500000000023212433636401021407 0ustar balasankarcbalasankarc*.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/Rakefile0000644000175000017500000000031112433636401021062 0ustar balasankarcbalasankarc#!/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.txt0000644000175000017500000000207112433636401021245 0ustar balasankarcbalasankarcCopyright (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.yml0000644000175000017500000000450212433636401021726 0ustar balasankarcbalasankarc--- !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/0000755000175000017500000000000012433636401020170 5ustar balasankarcbalasankarcactionpack-page-caching-1.0.2/lib/actionpack/0000755000175000017500000000000012433636401022304 5ustar balasankarcbalasankarcactionpack-page-caching-1.0.2/lib/actionpack/page_caching.rb0000644000175000017500000000005212433636401025216 0ustar balasankarcbalasankarcrequire 'actionpack/page_caching/railtie' actionpack-page-caching-1.0.2/lib/actionpack/page_caching/0000755000175000017500000000000012433636401024674 5ustar balasankarcbalasankarcactionpack-page-caching-1.0.2/lib/actionpack/page_caching/railtie.rb0000644000175000017500000000076712433636401026664 0ustar balasankarcbalasankarcrequire '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/0000755000175000017500000000000012433636401023710 5ustar balasankarcbalasankarcactionpack-page-caching-1.0.2/lib/action_controller/page_caching.rb0000644000175000017500000000035612433636401026631 0ustar balasankarcbalasankarcrequire '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/0000755000175000017500000000000012433636401025304 5ustar balasankarcbalasankarcactionpack-page-caching-1.0.2/lib/action_controller/caching/pages.rb0000644000175000017500000001733412433636401026740 0ustar balasankarcbalasankarcrequire '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.yml0000644000175000017500000000116012433636401021531 0ustar balasankarcbalasankarclanguage: 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.gemspec0000644000175000017500000000145312433636401025474 0ustar balasankarcbalasankarc# -*- 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/0000755000175000017500000000000012433636401020401 5ustar balasankarcbalasankarcactionpack-page-caching-1.0.2/test/caching_test.rb0000644000175000017500000001545012433636401023366 0ustar balasankarcbalasankarcrequire '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.rb0000644000175000017500000000063712433636401023576 0ustar balasankarcbalasankarcrequire '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.rb0000644000175000017500000000242212433636401024771 0ustar balasankarcbalasankarcrequire '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.md0000644000175000017500000000601512433636401020703 0ustar balasankarcbalasankarcactionpack-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 ----------- * [![Build Status](https://travis-ci.org/rails/actionpack-page_caching.png?branch=master)](https://travis-ci.org/rails/page_caching) * [![Dependency Status](https://gemnasium.com/rails/actionpack-page_caching.png)](https://gemnasium.com/rails/actionpack-page_caching) actionpack-page-caching-1.0.2/CHANGELOG.md0000644000175000017500000000025512433636401021235 0ustar balasankarcbalasankarc# 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