Enable brotli compression in the caches_page

Author: iggant

.travis.yml

@@ -5,19 +5,17 @@ cache:
   bundler: true
 
 before_install:
-  - gem install bundler
+  - "travis_retry gem update --system 2.7.9"
+  - "travis_retry gem install bundler -v '1.17.3'"
 
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.9
-  - 2.2.6
   - 2.3.3
   - 2.4.0
+  - 2.5.0
+  - 2.6.3
 
 gemfile:
   - Gemfile
-  - gemfiles/Gemfile-4-0-stable
   - gemfiles/Gemfile-4-1-stable
   - gemfiles/Gemfile-4-2-stable
   - gemfiles/Gemfile-5-0-stable
@@ -27,23 +25,9 @@ matrix:
   allow_failures:
     - gemfile: gemfiles/Gemfile-edge
   exclude:
-    - rvm: 1.9.3
-      gemfile: Gemfile
-    - rvm: 2.0.0
-      gemfile: Gemfile
-    - rvm: 2.1.9
-      gemfile: Gemfile
-    - rvm: 1.9.3
-      gemfile: gemfiles/Gemfile-5-0-stable
-    - rvm: 2.0.0
-      gemfile: gemfiles/Gemfile-5-0-stable
-    - rvm: 2.1.9
-      gemfile: gemfiles/Gemfile-5-0-stable
-    - rvm: 1.9.3
+    - rvm: 2.3.3
       gemfile: gemfiles/Gemfile-edge
-    - rvm: 2.0.0
-      gemfile: gemfiles/Gemfile-edge
-    - rvm: 2.1.9
+    - rvm: 2.4.0
       gemfile: gemfiles/Gemfile-edge
     - rvm: 2.4.0
       gemfile: gemfiles/Gemfile-4-0-stable

actionpack-page_caching.gemspec

@@ -16,6 +16,7 @@ Gem::Specification.new do |gem|
   gem.license       = 'MIT'
 
   gem.add_dependency "actionpack", ">= 4.0.0"
+  gem.add_dependency 'brotli', '>= 0.2.0'
 
   gem.add_development_dependency "mocha"
 end

lib/action_controller/caching/pages.rb

@@ -1,10 +1,15 @@
+# frozen_string_literal: true
+
 require "fileutils"
 require "uri"
 require "active_support/core_ext/class/attribute_accessors"
 require "active_support/core_ext/string/strip"
+require 'brotli'
 
 module ActionController
   module Caching
+    COMPRESSIONS_DEFAULTS = {gzip: 9, brotli: 9} # ::Zlib::BEST_COMPRESSION
+
     # 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
@@ -60,6 +65,9 @@ module Pages
         # or <tt>:best_speed</tt> or an integer configuring the compression level.
         class_attribute :page_cache_compression
         self.page_cache_compression ||= false
+
+        class_attribute :page_cache_compressions
+        self.page_cache_compressions ||= COMPRESSIONS_DEFAULTS
       end
 
       class PageCache #:nodoc:
@@ -75,9 +83,9 @@ def expire(path)
           end
         end
 
-        def cache(content, path, extension = nil, gzip = Zlib::BEST_COMPRESSION)
+        def cache(content, path, extension = nil, compressions: COMPRESSIONS_DEFAULTS)
           instrument :write_page, path do
-            write(content, cache_path(path, extension), gzip)
+            write(content, cache_path(path, extension), compressions: compressions)
           end
         end
 
@@ -161,14 +169,20 @@ def cache_path(path, extension = nil)
           def delete(path)
             File.delete(path) if File.exist?(path)
             File.delete(path + ".gz") if File.exist?(path + ".gz")
+            File.delete(path + ".br") if File.exist?(path + ".br")
           end
 
-          def write(content, path, gzip)
+          def write(content, path, compressions:)
             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) }
+            if compressions[:gzip]
+              Zlib::GzipWriter.open(path + ".gz", compressions[:gzip]) { |f| f.write(content) }
+            end
+
+            if compressions[:brotli]
+              brotli = ::Brotli.deflate(content, mode: :text, quality: compressions[:brotli])
+              File.atomic_write(path + ".br") { |f| f.write(brotli) }
             end
           end
 
@@ -190,9 +204,9 @@ def expire_page(path)
         # 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)
+        def cache_page(content, path, extension = nil, compressions: COMPRESSIONS_DEFAULTS)
           if perform_caching
-            page_cache.cache(content, path, extension, gzip)
+            page_cache.cache(content, path, extension, compressions: compressions)
           end
         end
 
@@ -214,21 +228,33 @@ def caches_page(*actions)
           if 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 Integer
-                gzip_level
-              when false
-                nil
-              else
-                Zlib::BEST_COMPRESSION
-              end
+            compressions = options.fetch(:compressions, page_cache_compressions)
+
+            if options.key?(:gzip)
+              ActiveSupport::Deprecation.warn(
+                "actionpack-page-caching now support brotli compression.\n
+                Using gzip directly is deprecated. instead of\n caches_page :index, gzip: Zlib::BEST_COMPRESSION \n
+                please use\n caches_page :index, compressions: {gzip: Zlib::BEST_COMPRESSION, brotli: 9}"
+              )
+
+              gzip_level = options.fetch(:gzip, page_cache_compression)
+              gzip_level = \
+                case gzip_level
+                when Symbol
+                  Zlib.const_get(gzip_level.upcase)
+                when Integer
+                  gzip_level
+                when false
+                  nil
+                else
+                  Zlib::BEST_COMPRESSION
+                end
+
+              compressions[:gzip] = gzip_level
+            end
 
             after_action({ only: actions }.merge(options)) do |c|
-              c.cache_page(nil, nil, gzip_level)
+              c.cache_page(nil, nil, compressions: compressions)
             end
           end
         end
@@ -263,7 +289,7 @@ def expire_page(options = {})
       # 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)
+      def cache_page(content = nil, options = nil, compressions: COMPRESSIONS_DEFAULTS)
         if perform_caching? && caching_allowed?
           path = \
             case options
@@ -279,7 +305,7 @@ def cache_page(content = nil, options = nil, gzip = Zlib::BEST_COMPRESSION)
             extension = ".#{type_symbol}"
           end
 
-          page_cache.cache(content || response.body, path, extension, gzip)
+          page_cache.cache(content || response.body, path, extension, compressions: compressions)
         end
       end
 

lib/action_controller/page_caching.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "action_controller/caching/pages"
 
 module ActionController

lib/actionpack/page_caching.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require "actionpack/page_caching/railtie"

lib/actionpack/page_caching/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails/railtie"
 
 module ActionPack

test/caching_test.rb

@@ -118,9 +118,11 @@ class PageCachingTestController < CachingController
   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
+  caches_page :default_compressions
+  caches_page :no_gzip, compressions: {gzip: false}
+  caches_page :gzip_level, compressions: {gzip: 1}
+  caches_page :no_brotli, compressions: {brotli: false}
+  caches_page :brotli_level, compressions: {brotli: 1}
 
   def ok
     render html: "ok"
@@ -143,8 +145,8 @@ def custom_path
     cache_page(nil, "/index.html")
   end
 
-  def default_gzip
-    render html: "default_gzip"
+  def default_compressions
+    render html: "default_compressions"
   end
 
   def no_gzip
@@ -155,6 +157,14 @@ def gzip_level
     render html: "gzip_level"
   end
 
+  def no_brotli
+    render html: "no_brotli"
+  end
+
+  def brotli_level
+    render html: "brotli_level"
+  end
+
   def expire_custom_path
     expire_page("/index.html")
     head :ok
@@ -241,6 +251,7 @@ def test_should_gzip_cache
 
     get :expire_custom_path
     assert_page_not_cached :index, controller: ".", format: "html.gz"
+    assert_page_not_cached :index, controller: ".", format: "html.br"
   end
 
   def test_should_allow_to_disable_gzip
@@ -253,24 +264,43 @@ def test_should_allow_to_disable_gzip
     assert_page_not_cached :no_gzip, format: "html.gz"
   end
 
-  def test_should_use_config_gzip_by_default
+  def test_should_allow_to_disable_brotli
+    draw do
+      get "/page_caching_test/no_brotli", to: "page_caching_test#no_brotli"
+    end
+
+    get :no_brotli
+    assert_page_cached :no_brotli, format: "html"
+    assert_page_not_cached :no_brotli, format: "html.br"
+  end
+
+  def test_should_use_config_compressions_by_default
     draw do
-      get "/page_caching_test/default_gzip", to: "page_caching_test#default_gzip"
+      get "/page_caching_test/default_compressions", to: "page_caching_test#default_compressions"
     end
 
-    @controller.expects(:cache_page).with(nil, nil, Zlib::BEST_COMPRESSION)
-    get :default_gzip
+    @controller.expects(:cache_page).with(nil, nil, compressions: {gzip: Zlib::BEST_COMPRESSION, brotli: 9})
+    get :default_compressions
   end
 
   def test_should_set_gzip_level
     draw do
       get "/page_caching_test/gzip_level", to: "page_caching_test#gzip_level"
     end
 
-    @controller.expects(:cache_page).with(nil, nil, Zlib::BEST_SPEED)
+    @controller.expects(:cache_page).with(nil, nil, compressions: {gzip: Zlib::BEST_SPEED})
     get :gzip_level
   end
 
+  def test_should_set_brotli_level
+    draw do
+      get "/page_caching_test/brotli_level", to: "page_caching_test#brotli_level"
+    end
+
+    @controller.expects(:cache_page).with(nil, nil, compressions: {brotli: 1})
+    get :brotli_level
+  end
+
   def test_should_cache_without_trailing_slash_on_url
     @controller.class.cache_page "cached content", "/page_caching_test/trailing_slash"
     assert_page_cached :trailing_slash, content: "cached content"