sprockets-rails 2.3.2 → 3.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 480e5ad0e2f9fa910adadff1df528c2fdbdcd7ba
-  data.tar.gz: 13ffd578bddc43427ba93d2ee3d1cff0e120fcee
+SHA256:
+  metadata.gz: 801a6cbc13340fb4c74ecf9b7aa2d5c6c563605e3462512e0073f268e269fe8d
+  data.tar.gz: facde95b73f355f987059128c7f6d852b5b8845d26f2eca5214b4fc37ded168d
 SHA512:
-  metadata.gz: a4fadc3c38141890f8f6f6c8d9cb8053eb8444893e8657d280f90c1c222eee8948553760b7e564137bf08caa684df89fab9f1b7f391291c55ab4eea54dd3ad4b
-  data.tar.gz: 05ce457e78078a598d208915a24577a67d298b0ca3dd188be9efe9a9e72451110f5f9c3660820b97440501d6dc38ece225eca30a6fdf1fcbfef331db6d051770
+  metadata.gz: 7f6c2f179ba5b3294ad0b49357c4a7a50c207f221d6cbb5d9cad406b1143ee5ff9d5a71897f3f6a2bd9709eda8d5e5bad5380e4defa1e135700cc3edd9669749
+  data.tar.gz: cbd34277b1e2e89c5ddded1b616ce179a269e384f1781b7032972c966737803e725440f5a23951383adf6b4a8705b50a307eb94a2bd6055ab42dcfc505aa468c

data/{LICENSE → MIT-LICENSE}

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Joshua Peek
+Copyright (c) 2014-2016 Joshua Peek
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -27,7 +27,7 @@ Only removes old assets (keeps the most recent 3 copies) from `public/assets`. U
 
 **`rake assets:clobber`**
 
-Nuke `public/assets` and clear the Sprockets file system cache.
+Nuke `public/assets`.
 
 #### Customize
 
@@ -37,11 +37,6 @@ You can also redefine the task with the built in task generator.
 
 ``` ruby
 require 'sprockets/rails/task'
-# clean the old tasks
-Rake::Task["assets:environment"].clear
-Rake::Task["assets:precompile"].clear
-Rake::Task["assets:clean"].clear
-Rake::Task["assets:clobber"].clear
 Sprockets::Rails::Task.new(Rails.application) do |t|
   t.environment = lambda { Rails.application.assets }
   t.assets = %w( application.js application.css )
@@ -51,23 +46,25 @@ end
 
 Each asset task will invoke `assets:environment` first. By default this loads the Rails environment. You can override this task to add or remove dependencies for your specific compilation environment.
 
-Also see [Sprockets::Rails::Task](https://github.com/rails/sprockets-rails/blob/master/lib/sprockets/rails/task.rb) and [Rake::SprocketsTask](https://github.com/sstephenson/sprockets/blob/master/lib/rake/sprocketstask.rb).
-
+Also see [Sprockets::Rails::Task](https://github.com/rails/sprockets-rails/blob/master/lib/sprockets/rails/task.rb) and [Rake::SprocketsTask](https://github.com/rails/sprockets/blob/master/lib/rake/sprocketstask.rb).
 
 ### Initializer options
 
-**`config.assets.precompile`**
+**`config.assets.unknown_asset_fallback`**
 
-Add additional assets to compile on deploy. Defaults to `application.js`, `application.css` and any other non-js/css file under `app/assets`.
+When set to a truthy value, a result will be returned even if the requested asset is not found in the asset pipeline. When set to a falsey value it will raise an error when no asset is found in the pipeline. Defaults to `true`.
 
-**`config.assets.raise_runtime_errors`**
+**`config.assets.precompile`**
 
-Set to `true` to enable additional runtime error checking. Recommended in the `development` environment to minimize unexpected behavior when deploying to `production`.
+Add additional assets to compile on deploy. Defaults to `application.js`, `application.css` and any other non-js/css file under `app/assets`.
 
 **`config.assets.paths`**
 
 Add additional load paths to this Array. Rails includes `app/assets`, `lib/assets` and `vendor/assets` for you already. Plugins might want to add their custom paths to this.
 
+**`config.assets.quiet`**
+
+Suppresses logger output for asset requests. Uses the `config.assets.prefix` path to match asset requests. Defaults to `false`.
 
 **`config.assets.version`**
 
@@ -83,13 +80,9 @@ config.assets.version = 'v2'
 
 Defaults to `/assets`. Changes the directory to compile assets to.
 
-**`config.assets.manifest`**
-
-Defines the full path to be used for the asset precompiler's manifest file. Defaults to a randomly-generated filename in the `config.assets.prefix` directory within the public folder.
-
 **`config.assets.digest`**
 
-Link to undigest asset filenames. This option will eventually go away. Unless when `compile` is disabled.
+When enabled, fingerprints will be added to asset filenames.
 
 **`config.assets.debug`**
 
@@ -97,7 +90,7 @@ Enable expanded asset debugging mode. Individual files will be served to make re
 
 **`config.assets.compile`**
 
-Enables Sprockets compile environment. If disabled, `Rails.application.assets` will be unavailable to any ActionView helpers. View helpers will depend on assets being precompiled to `public/assets` in order to link to them. You can still access the environment by directly calling `Rails.application.assets`.
+Enables Sprockets compile environment. If disabled, `Rails.application.assets` will be `nil` to prevent inadvertent compilation calls. View helpers will depend on assets being precompiled to `public/assets` in order to link to them. Initializers expecting `Rails.application.assets` during boot should be accessing the environment in a `config.assets.configure` block. See below.
 
 **`config.assets.configure`**
 
@@ -105,18 +98,38 @@ Invokes block with environment when the environment is initialized. Allows direc
 
 ``` ruby
 config.assets.configure do |env|
-  env.js_compressor  = :uglify # or :closure, :yui
+  env.js_compressor  = :uglifier # or :closure, :yui
   env.css_compressor = :sass   # or :yui
 
   require 'my_processor'
   env.register_preprocessor 'application/javascript', MyProcessor
 
   env.logger = Rails.logger
-
-  env.cache = ActiveSupport::Cache::FileStore.new("tmp/cache/assets")
 end
 ```
 
+**`config.assets.resolve_with`**
+
+A list of `:environment` and `:manifest` symbols that defines the order that
+we try to find assets: manifest first, environment second? Manifest only?
+
+By default, we check the manifest first if asset digests are enabled and debug
+is not enabled, then we check the environment if compiling is enabled:
+```
+# Dev where debug is true, or digests are disabled
+%i[ environment ]
+
+# Dev default, or production with compile enabled.
+%i[ manifest environment ]
+
+# Production default.
+%i[ manifest ]
+```
+If the resolver list is empty (e.g. if debug is true and compile is false), the standard rails public path resolution will be used.
+
+**`config.assets.check_precompiled_asset`**
+
+When enabled, an exception is raised for missing assets. This option is enabled by default.
 
 ## Complementary plugins
 
@@ -125,36 +138,51 @@ The following plugins provide some extras for the Sprockets Asset Pipeline.
 * [coffee-rails](https://github.com/rails/coffee-rails)
 * [sass-rails](https://github.com/rails/sass-rails)
 
-**NOTE** That these plugins are optional. The core coffee-script, sass, less, uglify, (any many more) features are built into Sprockets itself. Many of these plugins only provide generators and extra helpers. You can probably get by without them.
+**NOTE** That these plugins are optional. The core coffee-script, sass, less, uglify, (and many more) features are built into Sprockets itself. Many of these plugins only provide generators and extra helpers. You can probably get by without them.
 
 
 ## Changes from Rails 3.x
 
 * Only compiles digest filenames. Static non-digest assets should simply live in public/.
 * Unmanaged asset paths and urls fallback to linking to public/. This should make it easier to work with both compiled assets and simple static assets. As a side effect, there will never be any "asset not precompiled errors" when linking to missing assets. They will just link to a public file which may or may not exist.
-* JS and CSS compressors must be explicitly set. Magic detection has been removed to avoid loading compressors in environments where you want to avoid loading any of the asset libraries. Assign `config.assets.js_compressor = :uglify` or `config.assets.css_compressor = :sass` for the standard compressors.
+* JS and CSS compressors must be explicitly set. Magic detection has been removed to avoid loading compressors in environments where you want to avoid loading any of the asset libraries. Assign `config.assets.js_compressor = :uglifier` or `config.assets.css_compressor = :sass` for the standard compressors.
 * The manifest file is now in a JSON format. Since it lives in public/ by default, the initial filename is also randomized to obfuscate public access to the resource.
 * `config.assets.manifest` (if used) must now include the manifest filename, e.g. `Rails.root.join('config/manifest.json')`. It cannot be a directory.
-* Two cleanup tasks. `rake assets:clean` is now a safe cleanup that only removes older assets that are no longer used. While `rake assets:clobber` nukes the entire `public/assets` directory and clears your filesystem cache. The clean task allows for rolling deploys that may still be linking to an old asset while the new assets are being built.
+* Two cleanup tasks: `rake assets:clean` is now a safe cleanup that only removes older assets that are no longer used, while `rake assets:clobber` nukes the entire `public/assets` directory. The clean task allows for rolling deploys that may still be linking to an old asset while the new assets are being built.
+
+### But what if I want sprockets to generate non-digest assets?
+
+You have several options:
+
+* Use the [non-digest-assets gem](https://github.com/mvz/non-digest-assets).
+* Use the [sprockets-redirect gem](https://github.com/sikachu/sprockets-redirect).
+* Use the [smart_assets gem](https://github.com/zarqman/smart_assets).
+* Create [a rake task](https://github.com/rails/sprockets-rails/issues/49#issuecomment-20535134) to pre-generate a non-digest version in `public/`.
 
+## Experimental
 
-## Contributing
+### [SRI](http://www.w3.org/TR/SRI/) support
 
-Usual bundler workflow.
+Sprockets 3.x adds experimental support for subresource integrity checks. The spec is still evolving and the API may change in backwards incompatible ways.
 
-``` shell
-$ git clone https://github.com/rails/sprockets-rails.git
-$ cd sprockets-rails/
-$ bundle install
-$ bundle exec rake test
+``` ruby
+javascript_include_tag :application, integrity: true
+# => "<script src="/assets/application.js" integrity="sha256-TvVUHzSfftWg1rcfL6TIJ0XKEGrgLyEq6lEpcmrG9qs="></script>"
 ```
 
-[![Build Status](https://secure.travis-ci.org/rails/sprockets-rails.png)](http://travis-ci.org/rails/sprockets-rails)
+Note that sprockets-rails only adds integrity hashes to assets when served in a secure context (over an HTTPS connection or localhost).
+
+
+## Contributing to Sprockets Rails
 
+Sprockets Rails is work of many contributors. You're encouraged to submit pull requests, propose
+features and discuss issues.
+
+See [CONTRIBUTING](CONTRIBUTING.md).
 
 ## Releases
 
-sprockets-rails 2.x will primarily target sprockets 2.x with future compatibility for 3.x. Consider upgrading to sprockets-rails 3.x to take full advantage of 3.x features.
+sprockets-rails 3.x will primarily target sprockets 3.x. And future versions will target the corresponding sprockets release line.
 
 The minor and patch version will be updated according to [semver](http://semver.org/).
 
@@ -162,9 +190,11 @@ The minor and patch version will be updated according to [semver](http://semver.
 * Any time the sprockets dependency is bumped, there will be a new minor release
 * Simple bug fixes will be patch releases
 
-
 ## License
 
-Copyright &copy; 2014 Joshua Peek.
+Sprockets Rails is released under the [MIT License](MIT-LICENSE).
+
+## Code Status
 
-Released under the MIT license. See `LICENSE` for details.
+* [![Travis CI](https://travis-ci.org/rails/sprockets-rails.svg?branch=master)](http://travis-ci.org/rails/sprockets-rails)
+* [![Gem Version](https://badge.fury.io/rb/sprockets-rails.svg)](http://badge.fury.io/rb/sprockets-rails)

data/lib/sprockets/rails/context.rb

@@ -0,0 +1,48 @@
+require 'action_view/helpers'
+require 'sprockets'
+
+module Sprockets
+  module Rails
+    module Context
+      include ActionView::Helpers::AssetUrlHelper
+      include ActionView::Helpers::AssetTagHelper
+
+      def self.included(klass)
+        klass.class_eval do
+          class_attribute :config, :assets_prefix, :digest_assets
+        end
+      end
+
+      def compute_asset_path(path, options = {})
+        @dependencies << 'actioncontroller-asset-url-config'
+
+        begin
+          asset_uri = resolve(path)
+        rescue FileNotFound
+          # TODO: eh, we should be able to use a form of locate that returns
+          # nil instead of raising an exception.
+        end
+
+        if asset_uri
+          asset = link_asset(path)
+          digest_path = asset.digest_path
+          path = digest_path if digest_assets
+          File.join(assets_prefix || "/", path)
+        else
+          super
+        end
+      end
+    end
+  end
+
+  register_dependency_resolver 'actioncontroller-asset-url-config' do |env|
+    config = env.context_class.config
+    [config.relative_url_root,
+    (config.asset_host unless config.asset_host.respond_to?(:call))]
+  end
+
+  # fallback to the default pipeline when using Sprockets 3.x
+  unless config[:pipelines].include? :debug
+    register_pipeline :debug, config[:pipelines][:default]
+  end
+end

data/lib/sprockets/rails/helper.rb

@@ -1,128 +1,132 @@
 require 'action_view'
 require 'sprockets'
 require 'active_support/core_ext/class/attribute'
+require 'sprockets/rails/utils'
 
 module Sprockets
   module Rails
     module Helper
-      class << self
-        attr_accessor :precompile, :assets, :raise_runtime_errors
-      end
-
-      def precompile
-        Sprockets::Rails::Helper.precompile
-      end
-
-      def assets
-        Sprockets::Rails::Helper.assets
-      end
-
-      def raise_runtime_errors
-        Sprockets::Rails::Helper.raise_runtime_errors
-      end
+      class AssetNotFound < StandardError; end
+      class AssetNotPrecompiled < StandardError; end
 
-      class AssetFilteredError < StandardError
+      class AssetNotPrecompiledError < AssetNotPrecompiled
+        include Sprockets::Rails::Utils
         def initialize(source)
-          msg = "Asset filtered out and will not be served: " <<
-                "add `Rails.application.config.assets.precompile += %w( #{source} )` " <<
-                "to `config/initializers/assets.rb` and restart your server"
-          super(msg)
-        end
-      end
-
-      class AbsoluteAssetPathError < ArgumentError
-        def initialize(bad_path, good_path, prefix)
-          msg = "Asset names passed to helpers should not include the #{prefix.inspect} prefix. " <<
-                "Instead of #{bad_path.inspect}, use #{good_path.inspect}"
+          msg =
+          if using_sprockets4?
+            "Asset `#{ source }` was not declared to be precompiled in production.\n" +
+            "Declare links to your assets in `app/assets/config/manifest.js`.\n\n" +
+            "  //= link #{ source }\n\n" +
+            "and restart your server"
+          else
+            "Asset was not declared to be precompiled in production.\n" +
+            "Add `Rails.application.config.assets.precompile += " +
+            "%w( #{source} )` to `config/initializers/assets.rb` and " +
+            "restart your server"
+          end
           super(msg)
         end
       end
 
-      if defined? ActionView::Helpers::AssetUrlHelper
-        include ActionView::Helpers::AssetUrlHelper
-        include ActionView::Helpers::AssetTagHelper
-      else
-        require 'sprockets/rails/legacy_asset_tag_helper'
-        require 'sprockets/rails/legacy_asset_url_helper'
-        include LegacyAssetTagHelper
-        include LegacyAssetUrlHelper
-      end
+      include ActionView::Helpers::AssetUrlHelper
+      include ActionView::Helpers::AssetTagHelper
+      include Sprockets::Rails::Utils
 
-      VIEW_ACCESSORS = [:assets_environment, :assets_manifest,
-                        :assets_prefix, :digest_assets, :debug_assets]
+      VIEW_ACCESSORS = [
+        :assets_environment, :assets_manifest,
+        :assets_precompile, :precompiled_asset_checker,
+        :assets_prefix, :digest_assets, :debug_assets,
+        :resolve_assets_with, :check_precompiled_asset,
+        :unknown_asset_fallback
+      ]
 
       def self.included(klass)
-        if klass < Sprockets::Context
-          klass.class_eval do
-            alias_method :assets_environment, :environment
-            def assets_manifest; end
-            class_attribute :config, :assets_prefix, :digest_assets, :debug_assets
+        klass.class_attribute(*VIEW_ACCESSORS)
+
+        klass.class_eval do
+          remove_method :assets_environment
+          def assets_environment
+            if instance_variable_defined?(:@assets_environment)
+              @assets_environment = @assets_environment.cached
+            elsif env = self.class.assets_environment
+              @assets_environment = env.cached
+            else
+              nil
+            end
           end
-        else
-          klass.class_attribute(*VIEW_ACCESSORS)
         end
       end
 
       def self.extended(obj)
-        obj.class_eval do
+        obj.singleton_class.class_eval do
           attr_accessor(*VIEW_ACCESSORS)
+
+          remove_method :assets_environment
+          def assets_environment
+            if env = @assets_environment
+              @assets_environment = env.cached
+            else
+              nil
+            end
+          end
         end
       end
 
+      # Writes over the built in ActionView::Helpers::AssetUrlHelper#compute_asset_path
+      # to use the asset pipeline.
       def compute_asset_path(path, options = {})
-        # Check if we are inside Sprockets context before calling check_dependencies!.
-        check_dependencies!(path) if defined?(depend_on)
+        debug = options[:debug]
 
-        if digest_path = asset_digest_path(path)
-          path = digest_path if digest_assets
-          path += "?body=1" if options[:debug]
-          File.join(assets_prefix || "/", path)
+        if asset_path = resolve_asset_path(path, debug)
+          File.join(assets_prefix || "/", legacy_debug_path(asset_path, debug))
         else
+          message =  "The asset #{ path.inspect } is not present in the asset pipeline.\n"
+          raise AssetNotFound, message unless unknown_asset_fallback
+
+          if respond_to?(:public_compute_asset_path)
+            message << "Falling back to an asset that may be in the public folder.\n"
+            message << "This behavior is deprecated and will be removed.\n"
+            message << "To bypass the asset pipeline and preserve this behavior,\n"
+            message << "use the `skip_pipeline: true` option.\n"
+
+            call_stack = Kernel.respond_to?(:caller_locations) && ::Rails::VERSION::MAJOR >= 5 ? caller_locations : caller
+            ActiveSupport::Deprecation.warn(message, call_stack)
+          end
           super
         end
       end
 
-      # Computes the full URL to a asset in the public directory. This
-      # method checks for errors before returning path.
-      def asset_path(source, options = {})
-        unless options[:debug]
-          check_errors_for(source, options)
+      # Resolve the asset path against the Sprockets manifest or environment.
+      # Returns nil if it's an asset we don't know about.
+      def resolve_asset_path(path, allow_non_precompiled = false) #:nodoc:
+        resolve_asset do |resolver|
+          resolver.asset_path path, digest_assets, allow_non_precompiled
         end
-        super(source, options)
       end
-      alias :path_to_asset :asset_path
 
-      # Get digest for asset path.
+      # Expand asset path to digested form.
       #
       # path    - String path
       # options - Hash options
       #
-      # Returns String Hex digest or nil if digests are disabled.
-      def asset_digest(path, options = {})
-        return unless digest_assets
-
-        if digest_path = asset_digest_path(path, options)
-          digest_path[/-(.+)\./, 1]
+      # Returns String path or nil if no asset was found.
+      def asset_digest_path(path, options = {})
+        resolve_asset do |resolver|
+          resolver.digest_path path, options[:debug]
         end
       end
 
-      # Expand asset path to digested form.
+      # Experimental: Get integrity for asset path.
       #
       # path    - String path
       # options - Hash options
       #
-      # Returns String path or nil if no asset was found.
-      def asset_digest_path(path, options = {})
-        if manifest = assets_manifest
-          if digest_path = manifest.assets[path]
-            return digest_path
-          end
-        end
+      # Returns String integrity attribute or nil if no asset was found.
+      def asset_integrity(path, options = {})
+        path = path_with_extname(path, options)
 
-        if environment = assets_environment
-          if asset = environment[path]
-            return asset.digest_path
-          end
+        resolve_asset do |resolver|
+          resolver.integrity path
         end
       end
 
@@ -131,21 +135,27 @@ module Sprockets
       # Eventually will be deprecated and replaced by source maps.
       def javascript_include_tag(*sources)
         options = sources.extract_options!.stringify_keys
+        integrity = compute_integrity?(options)
 
         if options["debug"] != false && request_debug_assets?
           sources.map { |source|
-            check_errors_for(source, :type => :javascript)
-            if asset = lookup_asset_for_path(source, :type => :javascript)
-              asset.to_a.map do |a|
-                super(path_to_javascript(a.logical_path, :debug => true), options)
+            if asset = lookup_debug_asset(source, type: :javascript)
+              if asset.respond_to?(:to_a)
+                asset.to_a.map do |a|
+                  super(path_to_javascript(a.logical_path, debug: true), options)
+                end
+              else
+                super(path_to_javascript(asset.logical_path, debug: true), options)
               end
             else
               super(source, options)
             end
           }.flatten.uniq.join("\n").html_safe
         else
-          sources.push(options)
-          super(*sources)
+          sources.map { |source|
+            options = options.merge('integrity' => asset_integrity(source, type: :javascript)) if integrity
+            super source, options
+          }.join("\n").html_safe
         end
       end
 
@@ -154,81 +164,214 @@ module Sprockets
       # Eventually will be deprecated and replaced by source maps.
       def stylesheet_link_tag(*sources)
         options = sources.extract_options!.stringify_keys
+        integrity = compute_integrity?(options)
+
         if options["debug"] != false && request_debug_assets?
           sources.map { |source|
-            check_errors_for(source, :type => :stylesheet)
-            if asset = lookup_asset_for_path(source, :type => :stylesheet)
-              asset.to_a.map do |a|
-                super(path_to_stylesheet(a.logical_path, :debug => true), options)
+            if asset = lookup_debug_asset(source, type: :stylesheet)
+              if asset.respond_to?(:to_a)
+                asset.to_a.map do |a|
+                  super(path_to_stylesheet(a.logical_path, debug: true), options)
+                end
+              else
+                super(path_to_stylesheet(asset.logical_path, debug: true), options)
               end
             else
               super(source, options)
             end
           }.flatten.uniq.join("\n").html_safe
         else
-          sources.push(options)
-          super(*sources)
+          sources.map { |source|
+            options = options.merge('integrity' => asset_integrity(source, type: :stylesheet)) if integrity
+            super source, options
+          }.join("\n").html_safe
         end
       end
 
       protected
-        # Ensures the asset is included in the dependencies list.
-        def check_dependencies!(dep)
-          depend_on(dep)
-          depend_on_asset(dep)
-        rescue Sprockets::FileNotFound
+        # This is awkward: `integrity` is a boolean option indicating whether
+        # we want to include or omit the subresource integrity hash, but the
+        # options hash is also passed through as literal tag attributes.
+        # That means we have to delete the shortcut boolean option so it
+        # doesn't bleed into the tag attributes, but also check its value if
+        # it's boolean-ish.
+        def compute_integrity?(options)
+          if secure_subresource_integrity_context?
+            case options['integrity']
+            when nil, false, true
+              options.delete('integrity') == true
+            end
+          else
+            options.delete 'integrity'
+            false
+          end
         end
 
-        # Raise errors when source is not in the precompiled list, or
-        # incorrectly contains the assets_prefix.
-        def check_errors_for(source, options)
-          return unless self.raise_runtime_errors
+        # Only serve integrity metadata for HTTPS requests:
+        #   http://www.w3.org/TR/SRI/#non-secure-contexts-remain-non-secure
+        def secure_subresource_integrity_context?
+          respond_to?(:request) && self.request && (self.request.local? || self.request.ssl?)
+        end
 
-          source = source.to_s
-          return if source.blank? || source =~ URI_REGEXP
+        # Enable split asset debugging. Eventually will be deprecated
+        # and replaced by source maps in Sprockets 3.x.
+        def request_debug_assets?
+          debug_assets || (defined?(controller) && controller && params[:debug_assets])
+        rescue # FIXME: what exactly are we rescuing?
+          false
+        end
 
-          asset = lookup_asset_for_path(source, options)
+        # Internal method to support multifile debugging. Will
+        # eventually be removed w/ Sprockets 3.x.
+        def lookup_debug_asset(path, options = {})
+          path = path_with_extname(path, options)
 
-          if asset && asset_needs_precompile?(asset.logical_path, asset.pathname.to_s)
-            raise AssetFilteredError.new(asset.logical_path)
+          resolve_asset do |resolver|
+            resolver.find_debug_asset path
           end
+        end
 
-          full_prefix = File.join(self.assets_prefix || "/", '')
-          if !asset && source.start_with?(full_prefix)
-            short_path = source[full_prefix.size, source.size]
-            if lookup_asset_for_path(short_path, options)
-              raise AbsoluteAssetPathError.new(source, short_path, full_prefix)
+        # compute_asset_extname is in AV::Helpers::AssetUrlHelper
+        def path_with_extname(path, options)
+          path = path.to_s
+          "#{path}#{compute_asset_extname(path, options)}"
+        end
+
+        # Try each asset resolver and return the first non-nil result.
+        def resolve_asset
+          asset_resolver_strategies.detect do |resolver|
+            if result = yield(resolver)
+              break result
             end
           end
         end
 
-        # Returns true when an asset will not be available after precompile is run
-        def asset_needs_precompile?(source, filename)
-          if assets_environment && assets_environment.send(:matches_filter, precompile || [], source, filename)
-            false
+        # List of resolvers in `config.assets.resolve_with` order.
+        def asset_resolver_strategies
+          @asset_resolver_strategies ||=
+            Array(resolve_assets_with).map do |name|
+              HelperAssetResolvers[name].new(self)
+            end
+        end
+
+        # Append ?body=1 if debug is on and we're on old Sprockets.
+        def legacy_debug_path(path, debug)
+          if debug && !using_sprockets4?
+            "#{path}?body=1"
           else
-            true
+            path
           end
         end
+    end
 
-        # Enable split asset debugging. Eventually will be deprecated
-        # and replaced by source maps in Sprockets 3.x.
-        def request_debug_assets?
-          debug_assets || (defined?(controller) && controller && params[:debug_assets])
-        rescue
-          return false
+    # Use a separate module since Helper is mixed in and we needn't pollute
+    # the class namespace with our internals.
+    module HelperAssetResolvers #:nodoc:
+      def self.[](name)
+        case name
+        when :manifest
+          Manifest
+        when :environment
+          Environment
+        else
+          raise ArgumentError, "Unrecognized asset resolver: #{name.inspect}. Expected :manifest or :environment"
         end
+      end
 
-        # Internal method to support multifile debugging. Will
-        # eventually be removed w/ Sprockets 3.x.
-        def lookup_asset_for_path(path, options = {})
-          return unless env = assets_environment
-          path = path.to_s
-          if extname = compute_asset_extname(path, options)
-            path = "#{path}#{extname}"
+      class Manifest #:nodoc:
+        def initialize(view)
+          @manifest = view.assets_manifest
+          raise ArgumentError, 'config.assets.resolve_with includes :manifest, but app.assets_manifest is nil' unless @manifest
+        end
+
+        def asset_path(path, digest, allow_non_precompiled = false)
+          if digest
+            digest_path path, allow_non_precompiled
+          end
+        end
+
+        def digest_path(path, allow_non_precompiled = false)
+          @manifest.assets[path]
+        end
+
+        def integrity(path)
+          if meta = metadata(path)
+            meta["integrity"]
+          end
+        end
+
+        def find_debug_asset(path)
+          nil
+        end
+
+        private
+          def metadata(path)
+            if digest_path = digest_path(path)
+              @manifest.files[digest_path]
+            end
+          end
+      end
+
+      class Environment #:nodoc:
+        def initialize(view)
+          raise ArgumentError, 'config.assets.resolve_with includes :environment, but app.assets is nil' unless view.assets_environment
+          @env = view.assets_environment
+          @precompiled_asset_checker = view.precompiled_asset_checker
+          @check_precompiled_asset = view.check_precompiled_asset
+        end
+
+        def asset_path(path, digest, allow_non_precompiled = false)
+          # Digests enabled? Do the work to calculate the full asset path.
+          if digest
+            digest_path path, allow_non_precompiled
+
+          # Otherwise, ask the Sprockets environment whether the asset exists
+          # and check whether it's also precompiled for production deploys.
+          elsif asset = find_asset(path)
+            raise_unless_precompiled_asset asset.logical_path unless allow_non_precompiled
+            path
+          end
+        end
+
+        def digest_path(path, allow_non_precompiled = false)
+          if asset = find_asset(path)
+            raise_unless_precompiled_asset asset.logical_path unless allow_non_precompiled
+            asset.digest_path
+          end
+        end
+
+        def integrity(path)
+          find_asset(path).try :integrity
+        end
+
+        def find_debug_asset(path)
+          if asset = find_asset(path, pipeline: :debug)
+            raise_unless_precompiled_asset asset.logical_path.sub('.debug', '')
+            asset
           end
-          env[path]
         end
+
+        private
+          if RUBY_VERSION >= "2.7"
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def find_asset(path, options = {})
+                @env[path, **options]
+              end
+            RUBY
+          else
+            def find_asset(path, options = {})
+              @env[path, options]
+            end
+          end
+
+          def precompiled?(path)
+            @precompiled_asset_checker.call path
+          end
+
+          def raise_unless_precompiled_asset(path)
+            raise Helper::AssetNotPrecompiled.new(path) if @check_precompiled_asset && !precompiled?(path)
+          end
+      end
     end
   end
 end