sprockets 4.0.0.beta4 → 4.0.0.beta5

data/lib/sprockets/loader.rb

@@ -140,10 +140,6 @@ module Sprockets
 
         # Read into memory and process if theres a processor pipeline
         if processors.any?
-          source_uri, _ = resolve!(unloaded.filename, pipeline: :source)
-          source_asset = load(source_uri)
-
-          source_path = source_asset.digest_path
 
           result = call_processors(processors, {
             environment: self,
@@ -151,12 +147,10 @@ module Sprockets
             uri: unloaded.uri,
             filename: unloaded.filename,
             load_path: load_path,
-            source_path: source_path,
             name: name,
             content_type: type,
             metadata: {
-              dependencies: dependencies,
-              map: []
+              dependencies: dependencies
             }
           })
           validate_processor_result!(result)

data/lib/sprockets/manifest.rb

@@ -120,11 +120,14 @@ module Sprockets
       return to_enum(__method__, *args) unless block_given?
 
       environment = self.environment.cached
-      args.flatten.each do |path|
-        environment.find_all_linked_assets(path) do |asset|
-          yield asset
+      promises = args.flatten.map do |path|
+        Concurrent::Promise.execute(executor: executor) do
+          environment.find_all_linked_assets(path) do |asset|
+            yield asset
+          end
         end
       end
+      promises.each(&:wait!)
 
       nil
     end
@@ -160,7 +163,6 @@ module Sprockets
 
       filenames            = []
       concurrent_exporters = []
-      executor             = Concurrent::FixedThreadPool.new(Concurrent.processor_count)
 
       find(*args) do |asset|
         mtime = Time.now.iso8601
@@ -183,11 +185,6 @@ module Sprockets
         exporters_for_asset(asset) do |exporter|
           next if exporter.skip?(logger)
 
-          if !environment.export_concurrent
-            exporter.call
-            next
-          end
-
           if promise.nil?
             promise = Concurrent::Promise.new(executor: executor) { exporter.call }
             concurrent_exporters << promise.execute
@@ -265,6 +262,8 @@ module Sprockets
     def clobber
       FileUtils.rm_r(directory) if File.exist?(directory)
       logger.info "Removed #{directory}"
+      # if we have an environment clear the cache too
+      environment.cache.clear if environment
       nil
     end
 
@@ -294,6 +293,7 @@ module Sprockets
         exporters = [Exporters::FileExporter]
 
         environment.exporters.each do |mime_type, exporter_list|
+          next unless asset.content_type
           next unless environment.match_mime_type? asset.content_type, mime_type
           exporter_list.each do |exporter|
             exporters << exporter
@@ -324,5 +324,9 @@ module Sprockets
           logger
         end
       end
+
+      def executor
+        @executor ||= environment.export_concurrent ? :fast : :immediate
+      end
   end
 end

data/lib/sprockets/manifest_utils.rb

@@ -7,7 +7,6 @@ module Sprockets
     extend self
 
     MANIFEST_RE = /^\.sprockets-manifest-[0-9a-f]{32}.json$/
-    LEGACY_MANIFEST_RE = /^manifest(-[0-9a-f]{32})?.json$/
 
     # Public: Generate a new random manifest path.
     #

data/lib/sprockets/npm.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+require 'json'
+
+module Sprockets
+  module Npm
+    # Internal: Override resolve_alternates to install package.json behavior.
+    #
+    # load_path    - String environment path
+    # logical_path - String path relative to base
+    #
+    # Returns candiate filenames.
+    def resolve_alternates(load_path, logical_path)
+      candidates, deps = super
+
+      dirname = File.join(load_path, logical_path)
+
+      if directory?(dirname)
+        filename = File.join(dirname, 'package.json')
+
+        if self.file?(filename)
+          deps << build_file_digest_uri(filename)
+          read_package_directives(dirname, filename) do |path|
+            if file?(path)
+              candidates << path
+            end
+          end
+        end
+      end
+
+      return candidates, deps
+    end
+
+    # Internal: Read package.json's main and style directives.
+    #
+    # dirname  - String path to component directory.
+    # filename - String path to package.json.
+    #
+    # Returns nothing.
+    def read_package_directives(dirname, filename)
+      package = JSON.parse(File.read(filename), create_additions: false)
+
+      case package['main']
+      when String
+        yield File.expand_path(package['main'], dirname)
+      when nil
+        yield File.expand_path('index.js', dirname)
+      end
+
+      yield File.expand_path(package['style'], dirname) if package['style']
+    end
+  end
+end

data/lib/sprockets/path_utils.rb

@@ -81,7 +81,7 @@ module Sprockets
       end
     else
       def absolute_path?(path)
-        path[0] == File::SEPARATOR
+        path.start_with?(File::SEPARATOR)
       end
     end
 
@@ -128,6 +128,30 @@ module Sprockets
       (Pathname.new(base) + path).to_s
     end
 
+    # Public: Sets pipeline for path
+    #
+    # path       - String path
+    # extensions - List of file extensions
+    # pipeline   - Pipeline
+    #
+    # Examples
+    #
+    #     set_pipeline('path/file.js.erb', config[:mime_exts], config[:pipeline_exts], :source)
+    #     # => 'path/file.source.js.erb'
+    #
+    #     set_pipeline('path/some.file.source.js.erb', config[:mime_exts], config[:pipeline_exts], :debug)
+    #     # => 'path/some.file.debug.js.erb'
+    #
+    # Returns string path with pipeline parsed in
+    def set_pipeline(path, mime_exts, pipeline_exts, pipeline)
+      extension, _ = match_path_extname(path, mime_exts)
+      path.chomp!(extension)
+      pipeline_old, _ = match_path_extname(path, pipeline_exts)
+      path.chomp!(pipeline_old)
+
+      "#{path}.#{pipeline}#{extension}"
+    end
+
     # Internal: Get relative path for root path and subpath.
     #
     # path    - String path

data/lib/sprockets/preprocessors/default_source_map.rb

@@ -9,17 +9,37 @@ module Sprockets
     # available.
     class DefaultSourceMap
       def call(input)
-        result = { data: input[:data] }
-        map    = input[:metadata][:map]
+        result        = { data: input[:data] }
+        map           = input[:metadata][:map]
+        filename      = input[:filename]
+        load_path     = input[:load_path]
+        lines         = input[:data].lines.count
+        basename      = File.basename(filename)
+        mime_exts     = input[:environment].config[:mime_exts]
+        pipeline_exts = input[:environment].config[:pipeline_exts]
         if map.nil? || map.empty?
-          result[:map] ||= []
-          input[:data].each_line.with_index do |_, index|
-            line = index + 1
-            result[:map] << { source: input[:source_path], generated: [line , 0], original: [line, 0] }
-          end
+          result[:map] = {
+            "version"   => 3,
+            "file"      => PathUtils.split_subpath(load_path, filename),
+            "mappings"  => default_mappings(lines),
+            "sources"   => [PathUtils.set_pipeline(basename, mime_exts, pipeline_exts, :source)],
+            "names"     => []
+          }
         end
         return result
       end
+      
+      private
+
+      def default_mappings(lines)
+        if (lines == 0)
+          ""
+        elsif (lines == 1)
+          "AAAA"
+        else
+          "AAAA;" + "AACA;"*(lines - 2) + "AACA"
+        end
+      end
     end
   end
 end

data/lib/sprockets/sass_compressor.rb

@@ -49,15 +49,13 @@ module Sprockets
     def call(input)
       css, map = Autoload::Sass::Engine.new(
         input[:data],
-        @options.merge(filename: 'filename')
+        @options.merge(filename: input[: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"]
-      )
+      map = SourceMapUtils.format_source_map(JSON.parse(map.to_json(css_uri: '')), input)
+      map = SourceMapUtils.combine_source_maps(input[:metadata][:map], map)
 
       { data: css, map: map }
     end

data/lib/sprockets/sass_processor.rb

@@ -80,13 +80,8 @@ module Sprockets
 
       css = css.sub("\n/*# sourceMappingURL= */\n", '')
 
-      map = SourceMapUtils.combine_source_maps(
-        input[:metadata][:map],
-        expand_map_sources(
-          SourceMapUtils.decode_json_source_map(map.to_json(css_uri: '', type: :inline))["mappings"],
-          input[:environment]
-        )
-      )
+      map = SourceMapUtils.format_source_map(JSON.parse(map.to_json(css_uri: '')), input)
+      map = SourceMapUtils.combine_source_maps(input[:metadata][:map], map)
 
       # Track all imported files
       sass_dependencies = Set.new([input[:filename]])
@@ -100,17 +95,6 @@ module Sprockets
 
     private
 
-    def expand_source(source, env)
-      uri, _ = env.resolve!(source, pipeline: :source)
-      env.load(uri).digest_path
-    end
-
-    def expand_map_sources(mapping, env)
-      mapping.each do |map|
-        map[:source] = expand_source(map[:source], env)
-      end
-    end
-
     # Public: Build the cache store to be used by the Sass engine.
     #
     # input - the input hash.

data/lib/sprockets/sassc_compressor.rb

@@ -9,23 +9,24 @@ module Sprockets
       @options = {
         syntax: :scss,
         style: :compressed,
-        source_map_embed: true,
-        source_map_file: '.'
+        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]
-      data = Autoload::SassC::Engine.new(input_data, @options.merge(filename: 'filename')).render
+      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, '')
 
-      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"]
-      )
+      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

data/lib/sprockets/sassc_processor.rb

@@ -27,25 +27,18 @@ module Sprockets
         engine.render.sub(/^\n^\/\*# sourceMappingURL=.*\*\/$/m, '')
       end
 
-      map = SourceMapUtils.decode_json_source_map(engine.source_map)
-      sources = map['sources'].map do |s|
-        expand_source(PathUtils.join(File.dirname(input[:filename]), s), input[:environment])
-      end
-
-      map = map["mappings"].each do |m|
-        m[:source] = PathUtils.join(File.dirname(input[:filename]), m[:source])
-      end
-
-      map = SourceMapUtils.combine_source_maps(
-        input[:metadata][:map],
-        expand_map_sources(map, input[:environment])
-      )
+      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)
+        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, sources: sources)
+      context.metadata.merge(data: css, map: map)
     end
 
     private
@@ -56,7 +49,7 @@ module Sprockets
         syntax: self.class.syntax,
         load_paths: input[:environment].paths,
         importer: @importer_class,
-        source_map_contents: true,
+        source_map_contents: false,
         source_map_file: "#{input[:filename]}.map",
         omit_source_map_url: true,
         sprockets: {

data/lib/sprockets/server.rb

@@ -241,7 +241,7 @@ 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, immutable"
 
         # Otherwise set `must-revalidate` since the asset could be modified.
         else

data/lib/sprockets/source_map_comment_processor.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+require 'sprockets/uri_utils'
+require 'sprockets/path_utils'
+
 module Sprockets
   class SourceMapCommentProcessor
     def self.call(input)
@@ -21,7 +24,9 @@ module Sprockets
       uri, _ = env.resolve!(input[:filename], accept: map_type)
       map = env.load(uri)
 
-      path = PathUtils.relative_path_from(input[:filename], map.full_digest_path)
+      uri, params = URIUtils.parse_asset_uri(input[:uri])
+      uri = env.expand_from_root(params[:index_alias]) if params[:index_alias]
+      path = PathUtils.relative_path_from(PathUtils.split_subpath(input[:load_path], uri), map.digest_path)
 
       asset.metadata.merge(
         data: asset.source + (comment % path),

data/lib/sprockets/source_map_processor.rb

@@ -3,24 +3,25 @@ require 'set'
 
 module Sprockets
   class SourceMapProcessor
-    def self.call(input)
-      case input[:content_type]
+    def self.original_content_type(source_map_content_type, error_when_not_found: true)
+      case source_map_content_type
       when "application/js-sourcemap+json"
         accept = "application/javascript"
       when "application/css-sourcemap+json"
         accept = "text/css"
       else
-        fail input[:content_type]
+        fail(source_map_content_type) if error_when_not_found
+        source_map_content_type
       end
+    end
 
+    def self.call(input)
       links = Set.new(input[:metadata][:links])
-
       env = input[:environment]
 
-      uri, _  = env.resolve!(input[:filename], accept: accept)
-      asset   = env.load(uri)
-      map     = asset.metadata[:map] || []
-      sources = asset.metadata[:sources]
+      uri, _ = env.resolve!(input[:filename], accept: 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
@@ -28,19 +29,16 @@ module Sprockets
       dependencies = Set.new(input[:metadata][:dependencies])
       dependencies.merge(asset.metadata[:dependencies])
 
-      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)
+      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 = env.encode_json_source_map(map, sources: sources, filename: asset.logical_path)
+      json = JSON.generate(map)
 
       { data: json, links: links, dependencies: dependencies }
     end