Remove engines

Author: josh

lib/sprockets.rb

@@ -43,8 +43,6 @@ module Sprockets
     dependencies: Set.new.freeze,
     dependency_resolvers: {}.freeze,
     digest_class: Digest::SHA256,
-    engine_mime_types: {}.freeze,
-    engines: {}.freeze,
     mime_exts: {}.freeze,
     mime_types: {}.freeze,
     paths: [].freeze,
@@ -159,14 +157,14 @@ module Sprockets
   register_transformer 'text/coffeescript', 'application/javascript', autoload_processor(:CoffeeScriptProcessor, 'sprockets/coffee_script_processor')
   register_preprocessor 'text/coffeescript', DirectiveProcessor.new(comments: ["#", ["###", "###"]])
 
-  # JST engines
+  # JST processors
   register_mime_type 'text/eco', extensions: ['.eco', '.jst.eco']
   register_mime_type 'text/ejs', extensions: ['.ejs', '.jst.ejs']
   register_transformer 'text/eco', 'application/javascript+function', autoload_processor(:EcoProcessor, 'sprockets/eco_processor')
   register_transformer 'text/ejs', 'application/javascript+function', autoload_processor(:EjsProcessor, 'sprockets/ejs_processor')
   register_transformer 'application/javascript+function', 'application/javascript', autoload_processor(:JstProcessor, 'sprockets/jst_processor')
 
-  # CSS engines
+  # CSS processors
   register_mime_type 'text/sass', extensions: ['.sass', '.css.sass']
   register_mime_type 'text/scss', extensions: ['.scss', '.css.scss']
   register_mime_type 'text/sass+ruby', extensions: ['.sass.erb', '.css.sass.erb']

lib/sprockets/configuration.rb

@@ -1,6 +1,5 @@
 require 'sprockets/compressing'
 require 'sprockets/dependencies'
-require 'sprockets/engines'
 require 'sprockets/mime'
 require 'sprockets/paths'
 require 'sprockets/processing'
@@ -9,7 +8,7 @@
 
 module Sprockets
   module Configuration
-    include Paths, Mime, Engines, Transformers, Processing, Compressing, Dependencies, Utils
+    include Paths, Mime, Transformers, Processing, Compressing, Dependencies, Utils
 
     def initialize_configuration(parent)
       @config = parent.config

lib/sprockets/engines.rb

@@ -1,6 +1,5 @@
 require 'sprockets/asset'
 require 'sprockets/digest_utils'
-require 'sprockets/engines'
 require 'sprockets/errors'
 require 'sprockets/file_reader'
 require 'sprockets/mime'
@@ -16,7 +15,7 @@ module Sprockets
   # object.
   module Loader
     include DigestUtils, PathUtils, ProcessorUtils, URIUtils
-    include Engines, Mime, Processing, Resolve, Transformers
+    include Mime, Processing, Resolve, Transformers
 
     # Public: Load Asset by AssetURI.
     #
@@ -77,7 +76,7 @@ def load_asset_by_uri(uri, filename, params)
           raise FileOutsidePaths, "#{filename} is no longer under a load path: #{self.paths.join(', ')}"
         end
 
-        logical_path, file_type, engine_extnames = parse_path_extnames(logical_path)
+        logical_path, file_type = parse_path_extnames(logical_path)
         logical_path = normalize_logical_path(logical_path)
         name = logical_path
 
@@ -90,9 +89,9 @@ def load_asset_by_uri(uri, filename, params)
         end
 
         skip_bundle = params[:skip_bundle]
-        processors = processors_for(type, file_type, engine_extnames, skip_bundle)
+        processors = processors_for(type, file_type, skip_bundle)
 
-        processors_dep_uri = build_processors_uri(type, file_type, engine_extnames, skip_bundle)
+        processors_dep_uri = build_processors_uri(type, file_type, skip_bundle)
         dependencies = self.dependencies + [processors_dep_uri]
 
         # Read into memory and process if theres a processor pipeline

lib/sprockets/loader.rb

@@ -60,10 +60,6 @@ def register_mime_type(mime_type, extensions: [], charset: nil)
         type[:charset] = charset if charset
         mime_types.merge(mime_type => type)
       end
-
-      self.config = hash_reassoc(config, :_extnames) do
-        compute_extname_map
-      end
     end
 
     # Internal: Get detecter function for MIME type.
@@ -95,22 +91,5 @@ def read_file(filename, content_type = nil)
         data
       end
     end
-
-    private
-      def compute_extname_map
-        graph = {}
-
-        ([[nil, nil]] + mime_exts.to_a).each do |format_extname, format_type|
-          3.times do |n|
-            engines.keys.permutation(n).each do |engine_extnames|
-              key = "#{format_extname}#{engine_extnames.join}"
-              type = format_type || engine_mime_types[engine_extnames.first]
-              graph[key] = {type: type, engines: engine_extnames}
-            end
-          end
-        end
-
-        graph
-      end
   end
 end

lib/sprockets/mime.rb

@@ -1,5 +1,4 @@
 require 'source_map'
-require 'sprockets/engines'
 require 'sprockets/mime'
 require 'sprockets/processor_utils'
 require 'sprockets/uri_utils'
@@ -177,23 +176,20 @@ def process_bundle_reducers(assets, reducers)
     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[:skip_bundle])
+        processors = processors_for(params[:type], params[:file_type], params[:skip_bundle])
         processors_cache_keys(processors)
       end
 
-      def build_processors_uri(type, file_type, engine_extnames, skip_bundle)
-        engines = engine_extnames.join(',') if engine_extnames.any?
+      def build_processors_uri(type, file_type, skip_bundle)
         query = encode_uri_query_params(
           type: type,
           file_type: file_type,
-          engines: engines,
           skip_bundle: skip_bundle
         )
         "processors:#{query}"
       end
 
-      def processors_for(type, file_type, engine_extnames, skip_bundle)
+      def processors_for(type, file_type, skip_bundle)
         processors = []
 
         bundled_processors = skip_bundle ? [] : config[:bundle_processors][type]
@@ -202,12 +198,9 @@ def processors_for(type, file_type, engine_extnames, skip_bundle)
           processors.concat bundled_processors
         else
           processors.concat config[:postprocessors][type]
-
           if type != file_type && processor = transformers[file_type][type]
             processors << processor
           end
-
-          processors.concat engine_extnames.map { |ext| engines[ext] }
           processors.concat config[:preprocessors][file_type]
         end
 

lib/sprockets/processing.rb

@@ -62,7 +62,7 @@ def resolve_absolute_path(paths, filename, accept, skip_bundle)
         # Ensure path is under load paths
         return nil, deps unless paths_split(paths, filename)
 
-        mime_type = parse_path_extnames(filename)[1]
+        _, mime_type = match_path_extname(filename, mime_exts)
         type = resolve_transform_type(mime_type, accept)
         return nil, deps if accept && !type
 
@@ -84,7 +84,7 @@ def resolve_relative_path(paths, path, dirname, accept, skip_bundle)
       end
 
       def resolve_logical_path(paths, logical_path, accept, skip_bundle)
-        logical_name, mime_type, _ = parse_path_extnames(logical_path)
+        logical_name, mime_type = parse_path_extnames(logical_path)
         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)
@@ -151,7 +151,7 @@ def path_matches(load_path, logical_name, logical_basename)
 
         result = resolve_alternates(load_path, logical_name)
         result[0].each do |fn|
-          candidates << [fn, parse_path_extnames(fn)[1]]
+          candidates << [fn, match_path_extname(fn, mime_exts)[1]]
         end
         deps.merge(result[1])
 
@@ -166,7 +166,7 @@ def dirname_matches(dirname, basename)
         candidates = []
         entries, deps = self.entries_with_dependencies(dirname)
         entries.each do |entry|
-          name, type, _ = parse_path_extnames(entry)
+          name, type = parse_path_extnames(entry)
           if basename == name
             candidates << [File.join(dirname, entry), type]
           end
@@ -178,18 +178,18 @@ def resolve_alternates(load_path, logical_name)
         return [], Set.new
       end
 
-      # Internal: Returns the name, mime type and `Array` of engine extensions.
+      # Internal: Returns the name and mime type.
       #
       #     "foo.coffee.erb"
-      #     # => ["foo", "application/javascript", [".coffee", ".erb"]]
+      #     # => ["foo", "application/javascript"]
       #
       def parse_path_extnames(path)
-        extname, value = match_path_extname(path, config[:_extnames])
+        extname, type = match_path_extname(path, mime_exts)
         if extname
           name = path[0...-extname.length]
-          return name, value[:type], value[:engines]
+          return name, type
         else
-          return path, nil, []
+          return path, nil
         end
       end
   end

lib/sprockets/resolve.rb

@@ -952,7 +952,7 @@ def setup
     assert_equal "application/javascript", asset.content_type
   end
 
-  test "asset falls back to engines default mime type" do
+  test "asset falls back to files default mime type" do
     asset = asset("default_mime_type.js")
     assert_equal "application/javascript", asset.content_type
   end

test/fixtures/engines/hello.alert

@@ -26,7 +26,6 @@ def test_entries
       "default",
       "directives",
       "encoding",
-      "engines",
       "errors",
       "octicons",
       "paths",