sprockets 3.0.0 → 4.0.2

data/lib/sprockets/sassc_compressor.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+require 'sprockets/autoload'
+require 'sprockets/source_map_utils'
+
+module Sprockets
+  # Public: Sass CSS minifier.
+  #
+  # To accept the default options
+  #
+  #     environment.register_bundle_processor 'text/css',
+  #       Sprockets::SasscCompressor
+  #
+  # Or to pass options to the Sass::Engine class.
+  #
+  #     environment.register_bundle_processor 'text/css',
+  #       Sprockets::SasscCompressor.new({ ... })
+  #
+  class SasscCompressor
+    # Public: Return singleton instance with default options.
+    #
+    # Returns SasscCompressor object.
+    def self.instance
+      @instance ||= new
+    end
+
+    def self.call(input)
+      instance.call(input)
+    end
+
+    def initialize(options = {})
+      @options = {
+        syntax: :scss,
+        style: :compressed,
+        source_map_contents: false,
+        omit_source_map_url: true,
+      }.merge(options).freeze
+    end
+
+    def call(input)
+      # SassC requires the template to be modifiable
+      input_data = input[:data].frozen? ? input[:data].dup : input[:data]
+      engine = Autoload::SassC::Engine.new(input_data, @options.merge(filename: input[:filename], source_map_file: "#{input[:filename]}.map")) 
+        
+      css = engine.render.sub(/^\n^\/\*# sourceMappingURL=.*\*\/$/m, '')
+
+      begin
+        map = SourceMapUtils.format_source_map(JSON.parse(engine.source_map), input)
+        map = SourceMapUtils.combine_source_maps(input[:metadata][:map], map)
+      rescue SassC::NotRenderedError
+        map = input[:metadata][:map]
+      end
+
+      { data: css, map: map }
+    end
+  end
+end

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 infomation 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,3 +1,5 @@
+# frozen_string_literal: true
+require 'set'
 require 'time'
 require 'rack/utils'
 
@@ -6,6 +8,9 @@ module Sprockets
   # `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
+
     # `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,7 +28,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'
+      unless ALLOWED_REQUEST_METHODS.include? env['REQUEST_METHOD']
         return method_not_allowed_response
       end
 
@@ -32,6 +37,10 @@ module Sprockets
       # Extract the path from everything after the leading slash
       path = Rack::Utils.unescape(env['PATH_INFO'].to_s.sub(/^\//, ''))
 
+      unless path.valid_encoding?
+        return bad_request_response(env)
+      end
+
       # Strip fingerprint
       if fingerprint = path_fingerprint(path)
         path = path.sub("-#{fingerprint}", '')
@@ -39,32 +48,22 @@ module Sprockets
 
       # URLs containing a `".."` are rejected for security reasons.
       if forbidden_request?(path)
-        return forbidden_response
-      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
+        return forbidden_response(env)
       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)
+
       if asset.nil?
         status = :not_found
       elsif fingerprint && asset.etag != fingerprint
@@ -86,10 +85,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 +114,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
@@ -128,22 +135,43 @@ module Sprockets
         [ 304, cache_headers(env, etag), [] ]
       end
 
+      # Returns a 400 Forbidden response tuple
+      def bad_request_response(env)
+        if head_request?(env)
+          [ 400, { "Content-Type" => "text/plain", "Content-Length" => "0" }, [] ]
+        else
+          [ 400, { "Content-Type" => "text/plain", "Content-Length" => "11" }, [ "Bad Request" ] ]
+        end
+      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
@@ -216,22 +244,17 @@ 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["Cache-Control"] = +"public"
         headers["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["Cache-Control"] << ", max-age=31536000, immutable"
 
         # Otherwise set `must-revalidate` since the asset could be modified.
         else

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 aquire 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