sprockets 3.7.3 → 4.0.0.beta1

data/lib/sprockets/sass_compressor.rb

@@ -1,5 +1,6 @@
 require 'sprockets/autoload'
 require 'sprockets/digest_utils'
+require 'sprockets/source_map_utils'
 
 module Sprockets
   # Public: Sass CSS minifier.
@@ -45,7 +46,19 @@ module Sprockets
     end
 
     def call(input)
-      Autoload::Sass::Engine.new(input[:data], @options).render
+      css, map = Autoload::Sass::Engine.new(
+        input[:data],
+        @options.merge(filename: 'filename')
+      ).render_with_sourcemap('')
+
+      css = css.sub("/*# sourceMappingURL= */\n", '')
+
+      map = SourceMapUtils.combine_source_maps(
+        input[:metadata][:map],
+        SourceMapUtils.decode_json_source_map(map.to_json(css_uri: 'uri'))["mappings"]
+      )
+
+      { data: css, map: map }
     end
   end
 end

data/lib/sprockets/sass_processor.rb

@@ -1,5 +1,6 @@
 require 'rack/utils'
 require 'sprockets/autoload'
+require 'sprockets/source_map_utils'
 require 'uri'
 
 module Sprockets
@@ -45,7 +46,8 @@ module Sprockets
     def initialize(options = {}, &block)
       @cache_version = options[:cache_version]
       @cache_key = "#{self.class.name}:#{VERSION}:#{Autoload::Sass::VERSION}:#{@cache_version}".freeze
-
+      @importer_class = options[:importer] || Sass::Importers::Filesystem
+      @sass_config = options[:sass_config] || {}
       @functions = Module.new do
         include Functions
         include options[:functions] if options[:functions]
@@ -56,24 +58,32 @@ module Sprockets
     def call(input)
       context = input[:environment].context_class.new(input)
 
-      options = {
+      engine_options = {
         filename: input[:filename],
         syntax: self.class.syntax,
         cache_store: build_cache_store(input, @cache_version),
-        load_paths: input[:environment].paths,
+        load_paths: context.environment.paths.map { |p| @importer_class.new(p.to_s) },
+        importer: @importer_class.new(Pathname.new(context.filename).to_s),
         sprockets: {
           context: context,
           environment: input[:environment],
           dependencies: context.metadata[:dependencies]
         }
-      }
+      }.merge!(@sass_config)
 
-      engine = Autoload::Sass::Engine.new(input[:data], options)
+      engine = Autoload::Sass::Engine.new(input[:data], engine_options)
 
-      css = Utils.module_include(Autoload::Sass::Script::Functions, @functions) do
-        engine.render
+      css, map = Utils.module_include(Autoload::Sass::Script::Functions, @functions) do
+        engine.render_with_sourcemap('')
       end
 
+      css = css.sub("\n/*# sourceMappingURL= */\n", '')
+
+      map = SourceMapUtils.combine_source_maps(
+        input[:metadata][:map],
+        SourceMapUtils.decode_json_source_map(map.to_json(css_uri: '', type: :inline))["mappings"]
+      )
+
       # Track all imported files
       sass_dependencies = Set.new([input[:filename]])
       engine.dependencies.map do |dependency|
@@ -81,7 +91,7 @@ module Sprockets
         context.metadata[:dependencies] << URIUtils.build_file_digest_uri(dependency.options[:filename])
       end
 
-      context.metadata.merge(data: css, sass_dependencies: sass_dependencies)
+      context.metadata.merge(data: css, sass_dependencies: sass_dependencies, map: map)
     end
 
     # Public: Build the cache store to be used by the Sass engine.

data/lib/sprockets/sassc_compressor.rb

@@ -0,0 +1,30 @@
+require 'sprockets/autoload'
+require 'sprockets/sass_compressor'
+require 'base64'
+
+module Sprockets
+  class SasscCompressor < SassCompressor
+    def initialize(options = {})
+      @options = {
+        syntax: :scss,
+        style: :compressed,
+        source_map_embed: true,
+        source_map_file: '.'
+      }.merge(options).freeze
+    end
+
+    def call(input)
+      data = Autoload::SassC::Engine.new(input[:data], @options.merge(filename: 'filename')).render
+
+      match_data = data.match(/(.*)\n\/\*# sourceMappingURL=data:application\/json;base64,(.+) \*\//m)
+      css, map = match_data[1], Base64.decode64(match_data[2])
+
+      map = SourceMapUtils.combine_source_maps(
+        input[:metadata][:map],
+        SourceMapUtils.decode_json_source_map(map)["mappings"]
+      )
+
+      { data: css, map: map }
+    end
+  end
+end

data/lib/sprockets/sassc_processor.rb

@@ -0,0 +1,68 @@
+require 'sprockets/sass_processor'
+require 'base64'
+
+module Sprockets
+  class SasscProcessor < SassProcessor
+    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 SassProcessor::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)
+
+      data = Utils.module_include(Autoload::SassC::Script::Functions, @functions) do
+        engine.render
+      end
+
+      match_data = data.match(/(.*)\n\/\*# sourceMappingURL=data:application\/json;base64,(.+) \*\//m)
+      css, map = match_data[1], Base64.decode64(match_data[2])
+
+      map = SourceMapUtils.combine_source_maps(
+        input[:metadata][:map],
+        change_source(SourceMapUtils.decode_json_source_map(map)["mappings"], input[:source_path])
+      )
+
+      context.metadata.merge(data: css, map: map)
+    end
+
+    private
+
+    def change_source(mappings, source)
+      mappings.each { |m| m[:source] = source }
+    end
+
+    def engine_options(input, context)
+      {
+        filename: input[:filename],
+        syntax: self.class.syntax,
+        load_paths: input[:environment].paths,
+        importer: @importer_class,
+        source_map_embed: true,
+        source_map_file: '.',
+        sprockets: {
+          context: context,
+          environment: input[:environment],
+          dependencies: context.metadata[:dependencies]
+        }
+      }.merge!(@sass_config)
+    end
+  end
+
+
+  class ScsscProcessor < SasscProcessor
+    def self.syntax
+      :scss
+    end
+  end
+end

data/lib/sprockets/server.rb

@@ -1,3 +1,4 @@
+require 'set'
 require 'time'
 require 'rack/utils'
 
@@ -6,6 +7,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 +27,7 @@ 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
 
@@ -42,19 +46,6 @@ 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']
@@ -65,6 +56,9 @@ module Sprockets
         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
@@ -115,7 +109,7 @@ module Sprockets
         #
         #     http://example.org/assets/../../../etc/passwd
         #
-        path.include?("..") || absolute_path?(path) || path.include?("://")
+        path.include?("..") || absolute_path?(path)
       end
 
       def head_request?(env)
@@ -236,11 +230,6 @@ 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 = {}
 
@@ -251,11 +240,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/source_map_comment_processor.rb

@@ -0,0 +1,29 @@
+module Sprockets
+  class SourceMapCommentProcessor
+    def self.call(input)
+      case input[:content_type]
+      when "application/javascript"
+        comment = "\n//# sourceMappingURL=%s"
+        map_type = "application/js-sourcemap+json"
+      when "text/css"
+        comment = "\n/*# sourceMappingURL=%s */"
+        map_type = "application/css-sourcemap+json"
+      else
+        fail input[:content_type]
+      end
+
+      env = input[:environment]
+
+      uri, _ = env.resolve!(input[:filename], accept: input[:content_type])
+      asset = env.load(uri)
+
+      uri, _ = env.resolve!(input[:filename], accept: map_type)
+      map = env.load(uri)
+
+      asset.metadata.merge(
+        data: asset.source + (comment % map.digest_path),
+        links: asset.links + [asset.uri, map.uri]
+      )
+    end
+  end
+end

data/lib/sprockets/source_map_processor.rb

@@ -0,0 +1,40 @@
+require 'set'
+
+module Sprockets
+  class SourceMapProcessor
+    def self.call(input)
+      case input[:content_type]
+      when "application/js-sourcemap+json"
+        accept = "application/javascript"
+      when "application/css-sourcemap+json"
+        accept = "text/css"
+      else
+        fail input[:content_type]
+      end
+
+      links = Set.new(input[:metadata][:links])
+
+      env = input[:environment]
+
+      uri, _ = env.resolve!(input[:filename], accept: accept)
+      asset  = env.load(uri)
+      map    = asset.metadata[:map] || []
+
+      map.map { |m| m[:source] }.uniq.compact.each do |source|
+        # TODO: Resolve should expect fingerprints
+        fingerprint = source[/-([0-9a-f]{7,128})\.[^.]+\z/, 1]
+        if fingerprint
+          path = source.sub("-#{fingerprint}", "")
+        else
+          path = source
+        end
+        uri, _ = env.resolve!(path)
+        links << env.load(uri).uri
+      end
+
+      json = env.encode_json_source_map(map, filename: asset.logical_path)
+
+      { data: json, links: links }
+    end
+  end
+end

data/lib/sprockets/source_map_utils.rb

@@ -0,0 +1,345 @@
+require 'json'
+
+module Sprockets
+  module SourceMapUtils
+    extend self
+
+    # Public: Concatenate two source maps.
+    #
+    # For an example, if two js scripts are concatenated, the individual source
+    # maps for those files can be concatenated to map back to the originals.
+    #
+    # Examples
+    #
+    #     script3 = "#{script1}#{script2}"
+    #     map3    = concat_source_maps(map1, map2)
+    #
+    # a - Array of source mapping Hashes
+    # b - Array of source mapping Hashes
+    #
+    # Returns a new Array of source mapping Hashes.
+    def concat_source_maps(a, b)
+      a ||= []
+      b ||= []
+      mappings = a.dup
+
+      if a.any?
+        offset = a.last[:generated][0]
+      else
+        offset = 0
+      end
+
+      b.each do |m|
+        mappings << m.merge(generated: [m[:generated][0] + offset, m[:generated][1]])
+      end
+      mappings
+    end
+
+    # Public: Combine two seperate source map transformations into a single
+    # mapping.
+    #
+    # Source transformations may happen in discrete steps producing separate
+    # source maps. These steps can be combined into a single mapping back to
+    # the source.
+    #
+    # For an example, CoffeeScript may transform a file producing a map. Then
+    # Uglifier processes the result and produces another map. The CoffeeScript
+    # map can be combined with the Uglifier map so the source lines of the
+    # minified output can be traced back to the original CoffeeScript file.
+    #
+    #   original_map = [{ :source => "index.coffee", :generated => [2, 0], :original => [1, 0] }]
+    #   second_map   = [{ :source => "index.js",     :generated => [1, 1], :original => [2, 0] }]
+    #   combine_source_maps(original_map, second_map)
+    #     # => [{:source=>"index.coffee", :generated => [1, 1], :original => [1, 0]}]
+    #
+    # Returns a new Array of source mapping Hashes.
+    def combine_source_maps(original_map, second_map)
+      original_map ||= []
+      return second_map.dup if original_map.empty?
+
+      new_map = []
+
+      second_map.each do |m|
+        original_line = bsearch_mappings(original_map, m[:original])
+        next unless original_line
+        new_map << original_line.merge(generated: m[:generated])
+      end
+
+      new_map
+    end
+
+    # Public: Compare two source map offsets.
+    #
+    # Compatible with Array#sort.
+    #
+    # a - Array [line, column]
+    # b - Array [line, column]
+    #
+    # Returns -1 if a < b, 0 if a == b and 1 if a > b.
+    def compare_source_offsets(a, b)
+      diff = a[0] - b[0]
+      diff = a[1] - b[1] if diff == 0
+
+      if diff < 0
+        -1
+      elsif diff > 0
+        1
+      else
+        0
+      end
+    end
+
+    # Public: Search Array of mappings for closest offset.
+    #
+    # mappings - Array of mapping Hash objects
+    # offset  - Array [line, column]
+    #
+    # Returns mapping Hash object.
+    def bsearch_mappings(mappings, offset, from = 0, to = mappings.size - 1)
+      mid = (from + to) / 2
+
+      if from > to
+        return from < 1 ? nil : mappings[from-1]
+      end
+
+      case compare_source_offsets(offset, mappings[mid][:generated])
+      when 0
+        mappings[mid]
+      when -1
+        bsearch_mappings(mappings, offset, from, mid - 1)
+      when 1
+        bsearch_mappings(mappings, offset, mid + 1, to)
+      end
+    end
+
+    # Public: Decode Source Map JSON into Ruby objects.
+    #
+    # json - String source map JSON
+    #
+    # Returns Hash.
+    def decode_json_source_map(json)
+      map = JSON.parse(json)
+      map['mappings'] = decode_vlq_mappings(map['mappings'], sources: map['sources'], names: map['names'])
+      map
+    end
+
+    # Public: Encode mappings to Source Map JSON.
+    #
+    # mappings - Array of Hash or String VLQ encoded mappings
+    # sources  - Array of String sources
+    # names    - Array of String names
+    # filename - String filename
+    #
+    # Returns JSON String.
+    def encode_json_source_map(mappings, sources: nil, names: nil, filename: nil)
+      case mappings
+      when String
+      when Array
+        sources ||= mappings.map { |m| m[:source] }.uniq.compact
+        names   ||= mappings.map { |m| m[:name] }.uniq.compact
+        mappings = encode_vlq_mappings(mappings, sources: sources, names: names)
+      else
+        raise TypeError, "could not encode mappings: #{mappings}"
+      end
+
+      JSON.generate({
+        "version"   => 3,
+        "file"      => filename,
+        "mappings"  => mappings,
+        "sources"   => sources,
+        "names"     => names
+      })
+    end
+
+    # Public: Decode VLQ mappings and match up sources and symbol names.
+    #
+    # str     - VLQ string from 'mappings' attribute
+    # sources - Array of Strings from 'sources' attribute
+    # names   - Array of Strings from 'names' attribute
+    #
+    # Returns an Array of Mappings.
+    def decode_vlq_mappings(str, sources: [], names: [])
+      mappings = []
+
+      source_id       = 0
+      original_line   = 1
+      original_column = 0
+      name_id         = 0
+
+      vlq_decode_mappings(str).each_with_index do |group, index|
+        generated_column = 0
+        generated_line   = index + 1
+
+        group.each do |segment|
+          generated_column += segment[0]
+          generated = [generated_line, generated_column]
+
+          if segment.size >= 4
+            source_id        += segment[1]
+            original_line    += segment[2]
+            original_column  += segment[3]
+
+            source   = sources[source_id]
+            original = [original_line, original_column]
+          else
+            # TODO: Research this case
+            next
+          end
+
+          if segment[4]
+            name_id += segment[4]
+            name     = names[name_id]
+          end
+
+          mapping = {source: source, generated: generated, original: original}
+          mapping[:name] = name if name
+          mappings << mapping
+        end
+      end
+
+      mappings
+    end
+
+    # Public: Encode mappings Hash into a VLQ encoded String.
+    #
+    # mappings - Array of Hash mapping objects
+    # sources  - Array of String sources (default: mappings source order)
+    # names    - Array of String names (default: mappings name order)
+    #
+    # Returns a VLQ encoded String.
+    def encode_vlq_mappings(mappings, sources: nil, names: nil)
+      sources ||= mappings.map { |m| m[:source] }.uniq.compact
+      names   ||= mappings.map { |m| m[:name] }.uniq.compact
+
+      sources_index = Hash[sources.each_with_index.to_a]
+      names_index   = Hash[names.each_with_index.to_a]
+
+      source_id     = 0
+      source_line   = 1
+      source_column = 0
+      name_id       = 0
+
+      by_lines = mappings.group_by { |m| m[:generated][0] }
+
+      ary = (1..(by_lines.keys.max || 1)).map do |line|
+        generated_column = 0
+
+        (by_lines[line] || []).map do |mapping|
+          group = []
+          group << mapping[:generated][1] - generated_column
+          group << sources_index[mapping[:source]] - source_id
+          group << mapping[:original][0] - source_line
+          group << mapping[:original][1] - source_column
+          group << names_index[mapping[:name]] - name_id if mapping[:name]
+
+          generated_column = mapping[:generated][1]
+          source_id        = sources_index[mapping[:source]]
+          source_line      = mapping[:original][0]
+          source_column    = mapping[:original][1]
+          name_id          = names_index[mapping[:name]] if mapping[:name]
+
+          group
+        end
+      end
+
+      vlq_encode_mappings(ary)
+    end
+
+    # Public: Base64 VLQ encoding
+    #
+    # Adopted from ConradIrwin/ruby-source_map
+    #   https://github.com/ConradIrwin/ruby-source_map/blob/master/lib/source_map/vlq.rb
+    #
+    # Resources
+    #
+    #   http://en.wikipedia.org/wiki/Variable-length_quantity
+    #   https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
+    #   https://github.com/mozilla/source-map/blob/master/lib/source-map/base64-vlq.js
+    #
+    VLQ_BASE_SHIFT = 5
+    VLQ_BASE = 1 << VLQ_BASE_SHIFT
+    VLQ_BASE_MASK = VLQ_BASE - 1
+    VLQ_CONTINUATION_BIT = VLQ_BASE
+
+    BASE64_DIGITS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('')
+    BASE64_VALUES = (0...64).inject({}) { |h, i| h[BASE64_DIGITS[i]] = i; h }
+
+    # Public: Encode a list of numbers into a compact VLQ string.
+    #
+    # ary - An Array of Integers
+    #
+    # Returns a VLQ String.
+    def vlq_encode(ary)
+      result = []
+      ary.each do |n|
+        vlq = n < 0 ? ((-n) << 1) + 1 : n << 1
+        loop do
+          digit  = vlq & VLQ_BASE_MASK
+          vlq  >>= VLQ_BASE_SHIFT
+          digit |= VLQ_CONTINUATION_BIT if vlq > 0
+          result << BASE64_DIGITS[digit]
+
+          break unless vlq > 0
+        end
+      end
+      result.join
+    end
+
+    # Public: Decode a VLQ string.
+    #
+    # str - VLQ encoded String
+    #
+    # Returns an Array of Integers.
+    def vlq_decode(str)
+      result = []
+      chars = str.split('')
+      while chars.any?
+        vlq = 0
+        shift = 0
+        continuation = true
+        while continuation
+          char = chars.shift
+          raise ArgumentError unless char
+          digit = BASE64_VALUES[char]
+          continuation = false if (digit & VLQ_CONTINUATION_BIT) == 0
+          digit &= VLQ_BASE_MASK
+          vlq   += digit << shift
+          shift += VLQ_BASE_SHIFT
+        end
+        result << (vlq & 1 == 1 ? -(vlq >> 1) : vlq >> 1)
+      end
+      result
+    end
+
+    # Public: Encode a mapping array into a compact VLQ string.
+    #
+    # ary - Two dimensional Array of Integers.
+    #
+    # Returns a VLQ encoded String seperated by , and ;.
+    def vlq_encode_mappings(ary)
+      ary.map { |group|
+        group.map { |segment|
+          vlq_encode(segment)
+        }.join(',')
+      }.join(';')
+    end
+
+    # Public: Decode a VLQ string into mapping numbers.
+    #
+    # str - VLQ encoded String
+    #
+    # Returns an two dimensional Array of Integers.
+    def vlq_decode_mappings(str)
+      mappings = []
+
+      str.split(';').each_with_index do |group, index|
+        mappings[index] = []
+        group.split(',').each do |segment|
+          mappings[index] << vlq_decode(segment)
+        end
+      end
+
+      mappings
+    end
+  end
+end