sprockets 2.11.3 → 3.7.2

data/lib/sprockets/transformers.rb

@@ -0,0 +1,145 @@
+require 'sprockets/http_utils'
+require 'sprockets/processor_utils'
+require 'sprockets/utils'
+
+module Sprockets
+  module Transformers
+    include HTTPUtils, ProcessorUtils, Utils
+
+    # Public: Two level mapping of a source mime type to a target mime type.
+    #
+    #   environment.transformers
+    #   # => { 'text/coffeescript' => {
+    #            'application/javascript' => ConvertCoffeeScriptToJavaScript
+    #          }
+    #        }
+    #
+    def transformers
+      config[:transformers]
+    end
+
+    # Public: Register a transformer from and to a mime type.
+    #
+    # from - String mime type
+    # to   - String mime type
+    # proc - Callable block that accepts an input Hash.
+    #
+    # Examples
+    #
+    #   register_transformer 'text/coffeescript', 'application/javascript',
+    #     ConvertCoffeeScriptToJavaScript
+    #
+    #   register_transformer 'image/svg+xml', 'image/png', ConvertSvgToPng
+    #
+    # Returns nothing.
+    def register_transformer(from, to, proc)
+      self.config = hash_reassoc(config, :registered_transformers, from) do |transformers|
+        transformers.merge(to => proc)
+      end
+      compute_transformers!
+    end
+
+    # Internal: Resolve target mime type that the source type should be
+    # transformed to.
+    #
+    # type   - String from mime type
+    # accept - String accept type list (default: '*/*')
+    #
+    # Examples
+    #
+    #   resolve_transform_type('text/plain', 'text/plain')
+    #   # => 'text/plain'
+    #
+    #   resolve_transform_type('image/svg+xml', 'image/png, image/*')
+    #   # => 'image/png'
+    #
+    #   resolve_transform_type('text/css', 'image/png')
+    #   # => nil
+    #
+    # Returns String mime type or nil is no type satisfied the accept value.
+    def resolve_transform_type(type, accept)
+      find_best_mime_type_match(accept || '*/*', [type].compact + config[:transformers][type].keys)
+    end
+
+    # Internal: Expand accept type list to include possible transformed types.
+    #
+    # parsed_accepts - Array of accept q values
+    #
+    # Examples
+    #
+    #   expand_transform_accepts([['application/javascript', 1.0]])
+    #   # => [['application/javascript', 1.0], ['text/coffeescript', 0.8]]
+    #
+    # Returns an expanded Array of q values.
+    def expand_transform_accepts(parsed_accepts)
+      accepts = []
+      parsed_accepts.each do |(type, q)|
+        accepts.push([type, q])
+        config[:inverted_transformers][type].each do |subtype|
+          accepts.push([subtype, q * 0.8])
+        end
+      end
+      accepts
+    end
+
+    # Internal: Compose multiple transformer steps into a single processor
+    # function.
+    #
+    # transformers - Two level Hash of a source mime type to a target mime type
+    # types - Array of mime type steps
+    #
+    # Returns Processor.
+    def compose_transformers(transformers, types)
+      if types.length < 2
+        raise ArgumentError, "too few transform types: #{types.inspect}"
+      end
+
+      i = 0
+      processors = []
+
+      loop do
+        src = types[i]
+        dst = types[i+1]
+        break unless src && dst
+
+        unless processor = transformers[src][dst]
+          raise ArgumentError, "missing transformer for type: #{src} to #{dst}"
+        end
+        processors.concat config[:postprocessors][src]
+        processors << processor
+        processors.concat config[:preprocessors][dst]
+
+        i += 1
+      end
+
+      if processors.size > 1
+        compose_processors(*processors.reverse)
+      elsif processors.size == 1
+        processors.first
+      end
+    end
+
+    private
+      def compute_transformers!
+        registered_transformers = self.config[:registered_transformers]
+        transformers = Hash.new { {} }
+        inverted_transformers = Hash.new { Set.new }
+
+        registered_transformers.keys.flat_map do |key|
+          dfs_paths([key]) { |k| registered_transformers[k].keys }
+        end.each do |types|
+          src, dst = types.first, types.last
+          processor = compose_transformers(registered_transformers, types)
+
+          transformers[src] = {} unless transformers.key?(src)
+          transformers[src][dst] = processor
+
+          inverted_transformers[dst] = Set.new unless inverted_transformers.key?(dst)
+          inverted_transformers[dst] << src
+        end
+
+        self.config = hash_reassoc(config, :transformers) { transformers }
+        self.config = hash_reassoc(config, :inverted_transformers) { inverted_transformers }
+      end
+  end
+end

data/lib/sprockets/uglifier_compressor.rb

@@ -1,29 +1,56 @@
-require 'tilt'
+require 'sprockets/autoload'
+require 'sprockets/digest_utils'
 
 module Sprockets
-  class UglifierCompressor < Tilt::Template
-    self.default_mime_type = 'application/javascript'
+  # Public: Uglifier/Uglify compressor.
+  #
+  # To accept the default options
+  #
+  #     environment.register_bundle_processor 'application/javascript',
+  #       Sprockets::UglifierCompressor
+  #
+  # Or to pass options to the Uglifier class.
+  #
+  #     environment.register_bundle_processor 'application/javascript',
+  #       Sprockets::UglifierCompressor.new(comments: :copyright)
+  #
+  class UglifierCompressor
+    VERSION = '1'
 
-    def self.engine_initialized?
-      defined?(::Uglifier)
+    # Public: Return singleton instance with default options.
+    #
+    # Returns UglifierCompressor object.
+    def self.instance
+      @instance ||= new
     end
 
-    def initialize_engine
-      require_template_library 'uglifier'
+    def self.call(input)
+      instance.call(input)
     end
 
-    def prepare
+    def self.cache_key
+      instance.cache_key
     end
 
-    def evaluate(context, locals, &block)
+    attr_reader :cache_key
+
+    def initialize(options = {})
       # Feature detect Uglifier 2.0 option support
-      if Uglifier::DEFAULTS[:copyright]
+      if Autoload::Uglifier::DEFAULTS[:copyright]
         # Uglifier < 2.x
-        Uglifier.new(:copyright => false).compile(data)
+        options[:copyright] ||= false
       else
         # Uglifier >= 2.x
-        Uglifier.new(:comments => :none).compile(data)
+        options[:comments] ||= :none
       end
+
+      @options = options
+      @cache_key = "#{self.class.name}:#{Autoload::Uglifier::VERSION}:#{VERSION}:#{DigestUtils.digest(options)}".freeze
+    end
+
+    def call(input)
+      @uglifier ||= Autoload::Uglifier.new(@options)
+      @uglifier.compile(input[:data])
     end
   end
 end

data/lib/sprockets/unloaded_asset.rb

@@ -0,0 +1,137 @@
+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 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 lazilly 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 store 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 contain a set of stored dependencies
+    # for a given asset path and filename digest.
+    #
+    # A dependency can refer to either an asset i.e. 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 depndencies 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,98 @@
+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

@@ -0,0 +1,188 @@
+require 'uri'
+
+module Sprockets
+  # Internal: Asset URI related parsing utilities. Mixed into Environment.
+  #
+  # An Asset URI identifies the compiled Asset result. It shares the file:
+  # scheme and requires an absolute path.
+  #
+  # Other query parameters
+  #
+  # type - String output content type. Otherwise assumed from file extension.
+  #        This maybe different than the extension if the asset is transformed
+  #        from one content type to another. For an example .coffee -> .js.
+  #
+  # id - Unique fingerprint of the entire asset and all its metadata. Assets
+  #      will only have the same id if they serialize to an identical value.
+  #
+  # pipeline - String name of pipeline.
+  #
+  module URIUtils
+    extend self
+
+    # Internal: Parse URI into component parts.
+    #
+    # uri - String uri
+    #
+    # Returns Array of components.
+    def split_uri(uri)
+      URI.split(uri)
+    end
+
+    # Internal: Join URI component parts into String.
+    #
+    # Returns String.
+    def join_uri(scheme, userinfo, host, port, registry, path, opaque, query, fragment)
+      URI::Generic.new(scheme, userinfo, host, port, registry, path, opaque, query, fragment).to_s
+    end
+
+    # Internal: Parse file: URI into component parts.
+    #
+    # uri - String uri
+    #
+    # Returns [scheme, host, path, query].
+    def split_file_uri(uri)
+      scheme, _, host, _, _, path, _, query, _ = URI.split(uri)
+
+      path = URI::Generic::DEFAULT_PARSER.unescape(path)
+      path.force_encoding(Encoding::UTF_8)
+
+      # Hack for parsing Windows "file:///C:/Users/IEUser" paths
+      path.gsub!(/^\/([a-zA-Z]:)/, '\1'.freeze)
+
+      [scheme, host, path, query]
+    end
+
+    # Internal: Join file: URI component parts into String.
+    #
+    # Returns String.
+    def join_file_uri(scheme, host, path, query)
+      str = "#{scheme}://"
+      str << host if host
+      path = "/#{path}" unless path.start_with?("/")
+      str << URI::Generic::DEFAULT_PARSER.escape(path)
+      str << "?#{query}" if query
+      str
+    end
+
+    # Internal: Check if String is a valid Asset URI.
+    #
+    # str - Possible String asset URI.
+    #
+    # 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
+    rescue URI::InvalidURIError
+      false
+    end
+
+    # Internal: Parse Asset URI.
+    #
+    # Examples
+    #
+    #   parse("file:///tmp/js/application.coffee?type=application/javascript")
+    #   # => "/tmp/js/application.coffee", {type: "application/javascript"}
+    #
+    # uri - String asset URI
+    #
+    # Returns String path and Hash of symbolized parameters.
+    def parse_asset_uri(uri)
+      scheme, _, path, query = split_file_uri(uri)
+
+      unless scheme == 'file'
+        raise URI::InvalidURIError, "expected file:// scheme: #{uri}"
+      end
+
+      return path, parse_uri_query_params(query)
+    end
+
+    # Internal: Build Asset URI.
+    #
+    # Examples
+    #
+    #   build("/tmp/js/application.coffee", type: "application/javascript")
+    #   # => "file:///tmp/js/application.coffee?type=application/javascript"
+    #
+    # path   - String file path
+    # params - Hash of optional parameters
+    #
+    # Returns String URI.
+    def build_asset_uri(path, params = {})
+      join_file_uri("file", nil, path, encode_uri_query_params(params))
+    end
+
+    # Internal: Parse file-digest dependency URI.
+    #
+    # Examples
+    #
+    #   parse("file-digest:/tmp/js/application.js")
+    #   # => "/tmp/js/application.js"
+    #
+    # uri - String file-digest URI
+    #
+    # Returns String path.
+    def parse_file_digest_uri(uri)
+      scheme, _, path, _ = split_file_uri(uri)
+
+      unless scheme == 'file-digest'.freeze
+        raise URI::InvalidURIError, "expected file-digest scheme: #{uri}"
+      end
+
+      path
+    end
+
+    # Internal: Build file-digest dependency URI.
+    #
+    # Examples
+    #
+    #   build("/tmp/js/application.js")
+    #   # => "file-digest:/tmp/js/application.js"
+    #
+    # path - String file path
+    #
+    # Returns String URI.
+    def build_file_digest_uri(path)
+      join_file_uri('file-digest'.freeze, nil, path, nil)
+    end
+
+    # Internal: Serialize hash of params into query string.
+    #
+    # params - Hash of params to serialize
+    #
+    # Returns String query or nil if empty.
+    def encode_uri_query_params(params)
+      query = []
+
+      params.each do |key, value|
+        case value
+        when Integer
+          query << "#{key}=#{value}"
+        when String, Symbol
+          query << "#{key}=#{URI::Generic::DEFAULT_PARSER.escape(value.to_s)}"
+        when TrueClass
+          query << "#{key}"
+        when FalseClass, NilClass
+        else
+          raise TypeError, "unexpected type: #{value.class}"
+        end
+      end
+
+      "#{query.join('&')}" if query.any?
+    end
+
+    # Internal: Parse query string into hash of params
+    #
+    # query - String query string
+    #
+    # Return Hash of params.
+    def parse_uri_query_params(query)
+      query.to_s.split('&').reduce({}) do |h, p|
+        k, v = p.split('=', 2)
+        v = URI::Generic::DEFAULT_PARSER.unescape(v) if v
+        h[k.to_sym] = v || true
+        h
+      end
+    end
+  end
+end

data/lib/sprockets/utils/gzip.rb

@@ -0,0 +1,67 @@
+module Sprockets
+  module Utils
+    class Gzip
+      # Private: Generates a gzipped file based off of reference file.
+      def initialize(asset)
+        @content_type  = asset.content_type
+        @source        = asset.source
+        @charset       = asset.charset
+      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?(mime_types)
+        # 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?(mime_types)
+        !can_compress?(mime_types)
+      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(target)
+        mtime = PathUtils.stat(target).mtime
+        PathUtils.atomic_write("#{target}.gz") do |f|
+          gz = Zlib::GzipWriter.new(f, Zlib::BEST_COMPRESSION)
+          gz.mtime = mtime
+          gz.write(@source)
+          gz.close
+
+          File.utime(mtime, mtime, f.path)
+        end
+
+        nil
+      end
+    end
+  end
+end