sprockets 3.0.0 → 4.0.0

data/lib/sprockets/unloaded_asset.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+require 'sprockets/uri_utils'
+require 'sprockets/uri_tar'
+
+module Sprockets
+  # Internal: Used to parse and store the URI to an unloaded asset
+  # Generates keys used to store and retrieve items from cache
+  class UnloadedAsset
+
+    # Internal: Initialize object for generating cache keys
+    #
+    # uri - A String containing complete URI to a file including scheme
+    #       and full path such as
+    #       "file:///Path/app/assets/js/app.js?type=application/javascript"
+    # env - The current "environment" that assets are being loaded into.
+    #       We need it so we know where the +root+ (directory where Sprockets
+    #       is being invoked). We also need it for the `file_digest` method,
+    #       since, for some strange reason, memoization is provided by
+    #       overriding methods such as `stat` in the `PathUtils` module.
+    #
+    # Returns UnloadedAsset.
+    def initialize(uri, env)
+      @uri               = uri.to_s
+      @env               = env
+      @compressed_path   = URITar.new(uri, env).compressed_path
+      @params            = nil # lazy loaded
+      @filename          = nil # lazy loaded
+    end
+    attr_reader :compressed_path, :uri
+
+    # Internal: Full file path without schema
+    #
+    # This returns a string containing the full path to the asset without the schema.
+    # Information is loaded lazily since we want `UnloadedAsset.new(dep, self).relative_path`
+    # to be fast. Calling this method the first time allocates an array and a hash.
+    #
+    # Example
+    #
+    # If the URI is `file:///Full/path/app/assets/javascripts/application.js"` then the
+    # filename would be `"/Full/path/app/assets/javascripts/application.js"`
+    #
+    # Returns a String.
+    def filename
+      unless @filename
+        load_file_params
+      end
+      @filename
+    end
+
+    # Internal: Hash of param values
+    #
+    # This information is generated and used internally by Sprockets.
+    # Known keys include `:type` which stores the asset's mime-type, `:id` which is a fully resolved
+    # digest for the asset (includes dependency digest as opposed to a digest of only file contents)
+    # and `:pipeline`. Hash may be empty.
+    #
+    # Example
+    #
+    # If the URI is `file:///Full/path/app/assets/javascripts/application.js"type=application/javascript`
+    # Then the params would be `{type: "application/javascript"}`
+    #
+    # Returns a Hash.
+    def params
+      unless @params
+        load_file_params
+      end
+      @params
+    end
+
+    # Internal: Key of asset
+    #
+    # Used to retrieve an asset from the cache based on "compressed" path to asset.
+    # A "compressed" path can either be relative to the root of the project or an
+    # absolute path.
+    #
+    # Returns a String.
+    def asset_key
+      "asset-uri:#{compressed_path}"
+    end
+
+    # Public: Dependency History key
+    #
+    # Used to retrieve an array of "histories" each of which contains a set of stored dependencies
+    # for a given asset path and filename digest.
+    #
+    # A dependency can refer to either an asset e.g. index.js
+    # may rely on jquery.js (so jquery.js is a dependency), or other factors that may affect
+    # compilation, such as the VERSION of Sprockets (i.e. the environment) and what "processors"
+    # are used.
+    #
+    # For example a history array with one Set of dependencies may look like:
+    #
+    # [["environment-version", "environment-paths", "processors:type=text/css&file_type=text/css",
+    #   "file-digest:///Full/path/app/assets/stylesheets/application.css",
+    #   "processors:type=text/css&file_type=text/css&pipeline=self",
+    #   "file-digest:///Full/path/app/assets/stylesheets"]]
+    #
+    # This method of asset lookup is used to ensure that none of the dependencies have been modified
+    # since last lookup. If one of them has, the key will be different and a new entry must be stored.
+    #
+    # URI dependencies are later converted to "compressed" paths
+    #
+    # Returns a String.
+    def dependency_history_key
+      "asset-uri-cache-dependencies:#{compressed_path}:#{ @env.file_digest(filename) }"
+    end
+
+    # Internal: Digest key
+    #
+    # Used to retrieve a string containing the "compressed" path to an asset based on
+    # a digest. The digest is generated from dependencies stored via information stored in
+    # the `dependency_history_key` after each of the "dependencies" is "resolved".
+    # For example "environment-version" may be resolved to "environment-1.0-3.2.0"
+    # for version "3.2.0" of Sprockets
+    #
+    # Returns a String.
+    def digest_key(digest)
+      "asset-uri-digest:#{compressed_path}:#{digest}"
+    end
+
+    # Internal: File digest key
+    #
+    # The digest for a given file won't change if the path and the stat time hasn't changed
+    # We can save time by not re-computing this information and storing it in the cache
+    #
+    # Returns a String.
+    def file_digest_key(stat)
+      "file_digest:#{compressed_path}:#{stat}"
+    end
+
+    private
+      # Internal: Parses uri into filename and params hash
+      #
+      # Returns Array with filename and params hash
+      def load_file_params
+        @filename, @params = URIUtils.parse_asset_uri(uri)
+      end
+  end
+end

data/lib/sprockets/uri_tar.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+require 'sprockets/path_utils'
+
+module Sprockets
+ # Internal: used to "expand" and "compress" values for storage
+  class URITar
+    attr_reader :scheme, :root, :path
+
+    # Internal: Initialize object for compression or expansion
+    #
+    # uri - A String containing URI that may or may not contain the scheme
+    # env - The current "environment" that assets are being loaded into.
+    def initialize(uri, env)
+      @root = env.root
+      @env  = env
+      uri   = uri.to_s
+      if uri.include?("://".freeze)
+        @scheme, _, @path = uri.partition("://".freeze)
+        @scheme << "://".freeze
+      else
+        @scheme = "".freeze
+        @path   = uri
+      end
+    end
+
+    # Internal: Converts full uri to a "compressed" uri
+    #
+    # If a uri is inside of an environment's root it will
+    # be shortened to be a relative path.
+    #
+    # If a uri is outside of the environment's root the original
+    # uri will be returned.
+    #
+    # Returns String
+    def compress
+      scheme + compressed_path
+    end
+
+    # Internal: Tells us if we are using an absolute path
+    #
+    # Nix* systems start with a `/` like /Users/schneems.
+    # Windows systems start with a drive letter than colon and slash
+    # like C:/Schneems.
+    def absolute_path?
+      PathUtils.absolute_path?(path)
+    end
+
+    # Internal: Convert a "compressed" uri to an absolute path
+    #
+    # If a uri is inside of the environment's root it will not
+    # start with a slash for example:
+    #
+    #   file://this/is/a/relative/path
+    #
+    # If a uri is outside the root, it will start with a slash:
+    #
+    #   file:///This/is/an/absolute/path
+    #
+    # Returns String
+    def expand
+      if absolute_path?
+        # Stored path was absolute, don't add root
+        scheme + path
+      else
+        if scheme.empty?
+          File.join(root, path)
+        else
+          # We always want to return an absolute uri,
+          # make sure the path starts with a slash.
+          scheme + File.join("/".freeze, root, path)
+        end
+      end
+    end
+
+    # Internal: Returns "compressed" path
+    #
+    # If the input uri is relative to the environment root
+    # it will return a path relative to the environment root.
+    # Otherwise an absolute path will be returned.
+    #
+    # Only path information is returned, and not scheme.
+    #
+    # Returns String
+    def compressed_path
+      # windows
+      if !@root.start_with?("/".freeze) && path.start_with?("/".freeze)
+        consistent_root = "/".freeze + @root
+      else
+        consistent_root = @root
+      end
+
+      if compressed_path = PathUtils.split_subpath(consistent_root, path)
+        compressed_path
+      else
+        path
+      end
+    end
+  end
+end

data/lib/sprockets/uri_utils.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'uri'
 
 module Sprockets
@@ -17,9 +18,6 @@ module Sprockets
   #
   # pipeline - String name of pipeline.
   #
-  # encoding - A content encoding such as "gzip" or "deflate". NOT a charset
-  #            like "utf-8".
-  #
   module URIUtils
     extend self
 
@@ -50,8 +48,10 @@ module Sprockets
       path = URI::Generic::DEFAULT_PARSER.unescape(path)
       path.force_encoding(Encoding::UTF_8)
 
-      # Hack for parsing Windows "file:///C:/Users/IEUser" paths
-      path = path.gsub(/^\/([a-zA-Z]:)/, '\1')
+      # Hack for parsing Windows "/C:/Users/IEUser" paths
+      if File::ALT_SEPARATOR && path[2] == ':'
+        path = path[1..-1]
+      end
 
       [scheme, host, path, query]
     end
@@ -60,9 +60,9 @@ module Sprockets
     #
     # Returns String.
     def join_file_uri(scheme, host, path, query)
-      str = "#{scheme}://"
+      str = +"#{scheme}://"
       str << host if host
-      path = "/#{path}" unless path.start_with?("/")
+      path = "/#{path}" unless path.start_with?("/".freeze)
       str << URI::Generic::DEFAULT_PARSER.escape(path)
       str << "?#{query}" if query
       str
@@ -75,7 +75,7 @@ module Sprockets
     # Returns true or false.
     def valid_asset_uri?(str)
       # Quick prefix check before attempting a full parse
-      str.start_with?("file://") && parse_asset_uri(str) ? true : false
+      str.start_with?("file://".freeze) && parse_asset_uri(str) ? true : false
     rescue URI::InvalidURIError
       false
     end
@@ -128,7 +128,7 @@ module Sprockets
     def parse_file_digest_uri(uri)
       scheme, _, path, _ = split_file_uri(uri)
 
-      unless scheme == 'file-digest'
+      unless scheme == 'file-digest'.freeze
         raise URI::InvalidURIError, "expected file-digest scheme: #{uri}"
       end
 
@@ -146,7 +146,7 @@ module Sprockets
     #
     # Returns String URI.
     def build_file_digest_uri(path)
-      join_file_uri("file-digest", nil, path, nil)
+      join_file_uri('file-digest'.freeze, nil, path, nil)
     end
 
     # Internal: Serialize hash of params into query string.
@@ -171,7 +171,7 @@ module Sprockets
         end
       end
 
-      "#{query.join('&')}" if query.any?
+      "#{query.join('&'.freeze)}" if query.any?
     end
 
     # Internal: Parse query string into hash of params
@@ -180,10 +180,11 @@ module Sprockets
     #
     # Return Hash of params.
     def parse_uri_query_params(query)
-      query.to_s.split('&').reduce({}) do |h, p|
-        k, v = p.split('=', 2)
+      query.to_s.split('&'.freeze).reduce({}) do |h, p|
+        k, v = p.split('='.freeze, 2)
         v = URI::Generic::DEFAULT_PARSER.unescape(v) if v
-        h.merge(k.to_sym => v || true)
+        h[k.to_sym] = v || true
+        h
       end
     end
   end

data/lib/sprockets/utils/gzip.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+module Sprockets
+  module Utils
+    class Gzip
+      # Private: Generates a gzipped file based off of reference asset.
+      #
+      #     ZlibArchiver.call(file, source, mtime)
+      #
+      # Compresses a given `source` using stdlib Zlib algorithm
+      # writes contents to the `file` passed in. Sets `mtime` of
+      # written file to passed in `mtime`
+      module ZlibArchiver
+        def self.call(file, source, mtime)
+          gz = Zlib::GzipWriter.new(file, Zlib::BEST_COMPRESSION)
+          gz.mtime = mtime
+          gz.write(source)
+          gz.close
+
+          File.utime(mtime, mtime, file.path)
+        end
+      end
+
+      # Private: Generates a gzipped file based off of reference asset.
+      #
+      #     ZopfliArchiver.call(file, source, mtime)
+      #
+      # Compresses a given `source` using the zopfli gem
+      # writes contents to the `file` passed in. Sets `mtime` of
+      # written file to passed in `mtime`
+      module ZopfliArchiver
+        def self.call(file, source, mtime)
+          compressed_source = Autoload::Zopfli.deflate(source, format: :gzip, mtime: mtime)
+          file.write(compressed_source)
+          file.close
+
+          nil
+        end
+      end
+
+      attr_reader :content_type, :source, :charset, :archiver
+
+      # Private: Generates a gzipped file based off of reference file.
+      def initialize(asset, archiver: ZlibArchiver)
+        @content_type  = asset.content_type
+        @source        = asset.source
+        @charset       = asset.charset
+        @archiver      = archiver
+      end
+
+      # What non-text mime types should we compress? This list comes from:
+      # https://www.fastly.com/blog/new-gzip-settings-and-deciding-what-compress
+      COMPRESSABLE_MIME_TYPES = {
+        "application/vnd.ms-fontobject" => true,
+        "application/x-font-opentype" => true,
+        "application/x-font-ttf" => true,
+        "image/x-icon" => true,
+        "image/svg+xml" => true
+      }
+
+      # Private: Returns whether or not an asset can be compressed.
+      #
+      # We want to compress any file that is text based.
+      # You do not want to compress binary
+      # files as they may already be compressed and running them
+      # through a compression algorithm would make them larger.
+      #
+      # Return Boolean.
+      def can_compress?
+        # The "charset" of a mime type is present if the value is
+        # encoded text. We can check this value to see if the asset
+        # can be compressed.
+        #
+        # We also check against our list of non-text compressible mime types
+        @charset || COMPRESSABLE_MIME_TYPES.include?(@content_type)
+      end
+
+      # Private: Opposite of `can_compress?`.
+      #
+      # Returns Boolean.
+      def cannot_compress?
+        !can_compress?
+      end
+
+      # Private: Generates a gzipped file based off of reference asset.
+      #
+      # Compresses the target asset's contents and puts it into a file with
+      # the same name plus a `.gz` extension in the same folder as the original.
+      # Does not modify the target asset.
+      #
+      # Returns nothing.
+      def compress(file, target)
+        mtime = Sprockets::PathUtils.stat(target).mtime
+        archiver.call(file, source, mtime)
+
+        nil
+      end
+    end
+  end
+end

data/lib/sprockets/utils.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'set'
 
 module Sprockets
@@ -45,7 +46,8 @@ module Sprockets
     # Similar to Hash#store for nested frozen hashes.
     #
     # hash  - Hash
-    # key   - Object keys. Use multiple keys for nested hashes.
+    # key_a - Object key. Use multiple keys for nested hashes.
+    # key_b - Object key. Use multiple keys for nested hashes.
     # block - Receives current value at key.
     #
     # Examples
@@ -56,16 +58,19 @@ module Sprockets
     #     end
     #
     # Returns duplicated frozen Hash.
-    def hash_reassoc(hash, *keys, &block)
-      if keys.size == 1
-        hash_reassoc1(hash, keys[0], &block)
-      else
-        hash_reassoc1(hash, keys[0]) do |value|
-          hash_reassoc(value, *keys[1..-1], &block)
+    def hash_reassoc(hash, key_a, key_b = nil, &block)
+      if key_b
+        hash_reassoc1(hash, key_a) do |value|
+          hash_reassoc(value, key_b, &block)
         end
+      else
+        hash_reassoc1(hash, key_a, &block)
       end
     end
 
+    WHITESPACE_ORDINALS = {0x0A => "\n", 0x20 => " ", 0x09 => "\t"}
+    private_constant :WHITESPACE_ORDINALS
+
     # Internal: Check if string has a trailing semicolon.
     #
     # str - String
@@ -74,60 +79,43 @@ module Sprockets
     def string_end_with_semicolon?(str)
       i = str.size - 1
       while i >= 0
-        c = str[i]
+        c = str[i].ord
         i -= 1
-        if c == "\n" || c == " " || c == "\t"
-          next
-        elsif c != ";"
-          return false
-        else
-          return true
-        end
+
+        next if WHITESPACE_ORDINALS[c]
+
+        return c === 0x3B
       end
+
       true
     end
 
     # Internal: Accumulate asset source to buffer and append a trailing
     # semicolon if necessary.
     #
-    # buf   - String memo
-    # asset - Asset
+    # buf    - String buffer to append to
+    # source - String source to append
     #
-    # Returns appended buffer String.
+    # Returns buf String.
     def concat_javascript_sources(buf, source)
-      if string_end_with_semicolon?(buf)
-        buf + source
+      return buf if source.bytesize <= 0
+
+      buf << source
+      # If the source contains non-ASCII characters, indexing on it becomes O(N).
+      # This will lead to O(N^2) performance in string_end_with_semicolon?, so we should use 32 bit encoding to make sure indexing stays O(1)
+      source = source.encode(Encoding::UTF_32LE) unless source.ascii_only?
+      return buf if string_end_with_semicolon?(source)
+
+      # If the last character in the string was whitespace,
+      # such as a newline, then we want to put the semicolon
+      # before the whitespace. Otherwise append a semicolon.
+      if whitespace = WHITESPACE_ORDINALS[source[-1].ord]
+        buf[-1] = ";#{whitespace}"
       else
-        buf + ";\n" + source
+        buf << ";"
       end
-    end
 
-    # Internal: Prepends a leading "." to an extension if its missing.
-    #
-    #     normalize_extension("js")
-    #     # => ".js"
-    #
-    #     normalize_extension(".css")
-    #     # => ".css"
-    #
-    def normalize_extension(extension)
-      extension = extension.to_s
-      if extension[/^\./]
-        extension
-      else
-        ".#{extension}"
-      end
-    end
-
-    # Internal: Feature detect if UnboundMethods can #bind to any Object or
-    # just Objects that share the same super class.
-    # Basically if RUBY_VERSION >= 2.
-    UNBOUND_METHODS_BIND_TO_ANY_OBJECT = begin
-      foo = Module.new { def bar; end }
-      foo.instance_method(:bar).bind(Object.new)
-      true
-    rescue TypeError
-      false
+      buf
     end
 
     # Internal: Inject into target module for the duration of the block.
@@ -142,10 +130,6 @@ module Sprockets
         old_methods[sym] = base.instance_method(sym) if base.method_defined?(sym)
       end
 
-      unless UNBOUND_METHODS_BIND_TO_ANY_OBJECT
-        base.send(:include, mod) unless base < mod
-      end
-
       mod.instance_methods.each do |sym|
         method = mod.instance_method(sym)
         base.send(:define_method, sym, method)
@@ -199,16 +183,16 @@ module Sprockets
     # Returns an Array of node Arrays.
     def dfs_paths(path)
       paths = []
-      stack, seen = [path], Set.new
+      stack = [path]
+      seen  = Set.new
 
       while path = stack.pop
-        if !seen.include?(path.last)
-          seen.add(path.last)
-          paths << path if path.size > 1
+        seen.add(path.last)
+        paths << path
 
-          Array(yield path.last).reverse_each do |node|
-            stack.push(path + [node])
-          end
+        children = yield path.last
+        children.reverse_each do |node|
+          stack.push(path + [node]) unless seen.include?(node)
         end
       end
 

data/lib/sprockets/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Sprockets
-  VERSION = "3.0.0"
+  VERSION = "4.0.0"
 end

data/lib/sprockets/yui_compressor.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 require 'sprockets/autoload'
+require 'sprockets/digest_utils'
 
 module Sprockets
   # Public: YUI compressor.
@@ -35,12 +37,7 @@ module Sprockets
 
     def initialize(options = {})
       @options = options
-      @cache_key = [
-        self.class.name,
-        Autoload::YUI::Compressor::VERSION,
-        VERSION,
-        options
-      ].freeze
+      @cache_key = "#{self.class.name}:#{Autoload::YUI::Compressor::VERSION}:#{VERSION}:#{DigestUtils.digest(options)}".freeze
     end
 
     def call(input)
@@ -48,15 +45,9 @@ module Sprockets
 
       case input[:content_type]
       when 'application/javascript'
-        key = @cache_key + [input[:content_type], input[:data]]
-        input[:cache].fetch(key) do
-          Autoload::YUI::JavaScriptCompressor.new(@options).compress(data)
-        end
+        Autoload::YUI::JavaScriptCompressor.new(@options).compress(data)
       when 'text/css'
-        key = @cache_key + [input[:content_type], input[:data]]
-        input[:cache].fetch(key) do
-          Autoload::YUI::CssCompressor.new(@options).compress(data)
-        end
+        Autoload::YUI::CssCompressor.new(@options).compress(data)
       else
         data
       end