sprockets 4.0.0.beta4 → 4.0.0.beta5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 52d1dd6743105d82450959d44e27538e02130e7e
-  data.tar.gz: 02f58032703403898778cc33d6a56e0ca8bbee01
+  metadata.gz: 8fec40bbdd1b072ed9297eb8a8c4cace3ad4d406
+  data.tar.gz: 7e75410bb1fb7fce7577c5c7a270795735940d0b
 SHA512:
-  metadata.gz: ac089336d45577a2647ba6b329c5a62862613674be5969f4312e0d7afbb0cf3a9a06cbc7d9db7dd55649fac74c234da54d4482f83d091c4d2357269502006d99
-  data.tar.gz: 990363e0a8e9545ad6243279075cad733d7b403b45737b0c76b35d4647824e693c9f012c88b4220a431970d649dc7ad3582980311dc30c8e2b7b1871c1e5d611
+  metadata.gz: 41dc1ca9ad0acf4423861cc32353eb7e69f438fd01519ee2f0c5f6b543a4701b838132ebd1a55b3c2aedca5b2c2409b7221bc3199a7b094e9724c6165b9c7bbb
+  data.tar.gz: 2f9d9d7ca8cf7264eb99eb53b02f39d768f3f9472005d20a72655740c99eaf571977ddacd3ae07f8ada481e1390328e11cb2203bc415e29ecf496e93888d587a

data/CHANGELOG.md

@@ -4,6 +4,12 @@ Get upgrade notes from Sprockets 3.x to 4.x at https://github.com/rails/sprocket
 
 ## Master
 
+## 4.0.0.beta5
+
+- Reduce string allocations
+- Source map metadata uses compressed form specified by the [source map v3 spec](https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k). [#402] **[BREAKING]**
+- Generate [index maps](https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit#heading=h.535es3xeprgt) when decoding source maps isn't necessary. [#402]
+- Remove fingerprints from source map files. [#402]
 
 ## 4.0.0.beta4
 

data/README.md

@@ -63,8 +63,8 @@ For example, if you have an `application.js` and want all the files in the `foo/
 Then create a file `foo/index.js` that requires all the files in that folder in any order you want:
 
 ```
-//= require foo.min.js
-//= require foo-ui.js
+//= require ./foo.min.js
+//= require ./foo-ui.js
 ```
 
 Now, your `application.js` will correctly load the `foo.min.js` before `foo-ui.js`. If you used `require_tree` it would not work correctly.
@@ -359,8 +359,8 @@ reference files relative to the location of the current file.
 #### The `require` Directive
 
 `require` *path* inserts the contents of the asset source file
-specified by *path*. If the file is required multiple times, it will
-appear in the bundle only once.
+specified by *path*. If the same file is required multiple times
+with different path expressions, it will appear in the bundle only once.
 
 #### The `require_directory` Directive
 
@@ -440,7 +440,7 @@ Similar to Rack, a processor is any "callable" (an object that responds to `call
 
 Also see [`Sprockets::ProcessorUtils`](https://github.com/rails/sprockets/blob/master/lib/sprockets/processor_utils.rb) for public helper methods.
 
-### input Hash
+### Input Hash
 
 The `input` Hash defines the following public fields.
 
@@ -448,7 +448,6 @@ The `input` Hash defines the following public fields.
 * `:environment` - Current `Sprockets::Environment` instance.
 * `:cache` - A `Sprockets::Cache` instance. See [`Sprockets::Cache#fetch`](https://github.com/rails/sprockets/blob/master/lib/sprockets/cache.rb).
 * `:uri` - String Asset URI.
-* `:source_path` - String full path to original file.
 * `:load_path` - String current load path for filename.
 * `:name` - String logical path for filename.
 * `:content_type` - String content type of the output asset.

data/lib/sprockets.rb

@@ -99,13 +99,7 @@ module Sprockets
   end
 
   register_pipeline :default do |env, type, file_type|
-    # TODO: Hack for to inject source map transformer
-    if (type == "application/js-sourcemap+json" && file_type != "application/js-sourcemap+json") ||
-        (type == "application/css-sourcemap+json" && file_type != "application/css-sourcemap+json")
-      [SourceMapProcessor]
-    else
-      env.default_processors_for(type, file_type)
-    end
+    env.default_processors_for(type, file_type)
   end
 
   require 'sprockets/source_map_comment_processor'
@@ -129,7 +123,7 @@ module Sprockets
   register_bundle_metadata_reducer 'application/javascript', :data, proc { String.new("") }, Utils.method(:concat_javascript_sources)
   register_bundle_metadata_reducer '*/*', :links, :+
   register_bundle_metadata_reducer '*/*', :sources, proc { [] }, :+
-  register_bundle_metadata_reducer '*/*', :map, SourceMapUtils.method(:concat_source_maps)
+  register_bundle_metadata_reducer '*/*', :map, proc { |input| { "version" => 3, "file" => PathUtils.split_subpath(input[:load_path], input[:filename]), "sections" => [] } }, SourceMapUtils.method(:concat_source_maps)
 
   require 'sprockets/closure_compressor'
   require 'sprockets/sass_compressor'

data/lib/sprockets/babel_processor.rb

@@ -42,11 +42,11 @@ module Sprockets
 
       result = input[:cache].fetch(@cache_key + [input[:filename]] + [data]) do
         opts = {
-          'sourceRoot' => input[:load_path],
           'moduleRoot' => nil,
           'filename' => input[:filename],
           'filenameRelative' => PathUtils.split_subpath(input[:load_path], input[:filename]),
-          'sourceFileName' => input[:source_path]
+          'sourceFileName' => File.basename(input[:filename]),
+          'sourceMapTarget' => input[:filename]
         }.merge(@options)
 
         if opts['moduleIds'] && opts['moduleRoot']
@@ -57,8 +57,8 @@ module Sprockets
         Autoload::Babel::Transpiler.transform(data, opts)
       end
 
-      map = SourceMapUtils.decode_json_source_map(JSON.generate(result['map']))
-      map = SourceMapUtils.combine_source_maps(input[:metadata][:map], map["mappings"])
+      map = SourceMapUtils.format_source_map(result["map"], input)
+      map = SourceMapUtils.combine_source_maps(input[:metadata][:map], map)
 
       { data: result['code'], map: map }
     end

data/lib/sprockets/base.rb

@@ -6,6 +6,7 @@ require 'sprockets/configuration'
 require 'sprockets/digest_utils'
 require 'sprockets/errors'
 require 'sprockets/loader'
+require 'sprockets/npm'
 require 'sprockets/path_dependency_utils'
 require 'sprockets/path_digest_utils'
 require 'sprockets/path_utils'
@@ -22,6 +23,7 @@ module Sprockets
     include Server
     include Resolve, Loader
     include Bower
+    include Npm
 
     # Get persistent cache store
     attr_reader :cache

data/lib/sprockets/bundle.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require 'set'
 require 'sprockets/utils'
+require 'sprockets/uri_utils'
 
 module Sprockets
   # Internal: Bundle processor takes a single file asset and prepends all the
@@ -16,15 +17,32 @@ module Sprockets
     def self.call(input)
       env  = input[:environment]
       type = input[:content_type]
+      input[:links] ||= Set.new
       dependencies = Set.new(input[:metadata][:dependencies])
 
       processed_uri, deps = env.resolve(input[:filename], accept: type, pipeline: :self)
       dependencies.merge(deps)
 
+      # DirectiveProcessor (and any other transformers called here with pipeline=self)
+      primary_asset = env.load(processed_uri)
+      to_load = primary_asset.metadata.delete(:to_load) || Set.new
+      to_link = primary_asset.metadata.delete(:to_link) || Set.new
+
+      to_load.each do |uri|
+        loaded_asset = env.load(uri)
+        dependencies.merge(loaded_asset.metadata[:dependencies])
+        if to_link.include?(uri)
+          primary_metadata = primary_asset.metadata
+          input[:links]            << loaded_asset.uri
+          primary_metadata[:links] << loaded_asset.uri
+        end
+      end
+
       find_required = proc { |uri| env.load(uri).metadata[:required] }
       required = Utils.dfs(processed_uri, &find_required)
       stubbed  = Utils.dfs(env.load(processed_uri).metadata[:stubbed], &find_required)
       required.subtract(stubbed)
+      dedup(required)
       assets = required.map { |uri| env.load(uri) }
 
       (required + stubbed).each do |uri|
@@ -32,21 +50,38 @@ module Sprockets
       end
 
       reducers = Hash[env.match_mime_type_keys(env.config[:bundle_reducers], type).flat_map(&:to_a)]
-      process_bundle_reducers(assets, reducers).merge(dependencies: dependencies, included: assets.map(&:uri))
+      process_bundle_reducers(input, assets, reducers).merge(dependencies: dependencies, included: assets.map(&:uri))
+    end
+
+    # Internal: Removes uri from required if it's already included as an alias.
+    #
+    # required - Set of required uris
+    #
+    # Returns deduped set of uris
+    def self.dedup(required)
+      dupes = required.reduce([]) do |r, uri|
+        path, params = URIUtils.parse_asset_uri(uri)
+        if (params.delete(:index_alias))
+          r << URIUtils.build_asset_uri(path, params)
+        end
+        r
+      end
+      required.subtract(dupes)
     end
 
     # Internal: Run bundle reducers on set of Assets producing a reduced
     # metadata Hash.
     #
+    # filename - String bundle filename
     # assets - Array of Assets
     # reducers - Array of [initial, reducer_proc] pairs
     #
     # Returns reduced asset metadata Hash.
-    def self.process_bundle_reducers(assets, reducers)
+    def self.process_bundle_reducers(input, assets, reducers)
       initial = {}
       reducers.each do |k, (v, _)|
         if v.respond_to?(:call)
-          initial[k] = v.call
+          initial[k] = v.call(input)
         elsif !v.nil?
           initial[k] = v
         end

data/lib/sprockets/cache.rb

@@ -36,6 +36,12 @@ module Sprockets
   #
   #   Returns argument value.
   #
+  # clear(options)
+  #
+  #   Clear the entire cache. Be careful with this method since it could
+  #   affect other processes if shared cache is being used.
+  #
+  #   The options hash is passed to the underlying cache implementation.
   class Cache
     # Builtin cache stores.
     autoload :FileStore,   'sprockets/cache/file_store'
@@ -144,6 +150,14 @@ module Sprockets
       "#<#{self.class} local=#{@fetch_cache.inspect} store=#{@cache_wrapper.cache.inspect}>"
     end
 
+    # Public: Clear cache
+    #
+    # Returns truthy on success, potentially raises exception on failure
+    def clear(options=nil)
+      @cache_wrapper.clear
+      @fetch_cache.clear
+    end
+
     private
       # Internal: Expand object cache key into a short String key.
       #
@@ -212,6 +226,16 @@ module Sprockets
         def set(key, value)
           cache.set(key, value)
         end
+
+        def clear(options=nil)
+          # dalli has a #flush method so try it
+          if cache.respond_to?(:flush)
+            cache.flush(options)
+          else
+            cache.clear(options)
+          end
+          true
+        end
       end
 
       class HashWrapper < Wrapper
@@ -222,6 +246,11 @@ module Sprockets
         def set(key, value)
           cache[key] = value
         end
+
+        def clear(options=nil)
+          cache.clear
+          true
+        end
       end
 
       class ReadWriteWrapper < Wrapper
@@ -232,6 +261,11 @@ module Sprockets
         def set(key, value)
           cache.write(key, value)
         end
+
+        def clear(options=nil)
+          cache.clear(options)
+          true
+        end
       end
   end
 end

data/lib/sprockets/cache/file_store.rb

@@ -20,7 +20,8 @@ module Sprockets
     class FileStore
       # Internal: Default key limit for store.
       DEFAULT_MAX_SIZE = 25 * 1024 * 1024
-
+      EXCLUDED_DIRS = ['.', '..'].freeze
+      GITKEEP_FILES = ['.gitkeep', '.keep'].freeze
       # Internal: Default standard error fatal logger.
       #
       # Returns a Logger.
@@ -123,6 +124,21 @@ module Sprockets
         "#<#{self.class} size=#{size}/#{@max_size}>"
       end
 
+      # Public: Clear the cache
+      #
+      # adapted from ActiveSupport::Cache::FileStore#clear
+      #
+      # Deletes all items from the cache. In this case it deletes all the entries in the specified
+      # file store directory except for .keep or .gitkeep. Be careful which directory is specified
+      # as @root because everything in that directory will be deleted.
+      #
+      # Returns true
+      def clear(options=nil)
+        root_dirs = Dir.entries(@root).reject { |f| (EXCLUDED_DIRS + GITKEEP_FILES).include?(f) }
+        FileUtils.rm_r(root_dirs.collect{ |f| File.join(@root, f) })
+        true
+      end
+
       private
         # Internal: Get all cache files along with stats.
         #

data/lib/sprockets/cache/memory_store.rb

@@ -62,6 +62,14 @@ module Sprockets
       def inspect
         "#<#{self.class} size=#{@cache.size}/#{@max_size}>"
       end
+
+      # Public: Clear the cache
+      #
+      # Returns true
+      def clear(options=nil)
+        @cache.clear
+        true
+      end
     end
   end
 end

data/lib/sprockets/cache/null_store.rb

@@ -42,6 +42,13 @@ module Sprockets
       def inspect
         "#<#{self.class}>"
       end
+
+      # Public: Simulate clearing the cache
+      #
+      # Returns true
+      def clear(options=nil)
+        true
+      end
     end
   end
 end

data/lib/sprockets/cached_environment.rb

@@ -16,12 +16,11 @@ module Sprockets
       initialize_configuration(environment)
 
       @cache   = environment.cache
-      @stats   = Hash.new { |h, k| h[k] = _stat(k) }
-      @entries = Hash.new { |h, k| h[k] = _entries(k) }
-      @uris    = Hash.new { |h, k| h[k] = _load(k) }
-
-      @processor_cache_keys  = Hash.new { |h, k| h[k] = _processor_cache_key(k) }
-      @resolved_dependencies = Hash.new { |h, k| h[k] = _resolve_dependency(k) }
+      @stats   = {}
+      @entries = {}
+      @uris    = {}
+      @processor_cache_keys = {}
+      @resolved_dependencies = {}
     end
 
     # No-op return self as cached environment.
@@ -31,33 +30,28 @@ module Sprockets
     alias_method :index, :cached
 
     # Internal: Cache Environment#entries
-    alias_method :_entries, :entries
     def entries(path)
-      @entries[path]
+      @entries[path] ||= super(path)
     end
 
     # Internal: Cache Environment#stat
-    alias_method :_stat, :stat
     def stat(path)
-      @stats[path]
+      @stats[path] ||= super(path)
     end
 
     # Internal: Cache Environment#load
-    alias_method :_load, :load
     def load(uri)
-      @uris[uri]
+      @uris[uri] ||= super(uri)
     end
 
     # Internal: Cache Environment#processor_cache_key
-    alias_method :_processor_cache_key, :processor_cache_key
     def processor_cache_key(str)
-      @processor_cache_keys[str]
+      @processor_cache_keys[str] ||= super(str)
     end
 
     # Internal: Cache Environment#resolve_dependency
-    alias_method :_resolve_dependency, :resolve_dependency
     def resolve_dependency(str)
-      @resolved_dependencies[str]
+      @resolved_dependencies[str] ||= super(str)
     end
 
     private

data/lib/sprockets/coffee_script_processor.rb

@@ -21,11 +21,18 @@ module Sprockets
       data = input[:data]
 
       js, map = input[:cache].fetch([self.cache_key, data]) do
-        result = Autoload::CoffeeScript.compile(data, sourceMap: true, sourceFiles: [input[:source_path]])
-        [result['js'], SourceMapUtils.decode_json_source_map(result['v3SourceMap'])['mappings']]
+        result = Autoload::CoffeeScript.compile(
+          data,
+          sourceMap: "v3",
+          sourceFiles: [File.basename(input[:filename])],
+          generatedFile: input[:filename]
+        )
+        [result['js'], JSON.parse(result['v3SourceMap'])]
       end
 
+      map = SourceMapUtils.format_source_map(map, input)
       map = SourceMapUtils.combine_source_maps(input[:metadata][:map], map)
+
       { data: js, map: map }
     end
   end

data/lib/sprockets/digest_utils.rb

@@ -80,6 +80,9 @@ module Sprockets
         digest << val.to_s
       }
     end
+
+    ADD_VALUE_TO_DIGEST.compare_by_identity.rehash
+
     ADD_VALUE_TO_DIGEST.default_proc = ->(_, val) {
       raise TypeError, "couldn't digest #{ val }"
     }

data/lib/sprockets/directive_processor.rb

@@ -70,20 +70,28 @@ module Sprockets
       @uri          = input[:uri]
       @filename     = input[:filename]
       @dirname      = File.dirname(@filename)
-      @content_type = input[:content_type]
+      # If loading a source map file like `application.js.map` resolve
+      # dependencies using `.js` instead of `.js.map`
+      @content_type = SourceMapProcessor.original_content_type(input[:content_type], error_when_not_found: false)
       @required     = Set.new(input[:metadata][:required])
       @stubbed      = Set.new(input[:metadata][:stubbed])
       @links        = Set.new(input[:metadata][:links])
       @dependencies = Set.new(input[:metadata][:dependencies])
+      @to_link      = Set.new
+      @to_load      = Set.new
 
       data, directives = process_source(input[:data])
       process_directives(directives)
 
-      { data: data,
-        required: @required,
-        stubbed: @stubbed,
-        links: @links,
-        dependencies: @dependencies }
+      {
+        data:         data,
+        required:     @required,
+        stubbed:      @stubbed,
+        links:        @links,
+        to_load:      @to_load,
+        to_link:      @to_link,
+        dependencies: @dependencies
+      }
     end
 
     protected
@@ -274,7 +282,7 @@ module Sprockets
       #     //= depend_on_asset "bar.js"
       #
       def process_depend_on_asset_directive(path)
-        load(resolve(path))
+        to_load(resolve(path))
       end
 
       # Allows dependency to be excluded from the asset bundle.
@@ -298,7 +306,8 @@ module Sprockets
       #   /*= link "logo.png" */
       #
       def process_link_directive(path)
-        @links << load(resolve(path)).uri
+        uri = to_load(resolve(path))
+        @to_link << uri
       end
 
       # `link_directory` links all the files inside a single
@@ -355,7 +364,7 @@ module Sprockets
 
       def link_paths(paths, deps, accept)
         resolve_paths(paths, deps, accept: accept) do |uri|
-          @links << load(uri).uri
+          @to_link << to_load(uri)
         end
       end
 
@@ -385,10 +394,9 @@ module Sprockets
         end
       end
 
-      def load(uri)
-        asset = @environment.load(uri)
-        @dependencies.merge(asset.metadata[:dependencies])
-        asset
+      def to_load(uri)
+        @to_load << uri
+        uri
       end
 
       def resolve(path, **kargs)