sprockets 3.7.3 → 4.2.2

data/lib/sprockets/sassc_processor.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+require 'rack/utils'
+require 'sprockets/autoload'
+require 'sprockets/source_map_utils'
+require 'uri'
+
+module Sprockets
+  # Processor engine class for the SASS/SCSS compiler. Depends on the `sassc` gem.
+  #
+  # For more information see:
+  #
+  #   https://github.com/sass/sassc-ruby
+  #   https://github.com/sass/sassc-rails
+  #
+  class SasscProcessor
+
+    # Internal: Defines default sass syntax to use. Exposed so the ScsscProcessor
+    # may override it.
+    def self.syntax
+      :sass
+    end
+
+    # Public: Return singleton instance with default options.
+    #
+    # Returns SasscProcessor object.
+    def self.instance
+      @instance ||= new
+    end
+
+    def self.call(input)
+      instance.call(input)
+    end
+
+    def self.cache_key
+      instance.cache_key
+    end
+
+    attr_reader :cache_key
+
+    def initialize(options = {}, &block)
+      @cache_version = options[:cache_version]
+      @cache_key = "#{self.class.name}:#{VERSION}:#{Autoload::SassC::VERSION}:#{@cache_version}".freeze
+      @importer_class = options[:importer]
+      @sass_config = options[:sass_config] || {}
+      @functions = Module.new do
+        include Functions
+        include options[:functions] if options[:functions]
+        class_eval(&block) if block_given?
+      end
+    end
+
+    def call(input)
+      context = input[:environment].context_class.new(input)
+
+      options = engine_options(input, context)
+      engine = Autoload::SassC::Engine.new(input[:data], options)
+
+      css = Utils.module_include(Autoload::SassC::Script::Functions, @functions) do
+        engine.render.sub(/^\n^\/\*# sourceMappingURL=.*\*\/$/m, '')
+      end
+
+      begin
+        map = SourceMapUtils.format_source_map(JSON.parse(engine.source_map), input)
+        map = SourceMapUtils.combine_source_maps(input[:metadata][:map], map)
+
+        engine.dependencies.each do |dependency|
+          context.metadata[:dependencies] << URIUtils.build_file_digest_uri(dependency.filename)
+        end
+      rescue SassC::NotRenderedError
+        map = input[:metadata][:map]
+      end
+
+      context.metadata.merge(data: css, map: map)
+    end
+
+    private
+
+    def merge_options(options)
+      defaults = @sass_config.dup
+
+      if load_paths = defaults.delete(:load_paths)
+        options[:load_paths] += load_paths
+      end
+
+      options.merge!(defaults)
+      options
+    end
+
+    # Public: Functions injected into Sass context during Sprockets evaluation.
+    #
+    # This module may be extended to add global functionality to all Sprockets
+    # Sass environments. Though, scoping your functions to just your environment
+    # is preferred.
+    #
+    # module Sprockets::SasscProcessor::Functions
+    #   def asset_path(path, options = {})
+    #   end
+    # end
+    #
+    module Functions
+      # Public: Generate a url for asset path.
+      #
+      # Default implementation is deprecated. Currently defaults to
+      # Context#asset_path.
+      #
+      # Will raise NotImplementedError in the future. Users should provide their
+      # own base implementation.
+      #
+      # Returns a SassC::Script::Value::String.
+      def asset_path(path, options = {})
+        path = path.value
+
+        path, _, query, fragment = URI.split(path)[5..8]
+        path     = sprockets_context.asset_path(path, options)
+        query    = "?#{query}" if query
+        fragment = "##{fragment}" if fragment
+
+        Autoload::SassC::Script::Value::String.new("#{path}#{query}#{fragment}", :string)
+      end
+
+      # Public: Generate a asset url() link.
+      #
+      # path - SassC::Script::Value::String URL path
+      #
+      # Returns a SassC::Script::Value::String.
+      def asset_url(path, options = {})
+        Autoload::SassC::Script::Value::String.new("url(#{asset_path(path, options).value})")
+      end
+
+      # Public: Generate url for image path.
+      #
+      # path - SassC::Script::Value::String URL path
+      #
+      # Returns a SassC::Script::Value::String.
+      def image_path(path)
+        asset_path(path, type: :image)
+      end
+
+      # Public: Generate a image url() link.
+      #
+      # path - SassC::Script::Value::String URL path
+      #
+      # Returns a SassC::Script::Value::String.
+      def image_url(path)
+        asset_url(path, type: :image)
+      end
+
+      # Public: Generate url for video path.
+      #
+      # path - SassC::Script::Value::String URL path
+      #
+      # Returns a SassC::Script::Value::String.
+      def video_path(path)
+        asset_path(path, type: :video)
+      end
+
+      # Public: Generate a video url() link.
+      #
+      # path - SassC::Script::Value::String URL path
+      #
+      # Returns a SassC::Script::Value::String.
+      def video_url(path)
+        asset_url(path, type: :video)
+      end
+
+      # Public: Generate url for audio path.
+      #
+      # path - SassC::Script::Value::String URL path
+      #
+      # Returns a SassC::Script::Value::String.
+      def audio_path(path)
+        asset_path(path, type: :audio)
+      end
+
+      # Public: Generate a audio url() link.
+      #
+      # path - SassC::Script::Value::String URL path
+      #
+      # Returns a SassC::Script::Value::String.
+      def audio_url(path)
+        asset_url(path, type: :audio)
+      end
+
+      # Public: Generate url for font path.
+      #
+      # path - SassC::Script::Value::String URL path
+      #
+      # Returns a SassC::Script::Value::String.
+      def font_path(path)
+        asset_path(path, type: :font)
+      end
+
+      # Public: Generate a font url() link.
+      #
+      # path - SassC::Script::Value::String URL path
+      #
+      # Returns a SassC::Script::Value::String.
+      def font_url(path)
+        asset_url(path, type: :font)
+      end
+
+      # Public: Generate url for javascript path.
+      #
+      # path - SassC::Script::Value::String URL path
+      #
+      # Returns a SassC::Script::Value::String.
+      def javascript_path(path)
+        asset_path(path, type: :javascript)
+      end
+
+      # Public: Generate a javascript url() link.
+      #
+      # path - SassC::Script::Value::String URL path
+      #
+      # Returns a SassC::Script::Value::String.
+      def javascript_url(path)
+        asset_url(path, type: :javascript)
+      end
+
+      # Public: Generate url for stylesheet path.
+      #
+      # path - SassC::Script::Value::String URL path
+      #
+      # Returns a SassC::Script::Value::String.
+      def stylesheet_path(path)
+        asset_path(path, type: :stylesheet)
+      end
+
+      # Public: Generate a stylesheet url() link.
+      #
+      # path - SassC::Script::Value::String URL path
+      #
+      # Returns a SassC::Script::Value::String.
+      def stylesheet_url(path)
+        asset_url(path, type: :stylesheet)
+      end
+
+      # Public: Generate a data URI for asset path.
+      #
+      # path - SassC::Script::Value::String logical asset path
+      #
+      # Returns a SassC::Script::Value::String.
+      def asset_data_url(path)
+        url = sprockets_context.asset_data_uri(path.value)
+        Autoload::SassC::Script::Value::String.new("url(" + url + ")")
+      end
+
+      protected
+        # Public: The Environment.
+        #
+        # Returns Sprockets::Environment.
+        def sprockets_environment
+          options[:sprockets][:environment]
+        end
+
+        # Public: Mutatable set of dependencies.
+        #
+        # Returns a Set.
+        def sprockets_dependencies
+          options[:sprockets][:dependencies]
+        end
+
+        # Deprecated: Get the Context instance. Use APIs on
+        # sprockets_environment or sprockets_dependencies directly.
+        #
+        # Returns a Context instance.
+        def sprockets_context
+          options[:sprockets][:context]
+        end
+
+    end
+
+    def engine_options(input, context)
+      merge_options({
+        filename: input[:filename],
+        syntax: self.class.syntax,
+        load_paths: input[:environment].paths,
+        importer: @importer_class,
+        source_map_contents: false,
+        source_map_file: "#{input[:filename]}.map",
+        omit_source_map_url: true,
+        sprockets: {
+          context: context,
+          environment: input[:environment],
+          dependencies: context.metadata[:dependencies]
+        }
+      })
+    end
+  end
+
+
+  class ScsscProcessor < SasscProcessor
+    def self.syntax
+      :scss
+    end
+  end
+end

data/lib/sprockets/server.rb

@@ -1,11 +1,26 @@
+# frozen_string_literal: true
+require 'set'
 require 'time'
-require 'rack/utils'
+require 'rack'
 
 module Sprockets
   # `Server` is a concern mixed into `Environment` and
   # `CachedEnvironment` that provides a Rack compatible `call`
   # interface and url generation helpers.
   module Server
+    # Supported HTTP request methods.
+    ALLOWED_REQUEST_METHODS = ['GET', 'HEAD'].to_set.freeze
+
+    # :stopdoc:
+    if Gem::Version.new(Rack::RELEASE) < Gem::Version.new("3")
+      X_CASCADE = "X-Cascade"
+      VARY = "Vary"
+    else
+      X_CASCADE = "x-cascade"
+      VARY = "vary"
+    end
+    # :startdoc:
+
     # `call` implements the Rack 1.x specification which accepts an
     # `env` Hash and returns a three item tuple with the status code,
     # headers, and body.
@@ -23,14 +38,19 @@ module Sprockets
       start_time = Time.now.to_f
       time_elapsed = lambda { ((Time.now.to_f - start_time) * 1000).to_i }
 
-      if !['GET', 'HEAD'].include?(env['REQUEST_METHOD'])
+      unless ALLOWED_REQUEST_METHODS.include? env['REQUEST_METHOD']
         return method_not_allowed_response
       end
 
       msg = "Served asset #{env['PATH_INFO']} -"
 
       # Extract the path from everything after the leading slash
-      path = Rack::Utils.unescape(env['PATH_INFO'].to_s.sub(/^\//, ''))
+      full_path = Rack::Utils.unescape(env['PATH_INFO'].to_s.sub(/^\//, ''))
+      path = full_path
+
+      unless path.valid_encoding?
+        return bad_request_response(env)
+      end
 
       # Strip fingerprint
       if fingerprint = path_fingerprint(path)
@@ -42,27 +62,26 @@ module Sprockets
         return forbidden_response(env)
       end
 
-      # Look up the asset.
-      options = {}
-      options[:pipeline] = :self if body_only?(env)
-
-      asset = find_asset(path, options)
-
-      # 2.x/3.x compatibility hack. Just ignore fingerprints on ?body=1 requests.
-      # 3.x/4.x prefers strong validation of fingerprint to body contents, but
-      # 2.x just ignored it.
-      if asset && parse_asset_uri(asset.uri)[1][:pipeline] == "self"
-        fingerprint = nil
-      end
-
       if fingerprint
         if_match = fingerprint
       elsif env['HTTP_IF_MATCH']
-        if_match = env['HTTP_IF_MATCH'][/^"(\w+)"$/, 1]
+        if_match = env['HTTP_IF_MATCH'][/"(\w+)"$/, 1]
       end
 
       if env['HTTP_IF_NONE_MATCH']
-        if_none_match = env['HTTP_IF_NONE_MATCH'][/^"(\w+)"$/, 1]
+        if_none_match = env['HTTP_IF_NONE_MATCH'][/"(\w+)"$/, 1]
+      end
+
+      # Look up the asset.
+      asset = find_asset(path)
+
+      # Fallback to looking up the asset with the full path.
+      # This will make assets that are hashed with webpack or
+      # other js bundlers work consistently between production
+      # and development pipelines.
+      if asset.nil? && (asset = find_asset(full_path))
+        if_match = asset.etag if fingerprint
+        fingerprint = asset.etag
       end
 
       if asset.nil?
@@ -136,33 +155,42 @@ module Sprockets
         [ 304, cache_headers(env, etag), [] ]
       end
 
+      # Returns a 400 Forbidden response tuple
+      def bad_request_response(env)
+        if head_request?(env)
+          [ 400, { Rack::CONTENT_TYPE => "text/plain", Rack::CONTENT_LENGTH => "0" }, [] ]
+        else
+          [ 400, { Rack::CONTENT_TYPE => "text/plain", Rack::CONTENT_LENGTH => "11" }, [ "Bad Request" ] ]
+        end
+      end
+
       # Returns a 403 Forbidden response tuple
       def forbidden_response(env)
         if head_request?(env)
-          [ 403, { "Content-Type" => "text/plain", "Content-Length" => "0" }, [] ]
+          [ 403, { Rack::CONTENT_TYPE => "text/plain", Rack::CONTENT_LENGTH => "0" }, [] ]
         else
-          [ 403, { "Content-Type" => "text/plain", "Content-Length" => "9" }, [ "Forbidden" ] ]
+          [ 403, { Rack::CONTENT_TYPE => "text/plain", Rack::CONTENT_LENGTH => "9" }, [ "Forbidden" ] ]
         end
       end
 
       # Returns a 404 Not Found response tuple
       def not_found_response(env)
         if head_request?(env)
-          [ 404, { "Content-Type" => "text/plain", "Content-Length" => "0", "X-Cascade" => "pass" }, [] ]
+          [ 404, { Rack::CONTENT_TYPE => "text/plain", Rack::CONTENT_LENGTH => "0", X_CASCADE => "pass" }, [] ]
         else
-          [ 404, { "Content-Type" => "text/plain", "Content-Length" => "9", "X-Cascade" => "pass" }, [ "Not found" ] ]
+          [ 404, { Rack::CONTENT_TYPE => "text/plain", Rack::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" ] ]
+        [ 405, { Rack::CONTENT_TYPE => "text/plain", Rack::CONTENT_LENGTH => "18" }, [ "Method Not Allowed" ] ]
       end
 
       def precondition_failed_response(env)
         if head_request?(env)
-          [ 412, { "Content-Type" => "text/plain", "Content-Length" => "0", "X-Cascade" => "pass" }, [] ]
+          [ 412, { Rack::CONTENT_TYPE => "text/plain", Rack::CONTENT_LENGTH => "0", X_CASCADE => "pass" }, [] ]
         else
-          [ 412, { "Content-Type" => "text/plain", "Content-Length" => "19", "X-Cascade" => "pass" }, [ "Precondition Failed" ] ]
+          [ 412, { Rack::CONTENT_TYPE => "text/plain", Rack::CONTENT_LENGTH => "19", X_CASCADE => "pass" }, [ "Precondition Failed" ] ]
         end
       end
 
@@ -171,7 +199,7 @@ module Sprockets
       def javascript_exception_response(exception)
         err  = "#{exception.class.name}: #{exception.message}\n  (in #{exception.backtrace[0]})"
         body = "throw Error(#{err.inspect})"
-        [ 200, { "Content-Type" => "application/javascript", "Content-Length" => body.bytesize.to_s }, [ body ] ]
+        [ 200, { Rack::CONTENT_TYPE => "application/javascript", Rack::CONTENT_LENGTH => body.bytesize.to_s }, [ body ] ]
       end
 
       # Returns a CSS response that hides all elements on the page and
@@ -224,7 +252,7 @@ module Sprockets
           }
         CSS
 
-        [ 200, { "Content-Type" => "text/css; charset=utf-8", "Content-Length" => body.bytesize.to_s }, [ body ] ]
+        [ 200, { Rack::CONTENT_TYPE => "text/css; charset=utf-8", Rack::CONTENT_LENGTH => body.bytesize.to_s }, [ body ] ]
       end
 
       # Escape special characters for use inside a CSS content("...") string
@@ -236,27 +264,22 @@ module Sprockets
           gsub('/',  '\\\\002f ')
       end
 
-      # Test if `?body=1` or `body=true` query param is set
-      def body_only?(env)
-        env["QUERY_STRING"].to_s =~ /body=(1|t)/
-      end
-
       def cache_headers(env, etag)
         headers = {}
 
         # Set caching headers
-        headers["Cache-Control"] = "public"
-        headers["ETag"]          = %("#{etag}")
+        headers[Rack::CACHE_CONTROL] = +"public"
+        headers[Rack::ETAG]          = %("#{etag}")
 
         # 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[Rack::CACHE_CONTROL] << ", max-age=31536000, immutable"
 
         # Otherwise set `must-revalidate` since the asset could be modified.
         else
-          headers["Cache-Control"] += ", must-revalidate"
-          headers["Vary"] = "Accept-Encoding"
+          headers[Rack::CACHE_CONTROL] << ", must-revalidate"
+          headers[VARY] = "Accept-Encoding"
         end
 
         headers
@@ -266,7 +289,7 @@ module Sprockets
         headers = {}
 
         # Set content length header
-        headers["Content-Length"] = length.to_s
+        headers[Rack::CONTENT_LENGTH] = length.to_s
 
         # Set content type header
         if type = asset.content_type
@@ -274,7 +297,7 @@ module Sprockets
           if type.start_with?("text/") && asset.charset
             type += "; charset=#{asset.charset}"
           end
-          headers["Content-Type"] = type
+          headers[Rack::CONTENT_TYPE] = type
         end
 
         headers.merge(cache_headers(env, asset.etag))
@@ -286,7 +309,7 @@ module Sprockets
       #     # => "0aa2105d29558f3eb790d411d7d8fb66"
       #
       def path_fingerprint(path)
-        path[/-([0-9a-f]{7,128})\.[^.]+\z/, 1]
+        path[/-([0-9a-zA-Z]{7,128})\.[^.]+\z/, 1]
       end
   end
 end

data/lib/sprockets/source_map_processor.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+require 'set'
+
+module Sprockets
+
+  # The purpose of this class is to generate a source map file
+  # that can be read and understood by browsers.
+  #
+  # When a file is passed in it will have a `application/js-sourcemap+json`
+  # or `application/css-sourcemap+json` mime type. The filename will be
+  # match the original asset. The original asset is loaded. As it
+  # gets processed by Sprockets it will acquire all information
+  # needed to build a source map file in the `asset.to_hash[:metadata][:map]`
+  # key.
+  #
+  # The output is an asset with a properly formatted source map file:
+  #
+  #   {
+  #     "version": 3,
+  #     "sources": ["foo.js"],
+  #     "names":   [ ],
+  #     "mappings": "AAAA,GAAIA"
+  #   }
+  #
+  class SourceMapProcessor
+    def self.call(input)
+      links = Set.new(input[:metadata][:links])
+      env = input[:environment]
+
+      uri, _ = env.resolve!(input[:filename], accept: self.original_content_type(input[:content_type]))
+      asset  = env.load(uri)
+      map    = asset.metadata[:map]
+
+      # TODO: Because of the default piplene hack we have to apply dependencies
+      #       from compiled asset to the source map, otherwise the source map cache
+      #       will never detect the changes from directives
+      dependencies = Set.new(input[:metadata][:dependencies])
+      dependencies.merge(asset.metadata[:dependencies])
+
+      map["file"] = PathUtils.split_subpath(input[:load_path], input[:filename])
+      sources = map["sections"] ? map["sections"].map { |s| s["map"]["sources"] }.flatten : map["sources"]
+
+      sources.each do |source|
+        source = PathUtils.join(File.dirname(map["file"]), source)
+        uri, _ = env.resolve!(source)
+        links << uri
+      end
+
+      json = JSON.generate(map)
+
+      { data: json, links: links, dependencies: dependencies }
+    end
+
+    def self.original_content_type(source_map_content_type, error_when_not_found: true)
+      case source_map_content_type
+      when "application/js-sourcemap+json"
+        "application/javascript"
+      when "application/css-sourcemap+json"
+        "text/css"
+      else
+        fail(source_map_content_type) if error_when_not_found
+        source_map_content_type
+      end
+    end
+  end
+end