sprockets 3.0.0 → 4.0.2

data/lib/sprockets/loader.rb

@@ -1,6 +1,6 @@
+# frozen_string_literal: true
 require 'sprockets/asset'
 require 'sprockets/digest_utils'
-require 'sprockets/engines'
 require 'sprockets/errors'
 require 'sprockets/file_reader'
 require 'sprockets/mime'
@@ -10,82 +10,161 @@ require 'sprockets/processor_utils'
 require 'sprockets/resolve'
 require 'sprockets/transformers'
 require 'sprockets/uri_utils'
+require 'sprockets/unloaded_asset'
 
 module Sprockets
+
   # The loader phase takes a asset URI location and returns a constructed Asset
   # object.
   module Loader
     include DigestUtils, PathUtils, ProcessorUtils, URIUtils
-    include Engines, Mime, Processing, Resolve, Transformers
+    include Mime, Processing, Resolve, Transformers
+
 
-    # Public: Load Asset by AssetURI.
+    # Public: Load Asset by Asset URI.
     #
-    # uri - AssetURI
+    # uri - A String containing complete URI to a file including schema
+    #       and full path such as:
+    #       "file:///Path/app/assets/js/app.js?type=application/javascript"
     #
     # Returns Asset.
     def load(uri)
-      filename, params = parse_asset_uri(uri)
-      if params.key?(:id)
-        asset = cache.fetch("asset-uri:#{VERSION}#{uri}") do
-          load_asset_by_id_uri(uri, filename, params)
+      unloaded = UnloadedAsset.new(uri, self)
+      if unloaded.params.key?(:id)
+        unless asset = asset_from_cache(unloaded.asset_key)
+          id = unloaded.params.delete(:id)
+          uri_without_id = build_asset_uri(unloaded.filename, unloaded.params)
+          asset = load_from_unloaded(UnloadedAsset.new(uri_without_id, self))
+          if asset[:id] != id
+            @logger.warn "Sprockets load error: Tried to find #{uri}, but latest was id #{asset[:id]}"
+          end
         end
       else
-        asset = fetch_asset_from_dependency_cache(uri, filename) do |paths|
+        asset = fetch_asset_from_dependency_cache(unloaded) do |paths|
+          # When asset is previously generated, its "dependencies" are stored in the cache.
+          # The presence of `paths` indicates dependencies were stored.
+          # We can check to see if the dependencies have not changed by "resolving" them and
+          # generating a digest key from the resolved entries. If this digest key has not
+          # changed, the asset will be pulled from cache.
+          #
+          # If this `paths` is present but the cache returns nothing then `fetch_asset_from_dependency_cache`
+          # will confusingly be called again with `paths` set to nil where the asset will be
+          # loaded from disk.
           if paths
-            digest = digest(resolve_dependencies(paths))
-            if id_uri = cache.get("asset-uri-digest:#{VERSION}:#{uri}:#{digest}", true)
-              cache.get("asset-uri:#{VERSION}:#{id_uri}", true)
+            digest = DigestUtils.digest(resolve_dependencies(paths))
+            if uri_from_cache = cache.get(unloaded.digest_key(digest), true)
+              asset_from_cache(UnloadedAsset.new(uri_from_cache, self).asset_key)
             end
           else
-            load_asset_by_uri(uri, filename, params)
+            load_from_unloaded(unloaded)
           end
         end
       end
-      Asset.new(self, asset)
+      Asset.new(asset)
     end
 
     private
-      def load_asset_by_id_uri(uri, filename, params)
-        # Internal assertion, should be routed through load_asset_by_uri
-        unless id = params.delete(:id)
-          raise ArgumentError, "expected uri to have an id: #{uri}"
+      def compress_key_from_hash(hash, key)
+        return unless hash.key?(key)
+        value = hash[key].dup
+        return if !value
+
+        if block_given?
+          value.map! do |x|
+            if yield x
+             compress_from_root(x)
+            else
+             x
+            end
+          end
+        else
+          value.map! { |x| compress_from_root(x) }
         end
+        hash[key] = value
+      end
 
-        uri = build_asset_uri(filename, params)
-        asset = load_asset_by_uri(uri, filename, params)
 
-        if id && asset[:id] != id
-          raise VersionNotFound, "could not find specified id: #{uri}##{id}"
+      def expand_key_from_hash(hash, key)
+        return unless hash.key?(key)
+        value = hash[key].dup
+        return if !value
+        if block_given?
+          value.map! do |x|
+            if yield x
+              expand_from_root(x)
+            else
+              x
+            end
+          end
+        else
+          value.map! { |x| expand_from_root(x) }
         end
+        hash[key] = value
+      end
+
+      # Internal: Load asset hash from cache
+      #
+      # key - A String containing lookup information for an asset
+      #
+      # This method converts all "compressed" paths to absolute paths.
+      # Returns a hash of values representing an asset
+      def asset_from_cache(key)
+        asset = cache.get(key, true)
+        if asset
+          asset[:uri]       = expand_from_root(asset[:uri])
+          asset[:load_path] = expand_from_root(asset[:load_path])
+          asset[:filename]  = expand_from_root(asset[:filename])
+          expand_key_from_hash(asset[:metadata], :included)
+          expand_key_from_hash(asset[:metadata], :links)
+          expand_key_from_hash(asset[:metadata], :stubbed)
+          expand_key_from_hash(asset[:metadata], :required)
+          expand_key_from_hash(asset[:metadata], :to_load)
+          expand_key_from_hash(asset[:metadata], :to_link)
+          expand_key_from_hash(asset[:metadata], :dependencies) { |uri| uri.start_with?("file-digest://") }
 
+          asset[:metadata].each_key do |k|
+            next unless k.match?(/_dependencies\z/) # rubocop:disable Performance/EndWith
+            expand_key_from_hash(asset[:metadata], k)
+          end
+        end
         asset
       end
 
-      def load_asset_by_uri(uri, filename, params)
-        # Internal assertion, should be routed through load_asset_by_id_uri
-        if params.key?(:id)
-          raise ArgumentError, "expected uri to have no id: #{uri}"
+      # Internal: Loads an asset and saves it to cache
+      #
+      # unloaded - An UnloadedAsset
+      #
+      # This method is only called when the given unloaded asset could not be
+      # successfully pulled from cache.
+      def load_from_unloaded(unloaded)
+        unless file?(unloaded.filename)
+          raise FileNotFound, "could not find file: #{unloaded.filename}"
         end
 
-        unless file?(filename)
-          raise FileNotFound, "could not find file: #{filename}"
-        end
+        path_to_split =
+          if index_alias = unloaded.params[:index_alias]
+            expand_from_root index_alias
+          else
+            unloaded.filename
+          end
 
-        load_path, logical_path = paths_split(config[:paths], filename)
+        load_path, logical_path = paths_split(config[:paths], path_to_split)
 
         unless load_path
-          raise FileOutsidePaths, "#{filename} is no longer under a load path: #{self.paths.join(', ')}"
+          target = path_to_split
+          target += " (index alias of #{unloaded.filename})" if unloaded.params[:index_alias]
+          raise FileOutsidePaths, "#{target} is no longer under a load path: #{self.paths.join(', ')}"
         end
 
-        logical_path, file_type, engine_extnames, _ = parse_path_extnames(logical_path)
-        logical_path = normalize_logical_path(logical_path)
+        extname, file_type = match_path_extname(logical_path, mime_exts)
+        logical_path = logical_path.chomp(extname)
         name = logical_path
 
-        if pipeline = params[:pipeline]
+        if pipeline = unloaded.params[:pipeline]
           logical_path += ".#{pipeline}"
         end
 
-        if type = params[:type]
+        if type = unloaded.params[:type]
           logical_path += config[:mime_types][type][:extensions].first
         end
 
@@ -93,9 +172,9 @@ module Sprockets
           raise ConversionError, "could not convert #{file_type.inspect} to #{type.inspect}"
         end
 
-        processors = processors_for(type, file_type, engine_extnames, pipeline)
+        processors = processors_for(type, file_type, pipeline)
 
-        processors_dep_uri = build_processors_uri(type, file_type, engine_extnames, pipeline)
+        processors_dep_uri = build_processors_uri(type, file_type, pipeline)
         dependencies = config[:dependencies] + [processors_dep_uri]
 
         # Read into memory and process if theres a processor pipeline
@@ -103,72 +182,162 @@ module Sprockets
           result = call_processors(processors, {
             environment: self,
             cache: self.cache,
-            uri: uri,
-            filename: filename,
+            uri: unloaded.uri,
+            filename: unloaded.filename,
             load_path: load_path,
             name: name,
             content_type: type,
-            metadata: { dependencies: dependencies }
+            metadata: {
+              dependencies: dependencies
+            }
           })
+          validate_processor_result!(result)
           source = result.delete(:data)
-          metadata = result.merge!(
-            charset: source.encoding.name.downcase,
-            digest: digest(source),
-            length: source.bytesize
-          )
+          metadata = result
+          metadata[:charset] = source.encoding.name.downcase unless metadata.key?(:charset)
+          metadata[:digest]  = digest(source)
+          metadata[:length]  = source.bytesize
+          metadata[:environment_version] = version
         else
+          dependencies << build_file_digest_uri(unloaded.filename)
           metadata = {
-            digest: file_digest(filename),
-            length: self.stat(filename).size,
-            dependencies: dependencies
+            digest: file_digest(unloaded.filename),
+            length: self.stat(unloaded.filename).size,
+            dependencies: dependencies,
+            environment_version: version,
           }
         end
 
         asset = {
-          uri: uri,
+          uri: unloaded.uri,
           load_path: load_path,
-          filename: filename,
+          filename: unloaded.filename,
           name: name,
           logical_path: logical_path,
           content_type: type,
           source: source,
           metadata: metadata,
-          integrity: integrity_uri(metadata[:digest], type),
-          dependencies_digest: digest(resolve_dependencies(metadata[:dependencies]))
+          dependencies_digest: DigestUtils.digest(resolve_dependencies(metadata[:dependencies]))
         }
 
-        asset[:id]  = pack_hexdigest(digest(asset))
-        asset[:uri] = build_asset_uri(filename, params.merge(id: asset[:id]))
+        asset[:id]  = hexdigest(asset)
+        asset[:uri] = build_asset_uri(unloaded.filename, unloaded.params.merge(id: asset[:id]))
 
-        # Deprecated: Avoid tracking Asset mtime
-        asset[:mtime] = metadata[:dependencies].map { |u|
-          if u.start_with?("file-digest:")
-            s = self.stat(parse_file_digest_uri(u))
-            s ? s.mtime.to_i : 0
-          else
-            0
+        store_asset(asset, unloaded)
+        asset
+      end
+
+      # Internal: Save a given asset to the cache
+      #
+      # asset - A hash containing values of loaded asset
+      # unloaded - The UnloadedAsset used to lookup the `asset`
+      #
+      # This method converts all absolute paths to "compressed" paths
+      # which are relative if they're in the root.
+      def store_asset(asset, unloaded)
+        # Save the asset in the cache under the new URI
+        cached_asset             = asset.dup
+        cached_asset[:uri]       = compress_from_root(asset[:uri])
+        cached_asset[:filename]  = compress_from_root(asset[:filename])
+        cached_asset[:load_path] = compress_from_root(asset[:load_path])
+
+        if cached_asset[:metadata]
+          # Deep dup to avoid modifying `asset`
+          cached_asset[:metadata] = cached_asset[:metadata].dup
+          compress_key_from_hash(cached_asset[:metadata], :included)
+          compress_key_from_hash(cached_asset[:metadata], :links)
+          compress_key_from_hash(cached_asset[:metadata], :stubbed)
+          compress_key_from_hash(cached_asset[:metadata], :required)
+          compress_key_from_hash(cached_asset[:metadata], :to_load)
+          compress_key_from_hash(cached_asset[:metadata], :to_link)
+          compress_key_from_hash(cached_asset[:metadata], :dependencies) { |uri| uri.start_with?("file-digest://") }
+
+          cached_asset[:metadata].each do |key, value|
+            next unless key.match?(/_dependencies\z/) # rubocop:disable Performance/EndWith
+            compress_key_from_hash(cached_asset[:metadata], key)
           end
-        }.max
+        end
 
-        cache.set("asset-uri:#{VERSION}:#{asset[:uri]}", asset, true)
-        cache.set("asset-uri-digest:#{VERSION}:#{uri}:#{asset[:dependencies_digest]}", asset[:uri], true)
+        # Unloaded asset and stored_asset now have a different URI
+        stored_asset = UnloadedAsset.new(asset[:uri], self)
+        cache.set(stored_asset.asset_key, cached_asset, true)
 
-        asset
+        # Save the new relative path for the digest key of the unloaded asset
+        cache.set(unloaded.digest_key(asset[:dependencies_digest]), stored_asset.compressed_path, true)
       end
 
-      def fetch_asset_from_dependency_cache(uri, filename, limit = 3)
-        key = "asset-uri-cache-dependencies:#{VERSION}:#{uri}:#{file_digest(filename)}"
-        history = cache.get(key) || []
 
+      # Internal: Resolve set of dependency URIs.
+      #
+      # uris - An Array of "dependencies" for example:
+      #        ["environment-version", "environment-paths", "processors:type=text/css&file_type=text/css",
+      #           "file-digest:///Full/path/app/assets/stylesheets/application.css",
+      #           "processors:type=text/css&file_type=text/css&pipeline=self",
+      #           "file-digest:///Full/path/app/assets/stylesheets"]
+      #
+      # Returns back array of things that the given uri depends on
+      # For example the environment version, if you're using a different version of sprockets
+      # then the dependencies should be different, this is used only for generating cache key
+      # for example the "environment-version" may be resolved to "environment-1.0-3.2.0" for
+      # version "3.2.0" of sprockets.
+      #
+      # Any paths that are returned are converted to relative paths
+      #
+      # Returns array of resolved dependencies
+      def resolve_dependencies(uris)
+        uris.map { |uri| resolve_dependency(uri) }
+      end
+
+      # Internal: Retrieves an asset based on its digest
+      #
+      # unloaded - An UnloadedAsset
+      # limit    - A Fixnum which sets the maximum number of versions of "histories"
+      #            stored in the cache
+      #
+      # This method attempts to retrieve the last `limit` number of histories of an asset
+      # from the cache a "history" which is an array of unresolved "dependencies" that the asset needs
+      # to compile. In this case a dependency can refer to either an asset e.g. index.js
+      # may rely on jquery.js (so jquery.js is a dependency), or other factors that may affect
+      # compilation, such as the VERSION of Sprockets (i.e. the environment) and what "processors"
+      # are used.
+      #
+      # For example a history array may look something like this
+      #
+      #   [["environment-version", "environment-paths", "processors:type=text/css&file_type=text/css",
+      #     "file-digest:///Full/path/app/assets/stylesheets/application.css",
+      #     "processors:type=text/css&file_digesttype=text/css&pipeline=self",
+      #     "file-digest:///Full/path/app/assets/stylesheets"]]
+      #
+      # Where the first entry is a Set of dependencies for last generated version of that asset.
+      # Multiple versions are stored since Sprockets keeps the last `limit` number of assets
+      # generated present in the system.
+      #
+      # If a "history" of dependencies is present in the cache, each version of "history" will be
+      # yielded to the passed block which is responsible for loading the asset. If found, the existing
+      # history will be saved with the dependency that found a valid asset moved to the front.
+      #
+      # If no history is present, or if none of the histories could be resolved to a valid asset then,
+      # the block is yielded to and expected to return a valid asset.
+      # When this happens the dependencies for the returned asset are added to the "history", and older
+      # entries are removed if the "history" is above `limit`.
+      def fetch_asset_from_dependency_cache(unloaded, limit = 3)
+        key = unloaded.dependency_history_key
+
+        history = cache.get(key) || []
         history.each_with_index do |deps, index|
-          if asset = yield(deps)
+          expanded_deps = deps.map do |path|
+            path.start_with?("file-digest://") ? expand_from_root(path) : path
+          end
+          if asset = yield(expanded_deps)
             cache.set(key, history.rotate!(index)) if index > 0
             return asset
           end
         end
 
         asset = yield
-        deps = asset[:metadata][:dependencies]
+        deps  = asset[:metadata][:dependencies].dup.map! do |uri|
+          uri.start_with?("file-digest://") ? compress_from_root(uri) : uri
+        end
         cache.set(key, history.unshift(deps).take(limit))
         asset
       end

data/lib/sprockets/manifest.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
 require 'json'
 require 'time'
+
+require 'concurrent'
+
 require 'sprockets/manifest_utils'
 
 module Sprockets
@@ -48,14 +52,8 @@ module Sprockets
       @directory ||= File.dirname(@filename) if @filename
 
       # If directory is given w/o filename, pick a random manifest location
-      @rename_filename = nil
       if @directory && @filename.nil?
-        @filename = find_directory_manifest(@directory)
-
-        # If legacy manifest name autodetected, mark to rename on save
-        if File.basename(@filename).start_with?("manifest")
-          @rename_filename = File.join(@directory, generate_manifest_path)
-        end
+        @filename = find_directory_manifest(@directory, logger)
       end
 
       unless @directory && @filename
@@ -121,31 +119,38 @@ module Sprockets
 
       return to_enum(__method__, *args) unless block_given?
 
-      paths, filters = args.flatten.partition { |arg| self.class.simple_logical_path?(arg) }
-      filters = filters.map { |arg| self.class.compile_match_filter(arg) }
-
       environment = self.environment.cached
-
-      paths.each do |path|
-        environment.find_all_linked_assets(path) do |asset|
-          yield asset
-        end
-      end
-
-      if filters.any?
-        environment.logical_paths do |logical_path, filename|
-          if filters.any? { |f| f.call(logical_path, filename) }
-            environment.find_all_linked_assets(filename) do |asset|
-              yield asset
-            end
+      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
 
-    # Compile and write asset to directory. The asset is written to a
+    # Public: Find the source of assets by paths.
+    #
+    # Returns Enumerator of assets file content.
+    def find_sources(*args)
+      return to_enum(__method__, *args) unless block_given?
+
+      if environment
+        find(*args).each do |asset|
+          yield asset.source
+        end
+      else
+        args.each do |path|
+          asset = assets[path]
+          yield File.binread(File.join(dir, asset)) if asset
+        end
+      end
+    end
+
+    # Compile asset to directory. The asset is written to a
     # fingerprinted filename like
     # `application-2e8e9a7c6b0aafa0c9bdeec90ea30213.js`. An entry is
     # also inserted into the manifest file.
@@ -157,29 +162,46 @@ module Sprockets
         raise Error, "manifest requires environment for compilation"
       end
 
-      filenames = []
+      filenames            = []
+      concurrent_exporters = []
 
+      assets_to_export = Concurrent::Array.new
       find(*args) do |asset|
+        assets_to_export << asset
+      end
+
+      assets_to_export.each do |asset|
+        mtime = Time.now.iso8601
         files[asset.digest_path] = {
           'logical_path' => asset.logical_path,
-          'mtime'        => asset.mtime.iso8601,
+          'mtime'        => mtime,
           'size'         => asset.bytesize,
           'digest'       => asset.hexdigest,
-          'integrity'    => asset.integrity
+
+          # Deprecated: Remove beta integrity attribute in next release.
+          # Callers should DigestUtils.hexdigest_integrity_uri to compute the
+          # digest themselves.
+          'integrity'    => DigestUtils.hexdigest_integrity_uri(asset.hexdigest)
         }
         assets[asset.logical_path] = asset.digest_path
 
-        target = File.join(dir, asset.digest_path)
+        filenames << asset.filename
 
-        if File.exist?(target)
-          logger.debug "Skipping #{target}, already exists"
-        else
-          logger.info "Writing #{target}"
-          asset.write_to target
-        end
+        promise      = nil
+        exporters_for_asset(asset) do |exporter|
+          next if exporter.skip?(logger)
 
-        filenames << asset.filename
+          if promise.nil?
+            promise = Concurrent::Promise.new(executor: executor) { exporter.call }
+            concurrent_exporters << promise.execute
+          else
+            concurrent_exporters << promise.then { exporter.call }
+          end
+        end
       end
+
+      # make sure all exporters have finished before returning the main thread
+      concurrent_exporters.each(&:wait!)
       save
 
       filenames
@@ -192,6 +214,7 @@ module Sprockets
     #
     def remove(filename)
       path = File.join(dir, filename)
+      gzip = "#{path}.gz"
       logical_path = files[filename]['logical_path']
 
       if assets[logical_path] == filename
@@ -200,6 +223,7 @@ module Sprockets
 
       files.delete(filename)
       FileUtils.rm(path) if File.exist?(path)
+      FileUtils.rm(gzip) if File.exist?(gzip)
 
       save
 
@@ -230,9 +254,9 @@ module Sprockets
           # Sort by timestamp
           Time.parse(attrs['mtime'])
         }.reverse.each_with_index.drop_while { |(_, attrs), index|
-          age = [0, Time.now - Time.parse(attrs['mtime'])].max
+          _age = [0, Time.now - Time.parse(attrs['mtime'])].max
           # Keep if under age or within the count limit
-          age < age || index < count
+          _age < age || index < count
         }.each { |(path, _), _|
            # Remove old assets
           remove(path)
@@ -244,18 +268,13 @@ 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
 
     # Persist manfiest back to FS
     def save
-      if @rename_filename
-        logger.info "Renaming #{@filename} to #{@rename_filename}"
-        FileUtils.mv(@filename, @rename_filename)
-        @filename = @rename_filename
-        @rename_filename = nil
-      end
-
       data = json_encode(@data)
       FileUtils.mkdir_p File.dirname(@filename)
       PathUtils.atomic_write(@filename) do |f|
@@ -264,6 +283,36 @@ module Sprockets
     end
 
     private
+
+      # Given an asset, finds all exporters that
+      # match its mime-type.
+      #
+      # Will yield each expoter to the passed in block.
+      #
+      #     array = []
+      #     puts asset.content_type # => "application/javascript"
+      #     exporters_for_asset(asset) do |exporter|
+      #       array << exporter
+      #     end
+      #     # puts array => [Exporters::FileExporter, Exporters::ZlibExporter]
+      def exporters_for_asset(asset)
+        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
+          end
+        end
+
+        exporters.uniq!
+
+        exporters.each do |exporter|
+          yield exporter.new(asset: asset, environment: environment, directory: dir)
+        end
+      end
+
       def json_decode(obj)
         JSON.parse(obj, create_additions: false)
       end
@@ -281,5 +330,9 @@ module Sprockets
           logger
         end
       end
+
+      def executor
+        @executor ||= environment.export_concurrent ? :fast : :immediate
+      end
   end
 end

data/lib/sprockets/manifest_utils.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 require 'securerandom'
+require 'logger'
 
 module Sprockets
   # Public: Manifest utilities.
@@ -6,7 +8,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.
     #
@@ -33,12 +34,14 @@ module Sprockets
     #     # => "/app/public/assets/.sprockets-manifest-abc123.json"
     #
     # Returns String filename.
-    def find_directory_manifest(dirname)
+    def find_directory_manifest(dirname, logger = Logger.new($stderr))
       entries = File.directory?(dirname) ? Dir.entries(dirname) : []
-      entry = entries.find { |e| e =~ MANIFEST_RE } ||
-        # Deprecated: Will be removed in 4.x
-        entries.find { |e| e =~ LEGACY_MANIFEST_RE } ||
-        generate_manifest_path
+      manifest_entries = entries.select { |e| e =~ MANIFEST_RE }
+      if manifest_entries.length > 1
+        manifest_entries.sort!
+        logger.warn("Found multiple manifests: #{manifest_entries}. Choosing the first alphabetically: #{manifest_entries.first}")
+      end
+      entry = manifest_entries.first || generate_manifest_path
       File.join(dirname, entry)
     end
   end