openstreetmap-actionpack-page_caching 1.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e69b08cb6ea991488bfaa2cc9da8e8b622b8274ea783dd2691dba7c6095ec98b
+  data.tar.gz: b0a314a0c11879641dc509c2bf14b619a61a35e7b2981035e382f3af102fe882
+SHA512:
+  metadata.gz: e612b361bcdd0dc7581ae85a9a98b8258cc1716d5a6925a0260657c80b2def7f49fe22420914c38fb3a4b8d6d9eb6cb294f43a417ffa9395e64b20e7e396da6d
+  data.tar.gz: 2e0ad0654a516f12652870838e75c11d7d84d129def2ea94c3f1e8a7a38b53d7a87fe3589ef9ac81c56a7b3f1ada2762cb689163aa0d5840ef42576a0f0f18ac

data/.codeclimate.yml

@@ -0,0 +1,7 @@
+engines:
+  rubocop:
+    enabled: true
+
+ratings:
+  paths:
+  - "**.rb"

data/.gitignore

@@ -0,0 +1,5 @@
+.ruby-version
+Gemfile.lock
+gemfiles/*.lock
+pkg/*
+test/tmp

data/.rubocop.yml

@@ -0,0 +1,116 @@
+AllCops:
+  TargetRubyVersion: 2.2
+  # RuboCop has a bunch of cops enabled by default. This setting tells RuboCop
+  # to ignore them, so only the ones explicitly set in this file are enabled.
+  DisabledByDefault: true
+
+# Prefer &&/|| over and/or.
+Style/AndOr:
+  Enabled: true
+
+# Do not use braces for hash literals when they are the last argument of a
+# method call.
+Style/BracesAroundHashParameters:
+  Enabled: true
+
+# Align `when` with `case`.
+Style/CaseIndentation:
+  Enabled: true
+
+# Align comments with method definitions.
+Style/CommentIndentation:
+  Enabled: true
+
+# No extra empty lines.
+Style/EmptyLines:
+  Enabled: true
+
+# In a regular class definition, no empty lines around the body.
+Style/EmptyLinesAroundClassBody:
+  Enabled: true
+
+# In a regular module definition, no empty lines around the body.
+Style/EmptyLinesAroundModuleBody:
+  Enabled: true
+
+# Use Ruby >= 1.9 syntax for hashes. Prefer { a: :b } over { :a => :b }.
+Style/HashSyntax:
+  Enabled: true
+
+# Method definitions after `private` or `protected` isolated calls need one
+# extra level of indentation.
+Style/IndentationConsistency:
+  Enabled: true
+  EnforcedStyle: rails
+
+# Two spaces, no tabs (for indentation).
+Style/IndentationWidth:
+  Enabled: true
+
+Style/SpaceAfterColon:
+  Enabled: true
+
+Style/SpaceAfterComma:
+  Enabled: true
+
+Style/SpaceAroundEqualsInParameterDefault:
+  Enabled: true
+
+Style/SpaceAroundKeyword:
+  Enabled: true
+
+Style/SpaceAroundOperators:
+  Enabled: true
+
+Style/SpaceBeforeFirstArg:
+    Enabled: true
+
+# Defining a method with parameters needs parentheses.
+Style/MethodDefParentheses:
+  Enabled: true
+
+# Use `foo {}` not `foo{}`.
+Style/SpaceBeforeBlockBraces:
+  Enabled: true
+
+# Use `foo { bar }` not `foo {bar}`.
+Style/SpaceInsideBlockBraces:
+  Enabled: true
+
+# Use `{ a: 1 }` not `{a:1}`.
+Style/SpaceInsideHashLiteralBraces:
+  Enabled: true
+
+Style/SpaceInsideParens:
+  Enabled: true
+
+# Check quotes usage according to lint rule below.
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+# Detect hard tabs, no hard tabs.
+Style/Tab:
+  Enabled: true
+
+# Blank lines should not have any spaces.
+Style/TrailingBlankLines:
+  Enabled: true
+
+# No trailing whitespace.
+Style/TrailingWhitespace:
+  Enabled: true
+
+# Use quotes for string literals when they are enough.
+Style/UnneededPercentQ:
+  Enabled: true
+
+# Align `end` with the matching keyword or starting expression except for
+# assignments, where it should be aligned with the LHS.
+Lint/EndAlignment:
+  Enabled: true
+  AlignWith: variable
+
+# Use my_method(my_arg) not my_method( my_arg ) or my_method my_arg.
+Lint/RequireParentheses:
+  Enabled: true

data/.travis.yml

@@ -0,0 +1,43 @@
+language: ruby
+sudo: false
+
+cache:
+  bundler: true
+
+before_install:
+  - gem install bundler
+
+rvm:
+  - 2.4.6
+  - 2.5.5
+  - 2.6.3
+
+gemfile:
+  - Gemfile
+  - gemfiles/Gemfile-5-0-stable
+  - gemfiles/Gemfile-5-1-stable
+  - gemfiles/Gemfile-5-2-stable
+  - gemfiles/Gemfile-6-0-stable
+  - gemfiles/Gemfile-edge
+
+matrix:
+  allow_failures:
+    - gemfile: gemfiles/Gemfile-edge
+  exclude:
+    - rvm: 2.4.6
+      gemfile: gemfiles/Gemfile-6-0-stable
+    - rvm: 2.4.6
+      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="

data/CHANGELOG.md

@@ -0,0 +1,47 @@
+## 1.1.1 (September 25, 2018)
+
+*   Fixes handling of several forward slashes as root path.
+
+    *Xavier Noria*
+
+*   Documentation overhaul.
+
+    *Xavier Noria*
+
+
+## 1.1.0 (January 23, 2017)
+
+*   Support dynamic `page_cache_directory` using a Proc, Symbol or callable
+
+    *Andrew White*
+
+*   Support instance level setting of `page_cache_directory`
+
+    *Andrew White*
+
+*   Add support for Rails 5.0 and master
+
+    *Andrew White*
+
+
+## 1.0.2 (November 15, 2013)
+
+*   Fix load order problem with other gems.
+
+    *Rafael Mendonça França*
+
+
+## 1.0.1 (October 24, 2013)
+
+*   Add Railtie to set `page_cache_directory` by default to `public` folder.
+
+    Fixes #5.
+
+    *Žiga Vidic*
+
+
+## 1.0.0 (February 27, 2013)
+
+*   Extract Action Pack - Action Caching from Rails core.
+
+    *Francesco Rodriguez*, *Rafael Mendonça França*, *Michiel Sikkes*

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rails"

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,215 @@
+# actionpack-page_caching
+
+Static page caching for Action Pack (removed from core in Rails 4.0).
+
+## Introduction
+
+Page caching is an approach to caching in which response bodies are stored in
+files that the web server can serve directly:
+
+1. A request to endpoint _E_ arrives.
+2. Its response is calculated and stored in a file _F_.
+3. Next time _E_ is requested, the web server sends _F_ directly.
+
+That applies only to GET or HEAD requests whose response code is 200, the rest
+are ignored.
+
+Unlike caching proxies or other more sophisticated setups, page caching results
+in a dramatic speed up while being dead simple at the same time. Awesome
+cost/benefit.
+
+The reason for such performance boost is that cached endpoints are
+short-circuited by the web server, which is very efficient at serving static
+files. Requests to cached endpoints do not even reach your Rails application.
+
+This technique, however, is only suitable for pages that do not need to go
+through your Rails stack, precisely. For example, content management systems
+like wikis have typically 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. As a use case you can check, [Rails
+Contributors](https://contributors.rubyonrails.org/) makes heavy use of page
+caching. Its source code is [here](https://github.com/rails/rails-contributors).
+
+It is not all or nothing, though, in HTML cached pages JavaScript can still
+tweak details here and there dynamically as a trade-off.
+
+## Installation
+
+Add this line to your application's `Gemfile`:
+
+``` ruby
+gem "actionpack-page_caching"
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+## Usage
+
+### Enable Caching
+
+Page caching needs caching enabled:
+
+```ruby
+config.action_controller.perform_caching = true
+```
+
+That goes typically in `config/environments/production.rb`, but you can activate
+that flag in any mode.
+
+Since Rails 5 there is a special toggler to easily enable/disable caching in
+`development` mode without editing its configuration file. Just execute
+
+```
+$ bin/rails dev:cache
+```
+
+to enable/disable caching in `development` mode.
+
+### Configure the Cache Directory
+
+#### Default Cache Directory
+
+By default, files are stored below the `public` directory of your Rails
+application, with a path that matches the one in the URL.
+
+For example, a page-cached request to `/posts/what-is-new-in-rails-6` would be
+stored by default in the file `public/posts/what-is-new-in-rails-6.html`, and
+the web server would be configured to check that path in the file system before
+falling back to Rails. More on this later.
+
+#### Custom Cache Directory
+
+The default page caching directory can be overridden:
+
+``` ruby
+config.action_controller.page_cache_directory = Rails.root.join("public", "cached_pages")
+```
+
+There is no need to ensure the directory exists when the application boots,
+whenever a page has to be cached, the page cache directory is created if needed.
+
+#### Custom Cache Directory per Controller
+
+The globally configured cache directory, default or custom, can be overridden in
+each controller. There are three ways of doing this.
+
+With a lambda:
+
+``` ruby
+class WeblogController < ApplicationController
+  self.page_cache_directory = -> {
+    Rails.root.join("public", request.domain)
+  }
+end
+```
+
+a symbol:
+
+``` ruby
+class WeblogController < ApplicationController
+  self.page_cache_directory = :domain_cache_directory
+
+  private
+    def domain_cache_directory
+      Rails.root.join("public", request.domain)
+    end
+end
+```
+
+or a callable object:
+
+``` ruby
+class DomainCacheDirectory
+  def self.call(request)
+    Rails.root.join("public", request.domain)
+  end
+end
+
+class WeblogController < ApplicationController
+  self.page_cache_directory = DomainCacheDirectory
+end
+```
+
+Intermediate directories are created as needed also in this case.
+
+### Specify Actions to be Cached
+
+Specifying which actions have to be cached is done through the `caches_page` class method:
+
+``` ruby
+class WeblogController < ActionController::Base
+  caches_page :show, :new
+end
+```
+
+### Configure The Web Server
+
+The [wiki](https://github.com/rails/actionpack-page_caching/wiki) of the project
+has some examples of web server configuration.
+
+### Cache Expiration
+
+Expiration of the cache is handled by deleting the cached files, which results
+in a lazy regeneration approach in which the content is stored again as cached
+endpoints are hit.
+
+#### Full Cache Expiration
+
+If the cache is stored in a separate directory like `public/cached_pages`, you
+can easily expire the whole thing by removing said directory.
+
+Removing a directory recursively with something like `rm -rf` is unreliable
+because that operation is not atomic and can mess up with concurrent page cache
+generation.
+
+In POSIX systems moving a file is atomic, so the recommended approach would be
+to move the directory first out of the way, and then recursively delete that
+one. Something like
+
+```bash
+#!/bin/bash
+
+tmp=public/cached_pages-$(date +%s)
+mv public/cached_pages $tmp
+rm -rf $tmp
+```
+
+As noted before, the page cache directory is created if it does not exist, so
+moving the directory is enough to have a clean cache, no need to recreate.
+
+#### Fine-grained Cache Expiration
+
+The API for doing so mimics the options from `url_for` and friends:
+
+``` ruby
+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.svg?branch=master)](https://travis-ci.org/rails/actionpack-page_caching)