rack-page_caching 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fb99cfbdf37f440d76310e72aa7678ef50755dad
+  data.tar.gz: f9c25904f971fd111f2de264031bf260ab04593c
+SHA512:
+  metadata.gz: 61f3b351f508dcf1940953c5285857dfa8ef8b41945e1f0fbeac636693a910ec7c4ab05e85a97cfd9d48a10891e12835c8f9dfc3db59a7204044accdb4898929
+  data.tar.gz: 6e621c8fee7c6b5a533f78c56f5855a08638d6f5d74de9dd8df7e2b36698f96d728802fef70c3332af8c41e820cbd750a373fa57ca73bac316a9cae5f6857e48

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+gemfiles/*.gemfile.lock

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1
+  - 2.1.2
+  - jruby
+gemfile:
+  - gemfiles/rails_3.gemfile
+  - gemfiles/rails_4.gemfile

data/Appraisals

@@ -0,0 +1,7 @@
+appraise "rails-3" do
+  gem "rails", github: 'rails/rails', branch: '3-2-stable'
+end
+
+appraise "rails-4" do
+  gem "rails", github: 'rails/rails', branch: '4-0-stable'
+end

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rack-page_caching.gemspec
+gemspec
+
+gem 'coveralls', require: false

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Wayne See
+
+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,113 @@
+# Rack::PageCaching
+
+[![Dependency Status](https://gemnasium.com/weynsee/rack-page_caching.svg)](https://gemnasium.com/weynsee/rack-page_caching)
+[![Build Status](https://travis-ci.org/weynsee/rack-page_caching.svg?branch=master)](https://travis-ci.org/weynsee/rack-page_caching)
+[![Coverage Status](https://img.shields.io/coveralls/weynsee/rack-page_caching.svg)](https://coveralls.io/r/weynsee/rack-page_caching?branch=master)
+
+Rack::PageCaching is a Rack middleware that aids in static page caching. It serves
+the same purpose as [page caching in Rails](https://github.com/rails/actionpack-page_caching) 
+and was designed to be a drop-in replacement to Rails page caching.
+
+Rack::PageCaching provides a few differences from Rails page caching. It is
+implemented as a Rack middleware, which means transformations done on the 
+response by other middlewares will be present in the generated static page.
+Examples of middlewares that work well with page caching include 
+[htmlcompressor](https://github.com/paolochiodi/htmlcompressor) and 
+[rack-pjax](https://github.com/eval/rack-pjax).
+Implementing it in Rack also  means that it can also be used in other 
+Rack-compatible frameworks like Sinatra.
+
+While it was designed to be a drop-in replacement for Rails page caching, it
+provides additional features like including the hostname in the path of the
+generated static page.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rack-page_caching'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rack-page_caching
+
+Tell your app to use the Rack::PageCaching middleware.
+For Rails 3+ apps:
+
+```ruby
+# In config/application.rb
+config.middleware.use Rack::PageCaching
+```
+
+Or for Rackup files:
+
+```ruby
+# In config.ru
+use Rack::PageCaching
+```
+
+When you want page caching to be applied to a response modified by other
+middlewares, make sure you place Rack::PageCaching *before* those 
+middlewares.
+
+It has been tested on Rails 3 and 4, and on Ruby 1.9.3 and 2.x.
+
+## Usage
+
+Rack::PageCaching accepts all the options accepted by Rails page caching: 
+```ruby
+config.middleware.use Rack::PageCaching,
+  # Directory where the pages are stored. Defaults to the public folder in
+  # Rails, but you'll probably want to customize this
+  page_cache_directory: Rails.root.join('public', 'page_cache'),
+  # Gzipped version of the files are generated with compression level
+  # specified. It accepts the symbol versions of the constants in Zlib,
+  # e.g. :best_speed and :best_compression. To turn off gzip, pass in false.
+  gzip: :best_speed,
+  # Hostnames can be included in the path of the page cache. Default is false.
+  include_hostname: false
+```
+Rack::PageCaching respects `config.action_controller.perform_caching` and
+will skip cache generation if it is false.
+
+To configure your web server to serve the generated pages directly, point it to
+`page_cache_directory`. For Nginx, it would look something like:
+```
+if (-f $document_root/page_cache/$host/$uri/index.html) {
+  rewrite (.*) /page_cache/$host/$1/index.html break;
+}
+
+if (-f $document_root/page_cache/$host/$uri.html) {
+  rewrite (.*) /page_cache/$host/$1.html break;
+}
+```
+
+Rack::PageCaching implements the same class methods Rails page caching provides, 
+so if you were using it previously you can leave it as is:
+```ruby
+class WeblogController < ActionController::Base
+  caches_page :show, :new
+end
+```
+Expiration is also supported the same way:
+```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
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/rack-page_caching/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/**/*_spec.rb"
+  t.libs << 'test'
+end
+
+task :default => :test

data/gemfiles/rails_3.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "coveralls", :require => false
+gem "rails", :github => "rails/rails", :branch => "3-2-stable"
+
+gemspec :path => "../"

data/gemfiles/rails_4.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "coveralls", :require => false
+gem "rails", :github => "rails/rails", :branch => "4-0-stable"
+
+gemspec :path => "../"

data/lib/rack/page_caching/action_controller.rb

@@ -0,0 +1,61 @@
+module Rack
+  class PageCaching
+    module ActionController
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def caches_page(*actions)
+          return unless perform_caching
+          options = actions.extract_options!
+          gzip_level = options.fetch(:gzip, Zlib::BEST_COMPRESSION)
+          gzip_level = Rack::PageCaching::Utils.gzip_level(gzip_level)
+          after_filter({ only: actions }.merge(options)) do |c|
+            c.request.env['rack.page_caching.perform_caching'] = true
+            c.request.env['rack.page_caching.compression'] = gzip_level
+          end
+        end
+      end
+
+      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|
+              Rack::PageCaching::Cache.delete(url_for(options.merge(only_path: true, action: action)))
+            end
+          else
+            Rack::PageCaching::Cache.delete(url_for(options.merge(only_path: true)))
+          end
+        else
+          Rack::PageCaching::Cache.delete(options)
+        end
+      end
+
+      def cache_page(content = nil, options = nil, gzip = Zlib::BEST_COMPRESSION)
+        return unless self.class.perform_caching
+
+        path = case options
+          when Hash
+            url_for(options.merge(only_path: true, format: params[:format]))
+          when String
+            options
+          else
+            request.path
+        end
+        path = path.chomp('/')
+
+        if (type = ::Mime::LOOKUP[self.content_type]) && (type_symbol = type.symbol).present?
+          path = "#{path}.#{type_symbol}" unless /#{type_symbol}\z/.match(path)
+        end
+
+        Rack::PageCaching::Cache.write_file(
+          Array(content || response.body), path,
+          Rack::PageCaching::Utils.gzip_level(gzip)
+        )
+      end
+    end
+  end
+end
+
+ActionController::Base.send(:include, Rack::PageCaching::ActionController)

data/lib/rack/page_caching/cache.rb

@@ -0,0 +1,74 @@
+require 'fileutils'
+require 'zlib'
+
+module Rack
+  class PageCaching
+    class Cache
+      def initialize(response)
+        @response = response
+      end
+
+      def store
+        if path = page_cache_path
+          self.class.write_file(@response.body, path, gzip_level)
+        end
+      end
+
+      def page_cache_path
+        path = Rack::Utils.unescape(@response.path.chomp('/'))
+        if !path.include?('..')
+          type = Rack::PageCaching::MimeTypes.extension_for @response.content_type
+          path = '/index' if path.empty?
+          path = "#{path}#{type}" unless /#{Regexp.quote(type)}\z/.match(path)
+          path = "/#{@response.host}#{path}"  if config.include_hostname?
+          path
+        end
+      end
+
+      def gzip_level
+        @response.gzip_level || config.page_cache_compression
+      end
+
+      def self.store(response)
+        Rack::PageCaching::Cache.new(response).store
+      end
+
+      def self.write_file(content, path, gzip_level)
+        expand_path('write_page', path) do |full_path|
+          FileUtils.makedirs(::File.dirname(full_path))
+          ::File.open(full_path, 'wb+') { |f| content.each { |c| f.write(c) } }
+          if gzip_level
+            Zlib::GzipWriter.open(full_path + '.gz', gzip_level) do |f|
+              content.each do |c|
+                f.write(c)
+              end
+            end
+          end
+        end
+      end
+
+      def self.delete(path)
+        expand_path('expire_page', path) do |full_path|
+          Dir[full_path].each do |file|
+            ::File.delete(file)
+            ::File.delete(file + '.gz') if ::File.exist?(file + '.gz')
+          end
+        end
+      end
+
+      private
+
+      def self.expand_path(name, path)
+        env = Rack::PageCaching.environment
+        full_path = ::File.join(env.page_cache_directory, path)
+        env.instrument name, full_path do
+          yield full_path
+        end
+      end
+
+      def config
+        Rack::PageCaching.environment
+      end
+    end
+  end
+end

data/lib/rack/page_caching/environment.rb

@@ -0,0 +1,64 @@
+module Rack
+  class PageCaching
+    class Environment
+      def initialize(options = {})
+        @options = options
+        set_defaults
+      end
+
+      def page_cache_compression
+        @options[:page_cache_compression]
+      end
+
+      def page_cache_directory
+        @options[:page_cache_directory]
+      end
+
+      def include_hostname?
+        @options[:include_hostname]
+      end
+
+      def enabled?
+        @options[:enable]
+      end
+
+      def instrument(name, path)
+        if defined? ActiveSupport::Notifications
+          ActiveSupport::Notifications.instrument("#{name}.action_controller", path: path) do
+            yield
+          end
+        else
+          yield
+        end
+      end
+
+      private
+
+      def set_defaults
+        set_rails_defaults if defined? ::Rails
+        normalize_values
+        toggle_caching
+      end
+
+      def normalize_values
+        @options.merge!(
+          page_cache_compression: Rack::PageCaching::Utils.gzip_level(
+            @options[:page_cache_compression]),
+          page_cache_directory: @options[:page_cache_directory].to_s,
+        )
+      end
+
+      def toggle_caching
+        @options[:enable] = false if @options[:page_cache_directory].strip == ''
+        @options[:enable] = true unless @options.has_key?(:enable)
+      end
+
+      def set_rails_defaults
+        @options = {
+          page_cache_directory: ::Rails.root.join('public'),
+          enable: ::Rails.application.config.action_controller.perform_caching
+        }.merge(@options)
+      end
+    end
+  end
+end

data/lib/rack/page_caching/mime_types.rb

@@ -0,0 +1,24 @@
+require 'rack/mime'
+
+module Rack
+  class PageCaching
+    class MimeTypes
+      def self.load!
+        mime_types = Rack::Mime::MIME_TYPES
+        extensions = Hash.new { |hash, key| hash[key] = [] }
+        mime_types.each do |extension, content_type|
+          extensions[content_type] << extension
+        end
+        @extension_lookup = extensions
+      end
+
+      def self.register(content_type, extension)
+        @extension_lookup[content_type] = [extension]
+      end
+
+      def self.extension_for(content_type)
+        @extension_lookup[content_type].first
+      end
+    end
+  end
+end

data/lib/rack/page_caching/response.rb

@@ -0,0 +1,50 @@
+require 'rack/request'
+
+module Rack
+  class PageCaching
+    class Response
+      def initialize(response, env)
+        @response, @env = response, env
+      end
+
+      def cacheable?
+        perform_caching? && caching_allowed?
+      end
+
+      def path
+        @path ||= request.path
+      end
+
+      def body
+        @response[2]
+      end
+
+      def content_type
+        @response[1]['Content-Type'].split(';').first
+      end
+
+      def gzip_level
+        @env['rack.page_caching.compression'].to_i if @env['rack.page_caching.compression']
+      end
+
+      def host
+        request.host
+      end
+
+      private
+
+      def request
+        @request ||= Rack::Request.new(@env)
+      end
+
+      def caching_allowed?
+        method = @env['REQUEST_METHOD']
+        (method == 'GET' || method == 'HEAD') && @response[0] == 200
+      end
+
+      def perform_caching?
+        @env['rack.page_caching.perform_caching'].to_s == 'true'
+      end
+    end
+  end
+end

data/lib/rack/page_caching/utils.rb

@@ -0,0 +1,16 @@
+module Rack
+  class PageCaching
+    module Utils
+      def self.gzip_level(gzip)
+        case gzip
+        when Symbol
+          Zlib.const_get(gzip.to_s.upcase)
+        when Fixnum
+          gzip
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/rack/page_caching/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  class PageCaching
+    VERSION = "0.0.1"
+  end
+end

data/lib/rack/page_caching.rb

@@ -0,0 +1,35 @@
+require "rack/page_caching/version"
+require "rack/page_caching/utils"
+require "rack/page_caching/environment"
+require "rack/page_caching/response"
+require "rack/page_caching/cache"
+require "rack/page_caching/mime_types"
+
+require "rack/page_caching/action_controller" if defined?(::Rails)
+
+module Rack
+  class PageCaching
+
+    MimeTypes.load!
+    MimeTypes.register 'text/html', '.html'
+    MimeTypes.register 'text/plain', '.txt'
+
+    def initialize(app, options = {})
+      @app = app
+      self.class.environment = Rack::PageCaching::Environment.new(options)
+    end
+
+    def call(env)
+      rack_response = @app.call(env)
+      if self.class.environment.enabled?
+        response = Rack::PageCaching::Response.new(rack_response, env)
+        Rack::PageCaching::Cache.store(response) if response.cacheable?
+      end
+      rack_response
+    end
+
+    class << self
+      attr_accessor :environment
+    end
+  end
+end

data/rack-page_caching.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rack/page_caching/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rack-page_caching"
+  spec.version       = Rack::PageCaching::VERSION
+  spec.authors       = ["Wayne See"]
+  spec.email         = ["weynsee@gmail.com"]
+  spec.summary       = %q{Page caching for Rack.}
+  spec.description   = %q{Rack middleware to generate pages that can be served by a webserver. Compatible with Rails page caching.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 1.9.2'
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "appraisal"
+  spec.add_development_dependency "rails", ">= 3"
+  spec.add_dependency "rack"
+end