static-rails 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c20abb5a4b37f323a10e55d18ad7a65d0cb4219bf77bf1a9869d2ed0ab8f446
-  data.tar.gz: 3ca5e505c0b05eb36846153d0cb6b05947f3359eb1a92c6cfb477d99fc368484
+  metadata.gz: d5808adb0f3f344a5706a6dddb5053899047f5d8aa4bbddb577168319b9aa046
+  data.tar.gz: d84c08d618e80a28b95be9da396f34d57636985ecf83859a906c5997a1532238
 SHA512:
-  metadata.gz: eb489b95dfc77757c3e72e3612c7d5fa021393684b230de937355e230778d371468922e1d5277d3d0ef819b106d5ab07db09dc7284b9a6eefe1098baec9dc58e
-  data.tar.gz: cbba26724c30fcfec192893973d5ec83de0d50ab719b05c842e457d504319d4658b65688f154566091e8a3bd50c27e8cc7df5bd5ac1645e73b67a821e866150a
+  metadata.gz: adb43e14b69561af8ce12989d319782b95d8c915b30968c4ce28d6bbf109426b8d606ba83d860002c2d793c16be3fbfe6c962be473df83507fd18d1e16de66c4
+  data.tar.gz: 7f4e6b9a9ed8dabaccd3a0da66671c36605a56e15da8483fe17f9518badbe3be6e2b82369ac4e7a05af9b4d594eaec1b010ad7616fc77b3aa835f81e0f87aa57

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.0.11
+
+* Inline the `ActionDispatch::FileHandler` from Rails master so that we can
+  target a single stable version of its API and control what MIME types it
+  considers to be compressible (bonus is that it effectively backports brotli
+  compression to pre-6.1 rails apps)
+
 ## 0.0.10
 
 * Change default `cache-control` header for static assets being served from disk

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    static-rails (0.0.10)
+    static-rails (0.0.11)
       rack-proxy (~> 0.6)
       railties (>= 5.0.0)
 

data/lib/static-rails/file_handler.rb

@@ -0,0 +1,173 @@
+module StaticRails
+  # This class was extracted from Ruby on Rails:
+  #
+  #   - actionpack/lib/action_dispatch/middleware/static.rb
+  #
+  # Copyright (c) 2005-2020 David Heinemeier Hansson, Ryan Edward Hall, Jeremy Daer
+  #
+  # License here: https://github.com/rails/rails/blob/master/MIT-LICENSE
+  #
+  # This endpoint serves static files from disk using Rack::File.
+  #
+  # URL paths are matched with static files according to expected
+  # conventions: +path+, +path+.html, +path+/index.html.
+  #
+  # Precompressed versions of these files are checked first. Brotli (.br)
+  # and gzip (.gz) files are supported. If +path+.br exists, this
+  # endpoint returns that file with a +Content-Encoding: br+ header.
+  #
+  # If no matching file is found, this endpoint responds 404 Not Found.
+  #
+  # Pass the +root+ directory to search for matching files, an optional
+  # +index: "index"+ to change the default +path+/index.html, and optional
+  # additional response headers.
+  class FileHandler
+    # Accept-Encoding value -> file extension
+    PRECOMPRESSED = {
+      "br" => ".br",
+      "gzip" => ".gz",
+      "identity" => nil
+    }
+
+    def initialize(root, index: "index", headers: {}, precompressed: %i[br gzip], compressible_content_types: /\A(?:text\/|application\/javascript)/)
+      @root = root.chomp("/").b
+      @index = index
+
+      @precompressed = Array(precompressed).map(&:to_s) | %w[identity]
+      @compressible_content_types = compressible_content_types
+
+      @file_server = ::Rack::File.new(@root, headers)
+    end
+
+    def call(env)
+      attempt(env) || @file_server.call(env)
+    end
+
+    def attempt(env)
+      request = Rack::Request.new env
+
+      if request.get? || request.head?
+        if (found = find_file(request.path_info, accept_encoding: request.accept_encoding))
+          serve request, *found
+        end
+      end
+    end
+
+    def serve(request, filepath, content_headers)
+      original, request.path_info =
+          request.path_info, ::Rack::Utils.escape_path(filepath).b
+
+      @file_server.call(request.env).tap do |status, headers, body|
+        # Omit Content-Encoding/Type/etc headers for 304 Not Modified
+        if status != 304
+          headers.update(content_headers)
+        end
+      end
+    ensure
+      request.path_info = original
+    end
+
+    # Match a URI path to a static file to be served.
+    #
+    # Used by the +Static+ class to negotiate a servable file in the
+    # +public/+ directory (see Static#call).
+    #
+    # Checks for +path+, +path+.html, and +path+/index.html files,
+    # in that order, including .br and .gzip compressed extensions.
+    #
+    # If a matching file is found, the path and necessary response headers
+    # (Content-Type, Content-Encoding) are returned.
+    def find_file(path_info, accept_encoding:)
+      each_candidate_filepath(path_info) do |filepath, content_type|
+        if (response = try_files(filepath, content_type, accept_encoding: accept_encoding))
+          return response
+        end
+      end
+    end
+
+    private
+
+    def try_files(filepath, content_type, accept_encoding:)
+      headers = {"Content-Type" => content_type}
+
+      if compressible? content_type
+        try_precompressed_files filepath, headers, accept_encoding: accept_encoding
+      elsif file_readable? filepath
+        [filepath, headers]
+      end
+    end
+
+    def try_precompressed_files(filepath, headers, accept_encoding:)
+      each_precompressed_filepath(filepath) do |content_encoding, precompressed_filepath|
+        if file_readable? precompressed_filepath
+          # Identity encoding is default, so we skip Accept-Encoding
+          # negotiation and needn't set Content-Encoding.
+          #
+          # Vary header is expected when we've found other available
+          # encodings that Accept-Encoding ruled out.
+          if content_encoding == "identity"
+            return precompressed_filepath, headers
+          else
+            headers["Vary"] = "Accept-Encoding"
+
+            if accept_encoding.any? { |enc, _| /\b#{content_encoding}\b/i.match?(enc) }
+              headers["Content-Encoding"] = content_encoding
+              return precompressed_filepath, headers
+            end
+          end
+        end
+      end
+    end
+
+    def file_readable?(path)
+      file_stat = File.stat(File.join(@root, path.b))
+    rescue SystemCallError
+      false
+    else
+      file_stat.file? && file_stat.readable?
+    end
+
+    def compressible?(content_type)
+      @compressible_content_types.match?(content_type)
+    end
+
+    def each_precompressed_filepath(filepath)
+      @precompressed.each do |content_encoding|
+        precompressed_ext = PRECOMPRESSED.fetch(content_encoding)
+        yield content_encoding, "#{filepath}#{precompressed_ext}"
+      end
+
+      nil
+    end
+
+    def each_candidate_filepath(path_info)
+      return unless (path = clean_path(path_info))
+
+      ext = ::File.extname(path)
+      content_type = ::Rack::Mime.mime_type(ext, nil)
+      yield path, content_type || "text/plain"
+
+      # Tack on .html and /index.html only for paths that don't have
+      # an explicit, resolvable file extension. No need to check
+      # for foo.js.html and foo.js/index.html.
+      unless content_type
+        default_ext = ::ActionController::Base.default_static_extension
+        if ext != default_ext
+          default_content_type = ::Rack::Mime.mime_type(default_ext, "text/plain")
+
+          yield "#{path}#{default_ext}", default_content_type
+          yield "#{path}/#{@index}#{default_ext}", default_content_type
+        end
+      end
+
+      nil
+    end
+
+    def clean_path(path_info)
+      path = ::Rack::Utils.unescape_path path_info.chomp("/")
+      if ::Rack::Utils.valid_path? path
+        ::Rack::Utils.clean_path_info path
+      end
+    end
+  end
+end

data/lib/static-rails/static_middleware.rb

@@ -1,6 +1,6 @@
 require "rack-proxy"
-require "action_dispatch/middleware/static"
 
+require_relative "file_handler"
 require_relative "matches_request_to_static_site"
 
 module StaticRails
@@ -18,9 +18,8 @@ module StaticRails
       if (req.get? || req.head?) && (site = @matches_request_to_static_site.call(req))
         file_handler = file_handler_for(site)
         path = req.path_info.gsub(/^#{site.url_root_path}/, "").chomp("/")
-        if (match = matching_file_for(file_handler, site, path))
-          req.path_info = match
-          return file_handler.serve(req)
+        if (found = find_file_for(file_handler, site, path, req.accept_encoding))
+          return file_handler.serve(req, *found)
         end
       end
 
@@ -32,19 +31,20 @@ module StaticRails
     # The same file handler used by Rails when serving up files from /public
     #   See: actionpack/lib/action_dispatch/middleware/static.rb
     def file_handler_for(site)
-      @file_handlers[site] ||= ActionDispatch::FileHandler.new(
+      @file_handlers[site] ||= FileHandler.new(
         StaticRails.config.app.root.join(site.compile_dir).to_s,
         headers: {
           "cache-control" => "public; max-age=31536000"
-        }
+        },
+        compressible_content_types: /^text\/|[\/+](javascript|json|text|xml|css|yaml)$/i
       )
     end
 
-    def matching_file_for(file_handler, site, path)
-      if (match = file_handler.match?(path))
-        match
+    def find_file_for(file_handler, site, path, accept_encoding)
+      if (found = file_handler.find_file(path, accept_encoding: accept_encoding))
+        found
       elsif site.compile_404_file_path.present?
-        file_handler.match?(site.compile_404_file_path)
+        file_handler.find_file(site.compile_404_file_path, accept_encoding: accept_encoding)
       end
     end
   end

data/lib/static-rails/version.rb

@@ -1,3 +1,3 @@
 module StaticRails
-  VERSION = "0.0.10"
+  VERSION = "0.0.11"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: static-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.11
 platform: ruby
 authors:
 - Justin Searls
@@ -64,6 +64,7 @@ files:
 - lib/static-rails/configuration.rb
 - lib/static-rails/determines_whether_to_handle_request.rb
 - lib/static-rails/error.rb
+- lib/static-rails/file_handler.rb
 - lib/static-rails/gets_csrf_token.rb
 - lib/static-rails/matches_request_to_static_site.rb
 - lib/static-rails/proxy_middleware.rb