sprockets 3.7.2 → 4.0.2

data/lib/sprockets/paths.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'sprockets/path_utils'
 require 'sprockets/utils'
 

data/lib/sprockets/preprocessors/default_source_map.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module Sprockets
+  module Preprocessors
+    # Private: Adds a default map to assets when one is not present
+    #
+    # If the input file already has a source map, it effectively returns the original
+    # result. Otherwise it maps 1 for 1 lines original to generated. This is needed
+    # Because other generators run after might depend on having a valid source map
+    # available.
+    class DefaultSourceMap
+      def call(input)
+        result        = { data: input[:data] }
+        map           = input[:metadata][:map]
+        filename      = input[:filename]
+        load_path     = input[:load_path]
+        lines         = input[:data].lines.length
+        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] = {
+            "version"   => 3,
+            "file"      => PathUtils.split_subpath(load_path, filename),
+            "mappings"  => default_mappings(lines),
+            "sources"   => [PathUtils.set_pipeline(basename, mime_exts, pipeline_exts, :source)],
+            "names"     => []
+          }
+        else
+          result[:map] = map
+        end
+
+        result[:map]["x_sprockets_linecount"] = lines
+        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/processing.rb

@@ -1,7 +1,5 @@
-require 'sprockets/engines'
+# frozen_string_literal: true
 require 'sprockets/file_reader'
-require 'sprockets/legacy_proc_processor'
-require 'sprockets/legacy_tilt_processor'
 require 'sprockets/mime'
 require 'sprockets/processor_utils'
 require 'sprockets/uri_utils'
@@ -17,9 +15,14 @@ module Sprockets
       config[:pipelines]
     end
 
+    # Registers a pipeline that will be called by `call_processor` method.
     def register_pipeline(name, proc = nil, &block)
       proc ||= block
 
+      self.config = hash_reassoc(config, :pipeline_exts) do |pipeline_exts|
+        pipeline_exts.merge(".#{name}".freeze => name.to_sym)
+      end
+
       self.config = hash_reassoc(config, :pipelines) do |pipelines|
         pipelines.merge(name.to_sym => proc)
       end
@@ -43,12 +46,13 @@ module Sprockets
     #
     # A block can be passed for to create a shorthand processor.
     #
-    #     register_preprocessor 'text/css', :my_processor do |context, data|
-    #       data.gsub(...)
+    #     register_preprocessor 'text/css' do |input|
+    #       input[:data].gsub(...)
     #     end
     #
     def register_preprocessor(*args, &block)
       register_config_processor(:preprocessors, *args, &block)
+      compute_transformers!(self.config[:registered_transformers])
     end
     alias_method :register_processor, :register_preprocessor
 
@@ -58,12 +62,13 @@ module Sprockets
     #
     # A block can be passed for to create a shorthand processor.
     #
-    #     register_postprocessor 'application/javascript', :my_processor do |context, data|
-    #       data.gsub(...)
+    #     register_postprocessor 'application/javascript' do |input|
+    #       input[:data].gsub(...)
     #     end
     #
     def register_postprocessor(*args, &block)
       register_config_processor(:postprocessors, *args, &block)
+      compute_transformers!(self.config[:registered_transformers])
     end
 
     # Remove Preprocessor `klass` for `mime_type`.
@@ -72,6 +77,7 @@ module Sprockets
     #
     def unregister_preprocessor(*args)
       unregister_config_processor(:preprocessors, *args)
+      compute_transformers!(self.config[:registered_transformers])
     end
     alias_method :unregister_processor, :unregister_preprocessor
 
@@ -81,6 +87,7 @@ module Sprockets
     #
     def unregister_postprocessor(*args)
       unregister_config_processor(:postprocessors, *args)
+      compute_transformers!(self.config[:registered_transformers])
     end
 
     # Bundle Processors are ran on concatenated assets rather than
@@ -95,8 +102,8 @@ module Sprockets
     #
     # A block can be passed for to create a shorthand processor.
     #
-    #     register_bundle_processor 'application/javascript', :my_processor do |context, data|
-    #       data.gsub(...)
+    #     register_bundle_processor 'application/javascript' do |input|
+    #       input[:data].gsub(...)
     #     end
     #
     def register_bundle_processor(*args, &block)
@@ -154,46 +161,44 @@ module Sprockets
     protected
       def resolve_processors_cache_key_uri(uri)
         params = parse_uri_query_params(uri[11..-1])
-        params[:engine_extnames] = params[:engines] ? params[:engines].split(',') : []
-        processors = processors_for(params[:type], params[:file_type], params[:engine_extnames], params[:pipeline])
+        processors = processors_for(params[:type], params[:file_type], params[:pipeline])
         processors_cache_keys(processors)
       end
 
-      def build_processors_uri(type, file_type, engine_extnames, pipeline)
-        engines = engine_extnames.join(',') if engine_extnames.any?
+      def build_processors_uri(type, file_type, pipeline)
         query = encode_uri_query_params(
           type: type,
           file_type: file_type,
-          engines: engines,
           pipeline: pipeline
         )
         "processors:#{query}"
       end
 
-      def processors_for(type, file_type, engine_extnames, pipeline)
+      def processors_for(type, file_type, pipeline)
         pipeline ||= :default
-        config[:pipelines][pipeline.to_sym].call(self, type, file_type, engine_extnames)
+        if fn = config[:pipelines][pipeline.to_sym]
+          fn.call(self, type, file_type)
+        else
+          raise Error, "no pipeline: #{pipeline}"
+        end
       end
 
-      def default_processors_for(type, file_type, engine_extnames)
+      def default_processors_for(type, file_type)
         bundled_processors = config[:bundle_processors][type]
         if bundled_processors.any?
           bundled_processors
         else
-          self_processors_for(type, file_type, engine_extnames)
+          self_processors_for(type, file_type)
         end
       end
 
-      def self_processors_for(type, file_type, engine_extnames)
+      def self_processors_for(type, file_type)
         processors = []
 
         processors.concat config[:postprocessors][type]
-
         if type != file_type && processor = config[:transformers][file_type][type]
           processors << processor
         end
-
-        processors.concat engine_extnames.map { |ext| engines[ext] }
         processors.concat config[:preprocessors][file_type]
 
         if processors.any? || mime_type_charset_detecter(type)
@@ -204,55 +209,20 @@ module Sprockets
       end
 
     private
-      def register_config_processor(type, mime_type, klass, proc = nil, &block)
-        proc ||= block
-        processor = wrap_processor(klass, proc)
+      def register_config_processor(type, mime_type, processor = nil, &block)
+        processor ||= block
 
         self.config = hash_reassoc(config, type, mime_type) do |processors|
           processors.unshift(processor)
           processors
         end
-
-        compute_transformers!
       end
 
-      def unregister_config_processor(type, mime_type, klass)
-        if klass.is_a?(String) || klass.is_a?(Symbol)
-          klass = config[type][mime_type].detect do |cls|
-            cls.respond_to?(:name) && cls.name == "Sprockets::LegacyProcProcessor (#{klass})"
-          end
-        end
-
+      def unregister_config_processor(type, mime_type, processor)
         self.config = hash_reassoc(config, type, mime_type) do |processors|
-          processors.delete(klass)
+          processors.delete_if { |p| p == processor || p.class == processor }
           processors
         end
-
-        compute_transformers!
-      end
-
-      def deprecate_legacy_processor_interface(interface)
-        msg = "You are using a deprecated processor interface #{ interface.inspect }.\n" +
-        "Please update your processor interface:\n" +
-        "https://github.com/rails/sprockets/blob/master/guides/extending_sprockets.md#supporting-all-versions-of-sprockets-in-processors\n"
-
-        Deprecation.new([caller[3]]).warn msg
-      end
-
-      def wrap_processor(klass, proc)
-        if !proc
-          if klass.respond_to?(:call)
-            klass
-          else
-            deprecate_legacy_processor_interface(klass)
-            LegacyTiltProcessor.new(klass)
-          end
-        elsif proc.respond_to?(:arity) && proc.arity == 2
-          deprecate_legacy_processor_interface(proc)
-          LegacyProcProcessor.new(klass.to_s, proc)
-        else
-          proc
-        end
       end
   end
 end

data/lib/sprockets/processor_utils.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
 require 'set'
 
 module Sprockets
   # Functional utilities for dealing with Processor functions.
   #
-  # A Processor is a general function that my modify or transform an asset as
+  # A Processor is a general function that may modify or transform an asset as
   # part of the pipeline. CoffeeScript to JavaScript conversion, Minification
   # or Concatenation are all implemented as seperate Processor steps.
   #
@@ -16,26 +17,34 @@ module Sprockets
   module ProcessorUtils
     extend self
 
+    class CompositeProcessor < Struct.new(:processor_strategy, :param, :processors) # :nodoc:
+      SINGULAR = lambda { |param, input| ProcessorUtils.call_processor param, input }
+      PLURAL   = lambda { |param, input| ProcessorUtils.call_processors param, input }
+
+      def self.create(processors)
+        if processors.length == 1
+          new SINGULAR, processors.first, processors
+        else
+          new PLURAL, processors, processors
+        end
+      end
+
+      def call(input)
+        processor_strategy.call param, input
+      end
+
+      def cache_key
+        ProcessorUtils.processors_cache_keys(processors)
+      end
+    end
+
     # Public: Compose processors in right to left order.
     #
     # processors - Array of processors callables
     #
     # Returns a composed Proc.
     def compose_processors(*processors)
-      context = self
-
-      if processors.length == 1
-        obj = method(:call_processor).to_proc.curry[processors.first]
-      else
-        obj = method(:call_processors).to_proc.curry[processors]
-      end
-
-      metaclass = (class << obj; self; end)
-      metaclass.send(:define_method, :cache_key) do
-        context.processors_cache_keys(processors)
-      end
-
-      obj
+      CompositeProcessor.create processors
     end
 
     # Public: Invoke list of processors in right to left order.
@@ -152,29 +161,9 @@ module Sprockets
         if !key.instance_of?(Symbol)
           raise TypeError, "processor metadata[#{key.inspect}] expected to be a Symbol"
         end
-
-        if !valid_processor_metadata_value?(value)
-          raise TypeError, "processor metadata[:#{key}] returned a complex type: #{value.inspect}\n" +
-            "Only #{VALID_METADATA_TYPES.to_a.join(", ")} maybe used."
-        end
       end
 
       result
     end
-
-    # Internal: Validate object is in validate metadata whitelist.
-    #
-    # value - Any Object
-    #
-    # Returns true if class is in whitelist otherwise false.
-    def valid_processor_metadata_value?(value)
-      if VALID_METADATA_VALUE_TYPES_HASH[value.class]
-        true
-      elsif VALID_METADATA_COMPOUND_TYPES_HASH[value.class]
-        value.all? { |v| valid_processor_metadata_value?(v) }
-      else
-        false
-      end
-    end
   end
 end

data/lib/sprockets/resolve.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'set'
 require 'sprockets/http_utils'
 require 'sprockets/path_dependency_utils'
@@ -20,27 +21,21 @@ module Sprockets
     #     # => "file:///path/to/app/javascripts/application.coffee?type=application/javascript"
     #
     # The String Asset URI is returned or nil if no results are found.
-    def resolve(path, options = {})
-      path = path.to_s
-      paths = options[:load_paths] || config[:paths]
-      accept = options[:accept]
+    def resolve(path, load_paths: config[:paths], accept: nil, pipeline: nil, base_path: nil)
+      paths = load_paths
 
       if valid_asset_uri?(path)
         uri, deps = resolve_asset_uri(path)
       elsif absolute_path?(path)
         filename, type, deps = resolve_absolute_path(paths, path, accept)
       elsif relative_path?(path)
-        filename, type, pipeline, deps = resolve_relative_path(paths, path, options[:base_path], accept)
+        filename, type, path_pipeline, deps, index_alias = resolve_relative_path(paths, path, base_path, accept)
       else
-        filename, type, pipeline, deps = resolve_logical_path(paths, path, accept)
+        filename, type, path_pipeline, deps, index_alias = resolve_logical_path(paths, path, accept)
       end
 
       if filename
-        params = {}
-        params[:type] = type if type
-        params[:pipeline] = pipeline if pipeline
-        params[:pipeline] = options[:pipeline] if options[:pipeline]
-        uri = build_asset_uri(filename, params)
+        uri = build_asset_uri(filename, type: type, pipeline: pipeline || path_pipeline, index_alias: index_alias)
       end
 
       return uri, deps
@@ -48,19 +43,21 @@ module Sprockets
 
     # Public: Same as resolve() but raises a FileNotFound exception instead of
     # nil if no assets are found.
-    def resolve!(path, options = {})
-      uri, deps = resolve(path, options.merge(compat: false))
+    def resolve!(path, **kargs)
+      uri, deps = resolve(path, **kargs)
 
       unless uri
-        message = "couldn't find file '#{path}'"
+        message = +"couldn't find file '#{path}'"
 
-        if relative_path?(path) && options[:base_path]
-          load_path, _ = paths_split(config[:paths], options[:base_path])
+        if relative_path?(path) && kargs[:base_path]
+          load_path, _ = paths_split(config[:paths], kargs[:base_path])
           message << " under '#{load_path}'"
         end
 
-        message << " with type '#{options[:accept]}'" if options[:accept]
-        message << "\nChecked in these paths: \n  #{ config[:paths].join("\n  ") }"
+        message << " with type '#{kargs[:accept]}'" if kargs[:accept]
+
+        load_paths = kargs[:load_paths] || config[:paths]
+        message << "\nChecked in these paths: \n  #{ load_paths.join("\n  ") }"
 
         raise FileNotFound, message
       end
@@ -69,143 +66,230 @@ module Sprockets
     end
 
     protected
+
+      # Internal: Finds an asset given a URI
+      #
+      # uri - String. Contains file:// scheme, absolute path to
+      #       file.
+      #       e.g. "file:///Users/schneems/sprockets/test/fixtures/default/gallery.js?type=application/javascript"
+      #
+      # Returns Array. Contains a String uri and Set of dependencies
       def resolve_asset_uri(uri)
-        filename, _ = parse_asset_uri(uri)
-        return uri, Set.new([build_file_digest_uri(filename)])
+        filename, _ = URIUtils.parse_asset_uri(uri)
+        return uri, Set.new( [URIUtils.build_file_digest_uri(filename)] )
       end
 
+      # Internal: Finds a file in a set of given paths
+      #
+      # paths    - Array of Strings.
+      # filename - String containing absolute path to a file including extension.
+      #            e.g. "/Users/schneems/sprockets/test/fixtures/asset/application.js"
+      # accept   - String. A Quality value incoded set of
+      #            mime types that we are looking for. Can be nil.
+      #            e.g. "application/javascript" or "text/css, */*"
+      #
+      # Returns Array. Filename, type, path_pipeline, deps, index_alias
       def resolve_absolute_path(paths, filename, accept)
         deps = Set.new
         filename = File.expand_path(filename)
 
         # Ensure path is under load paths
-        return nil, nil, deps unless paths_split(paths, filename)
+        return nil, nil, deps unless PathUtils.paths_split(paths, filename)
 
-        _, mime_type, _, _ = parse_path_extnames(filename)
+        _, mime_type = PathUtils.match_path_extname(filename, config[:mime_exts])
         type = resolve_transform_type(mime_type, accept)
         return nil, nil, deps if accept && !type
 
         return nil, nil, deps unless file?(filename)
 
-        deps << build_file_digest_uri(filename)
+        deps << URIUtils.build_file_digest_uri(filename)
         return filename, type, deps
       end
 
+      # Internal: Finds a relative file in a set of given paths
+      #
+      # paths   - Array of Strings.
+      # path    - String. A relative filename with or without extension
+      #           e.g. "./jquery" or "../foo.js"
+      # dirname - String. Base path where we start looking for the given file.
+      # accept  - String. A Quality value incoded set of
+      #           mime types that we are looking for. Can be nil.
+      #           e.g. "application/javascript" or "text/css, */*"
+      #
+      # Returns Array. Filename, type, path_pipeline, deps, index_alias
       def resolve_relative_path(paths, path, dirname, accept)
         filename = File.expand_path(path, dirname)
-        load_path, _ = paths_split(paths, dirname)
-        if load_path && logical_path = split_subpath(load_path, filename)
+        load_path, _ = PathUtils.paths_split(paths, dirname)
+        if load_path && logical_path = PathUtils.split_subpath(load_path, filename)
           resolve_logical_path([load_path], logical_path, accept)
         else
-          return nil, nil, Set.new
+          return nil, nil, nil, Set.new
         end
       end
 
+      # Internal: Finds a file in a set of given paths
+      #
+      # paths        - Array of Strings.
+      # logical_path - String. A filename with extension
+      #                e.g. "coffee/foo.js" or "foo.js"
+      # accept       - String. A Quality value incoded set of
+      #                mime types that we are looking for. Can be nil.
+      #                e.g. "application/javascript" or "text/css, */*"
+      #
+      # Finds a file on the given paths.
+      #
+      # Returns Array. Filename, type, path_pipeline, deps, index_alias
       def resolve_logical_path(paths, logical_path, accept)
-        logical_name, mime_type, _, pipeline = parse_path_extnames(logical_path)
+        extname, mime_type = PathUtils.match_path_extname(logical_path, config[:mime_exts])
+        logical_name = logical_path.chomp(extname)
+
+        extname, pipeline = PathUtils.match_path_extname(logical_name, config[:pipeline_exts])
+        logical_name = logical_name.chomp(extname)
+
         parsed_accept = parse_accept_options(mime_type, accept)
         transformed_accepts = expand_transform_accepts(parsed_accept)
-        filename, mime_type, deps = resolve_under_paths(paths, logical_name, transformed_accepts)
+
+        filename, mime_type, deps, index_alias = resolve_under_paths(paths, logical_name, transformed_accepts)
 
         if filename
           deps << build_file_digest_uri(filename)
           type = resolve_transform_type(mime_type, parsed_accept)
-          return filename, type, pipeline, deps
+          return filename, type, pipeline, deps, index_alias
         else
           return nil, nil, nil, deps
         end
       end
 
+      # Internal: Finds a file in a set of given paths
+      #
+      # paths        - Array of Strings.
+      # logical_name - String. A filename without extension
+      #                e.g. "application" or "coffee/foo"
+      # accepts      - Array of array containing mime/version pairs
+      #                e.g. [["application/javascript", 1.0]]
+      #
+      # Finds a file with the same name as `logical_name` or "index" inside
+      # of the `logical_name` directory that matches a valid mime-type/version from
+      # `accepts`.
+      #
+      # Returns Array. Filename, type, dependencies, and index_alias
       def resolve_under_paths(paths, logical_name, accepts)
-        all_deps = Set.new
-        return nil, nil, all_deps if accepts.empty?
+        deps = Set.new
+        return nil, nil, deps if accepts.empty?
+
+        # TODO: Allow new path resolves to be registered
+        @resolvers ||= [
+          method(:resolve_main_under_path),
+          method(:resolve_alts_under_path),
+          method(:resolve_index_under_path)
+        ]
+        mime_exts = config[:mime_exts]
 
-        logical_basename = File.basename(logical_name)
         paths.each do |load_path|
-          candidates, deps = path_matches(load_path, logical_name, logical_basename)
-          all_deps.merge(deps)
-          candidate = find_best_q_match(accepts, candidates) do |c, matcher|
-            match_mime_type?(c[1] || "application/octet-stream", matcher)
+          candidates = []
+          @resolvers.each do |fn|
+            result = fn.call(load_path, logical_name, mime_exts)
+            candidates.concat(result[0])
+            deps.merge(result[1])
           end
-          return candidate + [all_deps] if candidate
-        end
 
-        return nil, nil, all_deps
-      end
-
-      def parse_accept_options(mime_type, types)
-        accepts = []
-        accepts += parse_q_values(types) if types
-
-        if mime_type
-          if accepts.empty? || accepts.any? { |accept, _| match_mime_type?(mime_type, accept) }
-            accepts = [[mime_type, 1.0]]
-          else
-            return []
+          candidate = HTTPUtils.find_best_q_match(accepts, candidates) do |c, matcher|
+            match_mime_type?(c[:type] || "application/octet-stream", matcher)
           end
+          return candidate[:filename], candidate[:type], deps, candidate[:index_alias] if candidate
         end
 
-        if accepts.empty?
-          accepts << ['*/*', 1.0]
-        end
-
-        accepts
+        return nil, nil, deps
       end
 
-      def path_matches(load_path, logical_name, logical_basename)
+      # Internal: Finds candidate files on a given path
+      #
+      # load_path    - String. An absolute path to a directory
+      # logical_name - String. A filename without extension
+      #                e.g. "application" or "coffee/foo"
+      # mime_exts    - Hash of file extensions and their mime types
+      #                e.g. {".xml.builder"=>"application/xml+builder"}
+      #
+      # Finds files that match a given `logical_name` with an acceptable
+      # mime type that is included in `mime_exts` on the `load_path`.
+      #
+      # Returns Array. First element is an Array of hashes or empty, second is a String
+      def resolve_main_under_path(load_path, logical_name, mime_exts)
         dirname    = File.dirname(File.join(load_path, logical_name))
-        candidates = dirname_matches(dirname, logical_basename)
-        deps       = file_digest_dependency_set(dirname)
-
-        result = resolve_alternates(load_path, logical_name)
-        result[0].each do |fn|
-          candidates << [fn, parse_path_extnames(fn)[1]]
+        candidates = self.find_matching_path_for_extensions(dirname, File.basename(logical_name), mime_exts)
+        candidates.map! do |c|
+          { filename: c[0], type: c[1] }
         end
-        deps.merge(result[1])
+        return candidates, [ URIUtils.build_file_digest_uri(dirname) ]
+      end
+
 
+      # Internal: Finds candidate index files in a given path
+      #
+      # load_path    - String. An absolute path to a directory
+      # logical_name - String. A filename without extension
+      #                e.g. "application" or "coffee/foo"
+      # mime_exts    - Hash of file extensions and their mime types
+      #                e.g. {".xml.builder"=>"application/xml+builder"}
+      #
+      # Looking in the given `load_path` this method will find all files under the `logical_name` directory
+      # that are named `index` and have a matching mime type in `mime_exts`.
+      #
+      # Returns Array. First element is an Array of hashes or empty, second is a String
+      def resolve_index_under_path(load_path, logical_name, mime_exts)
         dirname = File.join(load_path, logical_name)
-        if directory? dirname
-          result = dirname_matches(dirname, "index")
-          candidates.concat(result)
+
+        if self.directory?(dirname)
+          candidates = self.find_matching_path_for_extensions(dirname, "index".freeze, mime_exts)
+        else
+          candidates = []
         end
 
-        deps.merge(file_digest_dependency_set(dirname))
+        candidates.map! do |c|
+          { filename: c[0],
+            type: c[1],
+            index_alias: compress_from_root(c[0].sub(/\/index(\.[^\/]+)$/, '\1')) }
+        end
 
-        return candidates.select { |fn, _| file?(fn) }, deps
+        return candidates, [ URIUtils.build_file_digest_uri(dirname) ]
       end
 
-      def dirname_matches(dirname, basename)
-        candidates = []
-        entries = self.entries(dirname)
-        entries.each do |entry|
-          next unless File.basename(entry).start_with?(basename)
-          name, type, _, _ = parse_path_extnames(entry)
-          if basename == name
-            candidates << [File.join(dirname, entry), type]
-          end
+      def resolve_alts_under_path(load_path, logical_name, mime_exts)
+        filenames, deps = self.resolve_alternates(load_path, logical_name)
+        filenames.map! do |fn|
+          _, mime_type = PathUtils.match_path_extname(fn, mime_exts)
+          { filename: fn, type: mime_type }
         end
-        candidates
+        return filenames, deps
       end
 
-      def resolve_alternates(load_path, logical_name)
-        return [], Set.new
-      end
-
-      # Internal: Returns the name, mime type and `Array` of engine extensions.
+      # Internal: Converts mimetype into accept Array
       #
-      #     "foo.js.coffee.erb"
-      #     # => ["foo", "application/javascript", [".coffee", ".erb"]]
+      # - mime_type     - String, optional. e.g. "text/html"
+      # - explicit_type - String, optional. e.g. "application/javascript"
       #
-      def parse_path_extnames(path)
-        engines = []
-        extname, value = match_path_extname(path, extname_map)
-
-        if extname
-          path = path.chomp(extname)
-          type, engines, pipeline = value.values_at(:type, :engines, :pipeline)
+      # When called with an explicit_type and a mime_type, only a mime_type
+      # that matches the given explicit_type will be accepted.
+      #
+      # Returns Array of Array
+      #
+      #     [["application/javascript", 1.0]]
+      #     [["*/*", 1.0]]
+      #     []
+      def parse_accept_options(mime_type, explicit_type)
+        if mime_type
+          return [[mime_type, 1.0]] if explicit_type.nil?
+          return [[mime_type, 1.0]] if HTTPUtils.parse_q_values(explicit_type).any? { |accept, _| HTTPUtils.match_mime_type?(mime_type, accept) }
+          return []
         end
 
-        return path, type, engines, pipeline
+        accepts = HTTPUtils.parse_q_values(explicit_type)
+        accepts << ['*/*'.freeze, 1.0] if accepts.empty?
+        return accepts
+      end
+
+      def resolve_alternates(load_path, logical_name)
+        return [], Set.new
       end
   end
 end