sprockets 4.0.1

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

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+require 'set'
+require 'time'
+require 'rack/utils'
+
+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
+
+    # `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.
+    #
+    # Mapping your environment at a url prefix will serve all assets
+    # in the path.
+    #
+    #     map "/assets" do
+    #       run Sprockets::Environment.new
+    #     end
+    #
+    # A request for `"/assets/foo/bar.js"` will search your
+    # environment for `"foo/bar.js"`.
+    def call(env)
+      start_time = Time.now.to_f
+      time_elapsed = lambda { ((Time.now.to_f - start_time) * 1000).to_i }
+
+      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(/^\//, ''))
+
+      unless path.valid_encoding?
+        return bad_request_response(env)
+      end
+
+      # Strip fingerprint
+      if fingerprint = path_fingerprint(path)
+        path = path.sub("-#{fingerprint}", '')
+      end
+
+      # URLs containing a `".."` are rejected for security reasons.
+      if forbidden_request?(path)
+        return forbidden_response(env)
+      end
+
+      if fingerprint
+        if_match = fingerprint
+      elsif env['HTTP_IF_MATCH']
+        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]
+      end
+
+      # Look up the asset.
+      asset = find_asset(path)
+
+      if asset.nil?
+        status = :not_found
+      elsif fingerprint && asset.etag != fingerprint
+        status = :not_found
+      elsif if_match && asset.etag != if_match
+        status = :precondition_failed
+      elsif if_none_match && asset.etag == if_none_match
+        status = :not_modified
+      else
+        status = :ok
+      end
+
+      case status
+      when :ok
+        logger.info "#{msg} 200 OK (#{time_elapsed.call}ms)"
+        ok_response(asset, env)
+      when :not_modified
+        logger.info "#{msg} 304 Not Modified (#{time_elapsed.call}ms)"
+        not_modified_response(env, if_none_match)
+      when :not_found
+        logger.info "#{msg} 404 Not Found (#{time_elapsed.call}ms)"
+        not_found_response(env)
+      when :precondition_failed
+        logger.info "#{msg} 412 Precondition Failed (#{time_elapsed.call}ms)"
+        precondition_failed_response(env)
+      end
+    rescue Exception => e
+      logger.error "Error compiling asset #{path}:"
+      logger.error "#{e.class.name}: #{e.message}"
+
+      case File.extname(path)
+      when ".js"
+        # Re-throw JavaScript asset exceptions to the browser
+        logger.info "#{msg} 500 Internal Server Error\n\n"
+        return javascript_exception_response(e)
+      when ".css"
+        # Display CSS asset exceptions in the browser
+        logger.info "#{msg} 500 Internal Server Error\n\n"
+        return css_exception_response(e)
+      else
+        raise
+      end
+    end
+
+    private
+      def forbidden_request?(path)
+        # Prevent access to files elsewhere on the file system
+        #
+        #     http://example.org/assets/../../../etc/passwd
+        #
+        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)
+        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
+      def not_modified_response(env, etag)
+        [ 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(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(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(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
+      # in the browser
+      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 ] ]
+      end
+
+      # Returns a CSS response that hides all elements on the page and
+      # displays the exception
+      def css_exception_response(exception)
+        message   = "\n#{exception.class.name}: #{exception.message}"
+        backtrace = "\n  #{exception.backtrace.first}"
+
+        body = <<-CSS
+          html {
+            padding: 18px 36px;
+          }
+
+          head {
+            display: block;
+          }
+
+          body {
+            margin: 0;
+            padding: 0;
+          }
+
+          body > * {
+            display: none !important;
+          }
+
+          head:after, body:before, body:after {
+            display: block !important;
+          }
+
+          head:after {
+            font-family: sans-serif;
+            font-size: large;
+            font-weight: bold;
+            content: "Error compiling CSS asset";
+          }
+
+          body:before, body:after {
+            font-family: monospace;
+            white-space: pre-wrap;
+          }
+
+          body:before {
+            font-weight: bold;
+            content: "#{escape_css_content(message)}";
+          }
+
+          body:after {
+            content: "#{escape_css_content(backtrace)}";
+          }
+        CSS
+
+        [ 200, { "Content-Type" => "text/css; charset=utf-8", "Content-Length" => body.bytesize.to_s }, [ body ] ]
+      end
+
+      # Escape special characters for use inside a CSS content("...") string
+      def escape_css_content(content)
+        content.
+          gsub('\\', '\\\\005c ').
+          gsub("\n", '\\\\000a ').
+          gsub('"',  '\\\\0022 ').
+          gsub('/',  '\\\\002f ')
+      end
+
+      def cache_headers(env, etag)
+        headers = {}
+
+        # Set caching headers
+        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, immutable"
+
+        # Otherwise set `must-revalidate` since the asset could be modified.
+        else
+          headers["Cache-Control"] << ", must-revalidate"
+          headers["Vary"] = "Accept-Encoding"
+        end
+
+        headers
+      end
+
+      def headers(env, asset, length)
+        headers = {}
+
+        # Set content length header
+        headers["Content-Length"] = length.to_s
+
+        # Set content type header
+        if type = asset.content_type
+          # Set charset param for text/* mime types
+          if type.start_with?("text/") && asset.charset
+            type += "; charset=#{asset.charset}"
+          end
+          headers["Content-Type"] = type
+        end
+
+        headers.merge(cache_headers(env, asset.etag))
+      end
+
+      # Gets ETag fingerprint.
+      #
+      #     "foo-0aa2105d29558f3eb790d411d7d8fb66.js"
+      #     # => "0aa2105d29558f3eb790d411d7d8fb66"
+      #
+      def path_fingerprint(path)
+        path[/-([0-9a-f]{7,128})\.[^.]+\z/, 1]
+      end
+  end
+end