sprockets 3.0.1 → 3.7.5

data/lib/sprockets/processor_utils.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module Sprockets
   # Functional utilities for dealing with Processor functions.
   #
@@ -99,5 +101,80 @@ module Sprockets
     def processors_cache_keys(processors)
       processors.map { |processor| processor_cache_key(processor) }
     end
+
+    # Internal: Set of all "simple" value types allowed to be returned in
+    # processor metadata.
+    VALID_METADATA_VALUE_TYPES = Set.new([
+      String,
+      Symbol,
+      TrueClass,
+      FalseClass,
+      NilClass
+    ] + (0.class == Integer ? [Integer] : [Bignum, Fixnum])).freeze
+
+    # Internal: Set of all nested compound metadata types that can nest values.
+    VALID_METADATA_COMPOUND_TYPES = Set.new([
+      Array,
+      Hash,
+      Set
+    ]).freeze
+
+    # Internal: Hash of all "simple" value types allowed to be returned in
+    # processor metadata.
+    VALID_METADATA_VALUE_TYPES_HASH = VALID_METADATA_VALUE_TYPES.each_with_object({}) do |type, hash|
+      hash[type] = true
+    end.freeze
+
+    # Internal: Hash of all nested compound metadata types that can nest values.
+    VALID_METADATA_COMPOUND_TYPES_HASH = VALID_METADATA_COMPOUND_TYPES.each_with_object({}) do |type, hash|
+      hash[type] = true
+    end.freeze
+
+    # Internal: Set of all allowed metadata types.
+    VALID_METADATA_TYPES = (VALID_METADATA_VALUE_TYPES + VALID_METADATA_COMPOUND_TYPES).freeze
+
+    # Internal: Validate returned result of calling a processor pipeline and
+    # raise a friendly user error message.
+    #
+    # result - Metadata Hash returned from call_processors
+    #
+    # Returns result or raises a TypeError.
+    def validate_processor_result!(result)
+      if !result.instance_of?(Hash)
+        raise TypeError, "processor metadata result was expected to be a Hash, but was #{result.class}"
+      end
+
+      if !result[:data].instance_of?(String)
+        raise TypeError, "processor :data was expected to be a String, but as #{result[:data].class}"
+      end
+
+      result.each do |key, value|
+        if !key.instance_of?(Symbol)
+          raise TypeError, "processor metadata[#{key.inspect}] expected to be a Symbol"
+        end
+
+        if !valid_processor_metadata_value?(value)
+          raise TypeError, "processor metadata[:#{key}] returned a complex type: #{value.inspect}\n" +
+            "Only #{VALID_METADATA_TYPES.to_a.join(", ")} maybe used."
+        end
+      end
+
+      result
+    end
+
+    # Internal: Validate object is in validate metadata whitelist.
+    #
+    # value - Any Object
+    #
+    # Returns true if class is in whitelist otherwise false.
+    def valid_processor_metadata_value?(value)
+      if VALID_METADATA_VALUE_TYPES_HASH[value.class]
+        true
+      elsif VALID_METADATA_COMPOUND_TYPES_HASH[value.class]
+        value.all? { |v| valid_processor_metadata_value?(v) }
+      else
+        false
+      end
+    end
   end
 end

data/lib/sprockets/resolve.rb

@@ -53,7 +53,15 @@ module Sprockets
 
       unless uri
         message = "couldn't find file '#{path}'"
+
+        if relative_path?(path) && options[:base_path]
+          load_path, _ = paths_split(config[:paths], options[:base_path])
+          message << " under '#{load_path}'"
+        end
+
         message << " with type '#{options[:accept]}'" if options[:accept]
+        message << "\nChecked in these paths: \n  #{ config[:paths].join("\n  ") }"
+
         raise FileNotFound, message
       end
 
@@ -144,12 +152,6 @@ module Sprockets
         accepts
       end
 
-      def normalize_logical_path(path)
-        dirname, basename = File.split(path)
-        path = dirname if basename == 'index'
-        path
-      end
-
       def path_matches(load_path, logical_name, logical_basename)
         dirname    = File.dirname(File.join(load_path, logical_name))
         candidates = dirname_matches(dirname, logical_basename)
@@ -176,6 +178,7 @@ module Sprockets
         candidates = []
         entries = self.entries(dirname)
         entries.each do |entry|
+          next unless File.basename(entry).start_with?(basename)
           name, type, _, _ = parse_path_extnames(entry)
           if basename == name
             candidates << [File.join(dirname, entry), type]
@@ -199,7 +202,7 @@ module Sprockets
 
         if extname
           path = path.chomp(extname)
-          type, engines, pipeline = value.values_at(:type, :engines, :pipeline)
+          type, engines, pipeline = value
         end
 
         return path, type, engines, pipeline

data/lib/sprockets/sass_cache_store.rb

@@ -25,5 +25,10 @@ module Sprockets
   end
 
   # Deprecated: Use Sprockets::SassProcessor::CacheStore instead.
-  SassCacheStore = SassProcessor::CacheStore
+  class SassCacheStore < SassProcessor::CacheStore
+    def initialize(*args)
+      Deprecation.new.warn "SassCacheStore is deprecated please use SassProcessor::CacheStore instead"
+      super
+    end
+  end
 end

data/lib/sprockets/sass_compressor.rb

@@ -1,4 +1,5 @@
 require 'sprockets/autoload'
+require 'sprockets/digest_utils'
 
 module Sprockets
   # Public: Sass CSS minifier.
@@ -34,26 +35,17 @@ module Sprockets
     attr_reader :cache_key
 
     def initialize(options = {})
-      @options = options
-      @cache_key = [
-        self.class.name,
-        Autoload::Sass::VERSION,
-        VERSION,
-        options
-      ].freeze
+      @options = {
+        syntax: :scss,
+        cache: false,
+        read_cache: false,
+        style: :compressed
+      }.merge(options).freeze
+      @cache_key = "#{self.class.name}:#{Autoload::Sass::VERSION}:#{VERSION}:#{DigestUtils.digest(options)}".freeze
     end
 
     def call(input)
-      data = input[:data]
-      input[:cache].fetch(@cache_key + [data]) do
-        options = {
-          syntax: :scss,
-          cache: false,
-          read_cache: false,
-          style: :compressed
-        }.merge(@options)
-        Autoload::Sass::Engine.new(data, options).render
-      end
+      Autoload::Sass::Engine.new(input[:data], @options).render
     end
   end
 end

data/lib/sprockets/sass_processor.rb

@@ -39,17 +39,12 @@ module Sprockets
     # Public: Initialize template with custom options.
     #
     # options - Hash
-    #   cache_version - String custom cache version. Used to force a cache
-    #                   change after code changes are made to Sass Functions.
+    # cache_version - String custom cache version. Used to force a cache
+    #                 change after code changes are made to Sass Functions.
     #
     def initialize(options = {}, &block)
       @cache_version = options[:cache_version]
-      @cache_key = [
-        self.class.name,
-        VERSION,
-        Autoload::Sass::VERSION,
-        @cache_version
-      ].freeze
+      @cache_key = "#{self.class.name}:#{VERSION}:#{Autoload::Sass::VERSION}:#{@cache_version}".freeze
 
       @functions = Module.new do
         include Functions
@@ -64,7 +59,7 @@ module Sprockets
       options = {
         filename: input[:filename],
         syntax: self.class.syntax,
-        cache_store: CacheStore.new(input[:cache], @cache_version),
+        cache_store: build_cache_store(input, @cache_version),
         load_paths: input[:environment].paths,
         sprockets: {
           context: context,
@@ -89,6 +84,18 @@ module Sprockets
       context.metadata.merge(data: css, sass_dependencies: sass_dependencies)
     end
 
+    # Public: Build the cache store to be used by the Sass engine.
+    #
+    # input - the input hash.
+    # version - the cache version.
+    #
+    # Override this method if you need to use a different cache than the
+    # Sprockets cache.
+    def build_cache_store(input, version)
+      CacheStore.new(input[:cache], version)
+    end
+    private :build_cache_store
+
     # Public: Functions injected into Sass context during Sprockets evaluation.
     #
     # This module may be extended to add global functionality to all Sprockets

data/lib/sprockets/sass_template.rb

@@ -2,6 +2,18 @@ require 'sprockets/sass_processor'
 
 module Sprockets
   # Deprecated
-  SassTemplate = SassProcessor
-  ScssTemplate = ScssProcessor
+  class SassTemplate < SassProcessor
+    def self.call(*args)
+      Deprecation.new.warn "SassTemplate is deprecated please use SassProcessor instead"
+      super
+    end
+  end
+
+  # Deprecated
+  class ScssTemplate < ScssProcessor
+    def self.call(*args)
+      Deprecation.new.warn "ScssTemplate is deprecated please use ScssProcessor instead"
+      super
+    end
+  end
 end

data/lib/sprockets/server.rb

@@ -23,7 +23,7 @@ module Sprockets
       start_time = Time.now.to_f
       time_elapsed = lambda { ((Time.now.to_f - start_time) * 1000).to_i }
 
-      if env['REQUEST_METHOD'] != 'GET'
+      if !['GET', 'HEAD'].include?(env['REQUEST_METHOD'])
         return method_not_allowed_response
       end
 
@@ -39,7 +39,7 @@ module Sprockets
 
       # URLs containing a `".."` are rejected for security reasons.
       if forbidden_request?(path)
-        return forbidden_response
+        return forbidden_response(env)
       end
 
       # Look up the asset.
@@ -86,10 +86,10 @@ module Sprockets
         not_modified_response(env, if_none_match)
       when :not_found
         logger.info "#{msg} 404 Not Found (#{time_elapsed.call}ms)"
-        not_found_response
+        not_found_response(env)
       when :precondition_failed
         logger.info "#{msg} 412 Precondition Failed (#{time_elapsed.call}ms)"
-        precondition_failed_response
+        precondition_failed_response(env)
       end
     rescue Exception => e
       logger.error "Error compiling asset #{path}:"
@@ -115,12 +115,20 @@ module Sprockets
         #
         #     http://example.org/assets/../../../etc/passwd
         #
-        path.include?("..") || absolute_path?(path)
+        path.include?("..") || absolute_path?(path) || path.include?("://")
+      end
+
+      def head_request?(env)
+        env['REQUEST_METHOD'] == 'HEAD'
       end
 
       # Returns a 200 OK response tuple
       def ok_response(asset, env)
-        [ 200, headers(env, asset, asset.length), asset ]
+        if head_request?(env)
+          [ 200, headers(env, asset, 0), [] ]
+        else
+          [ 200, headers(env, asset, asset.length), asset ]
+        end
       end
 
       # Returns a 304 Not Modified response tuple
@@ -129,21 +137,33 @@ module Sprockets
       end
 
       # Returns a 403 Forbidden response tuple
-      def forbidden_response
-        [ 403, { "Content-Type" => "text/plain", "Content-Length" => "9" }, [ "Forbidden" ] ]
+      def forbidden_response(env)
+        if head_request?(env)
+          [ 403, { "Content-Type" => "text/plain", "Content-Length" => "0" }, [] ]
+        else
+          [ 403, { "Content-Type" => "text/plain", "Content-Length" => "9" }, [ "Forbidden" ] ]
+        end
       end
 
       # Returns a 404 Not Found response tuple
-      def not_found_response
-        [ 404, { "Content-Type" => "text/plain", "Content-Length" => "9", "X-Cascade" => "pass" }, [ "Not found" ] ]
+      def not_found_response(env)
+        if head_request?(env)
+          [ 404, { "Content-Type" => "text/plain", "Content-Length" => "0", "X-Cascade" => "pass" }, [] ]
+        else
+          [ 404, { "Content-Type" => "text/plain", "Content-Length" => "9", "X-Cascade" => "pass" }, [ "Not found" ] ]
+        end
       end
 
       def method_not_allowed_response
         [ 405, { "Content-Type" => "text/plain", "Content-Length" => "18" }, [ "Method Not Allowed" ] ]
       end
 
-      def precondition_failed_response
-        [ 412, { "Content-Type" => "text/plain", "Content-Length" => "19", "X-Cascade" => "pass" }, [ "Precondition Failed" ] ]
+      def precondition_failed_response(env)
+        if head_request?(env)
+          [ 412, { "Content-Type" => "text/plain", "Content-Length" => "0", "X-Cascade" => "pass" }, [] ]
+        else
+          [ 412, { "Content-Type" => "text/plain", "Content-Length" => "19", "X-Cascade" => "pass" }, [ "Precondition Failed" ] ]
+        end
       end
 
       # Returns a JavaScript response that re-throws a Ruby exception
@@ -231,11 +251,11 @@ module Sprockets
         # If the request url contains a fingerprint, set a long
         # expires on the response
         if path_fingerprint(env["PATH_INFO"])
-          headers["Cache-Control"] << ", max-age=31536000"
+          headers["Cache-Control"] += ", max-age=31536000"
 
         # Otherwise set `must-revalidate` since the asset could be modified.
         else
-          headers["Cache-Control"] << ", must-revalidate"
+          headers["Cache-Control"] += ", must-revalidate"
           headers["Vary"] = "Accept-Encoding"
         end
 

data/lib/sprockets/uglifier_compressor.rb

@@ -1,4 +1,5 @@
 require 'sprockets/autoload'
+require 'sprockets/digest_utils'
 
 module Sprockets
   # Public: Uglifier/Uglify compressor.
@@ -40,24 +41,16 @@ module Sprockets
         options[:copyright] ||= false
       else
         # Uglifier >= 2.x
-        options[:copyright] ||= :none
+        options[:comments] ||= :none
       end
 
-      @uglifier = Autoload::Uglifier.new(options)
-
-      @cache_key = [
-        self.class.name,
-        Autoload::Uglifier::VERSION,
-        VERSION,
-        options
-      ].freeze
+      @options = options
+      @cache_key = "#{self.class.name}:#{Autoload::Uglifier::VERSION}:#{VERSION}:#{DigestUtils.digest(options)}".freeze
     end
 
     def call(input)
-      data = input[:data]
-      input[:cache].fetch(@cache_key + [data]) do
-        @uglifier.compile(data)
-      end
+      @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