sprockets-rails 2.3.2 → 3.4.2

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::AssetNotPrecompiledError.new(path) if @check_precompiled_asset && !precompiled?(path)
+          end
+      end
     end
   end
 end

data/lib/sprockets/rails/quiet_assets.rb

@@ -0,0 +1,18 @@
+module Sprockets
+  module Rails
+    class QuietAssets
+      def initialize(app)
+        @app = app
+        @assets_regex = %r(\A/{0,2}#{::Rails.application.config.assets.prefix})
+      end
+
+      def call(env)
+        if env['PATH_INFO'] =~ @assets_regex
+          ::Rails.logger.silence { @app.call(env) }
+        else
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/rails/route_wrapper.rb

@@ -0,0 +1,23 @@
+module Sprockets
+  module Rails
+    module RouteWrapper
+
+      def internal_assets_path?
+        path =~ %r{\A#{self.class.assets_prefix}\z}
+      end
+
+      def internal?
+        super || internal_assets_path?
+      end
+
+      def self.included(klass)
+        klass.class_eval do
+          def internal_with_sprockets?
+            internal_without_sprockets? || internal_assets_path?
+          end
+          alias_method_chain :internal?, :sprockets
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/rails/sourcemapping_url_processor.rb

@@ -0,0 +1,54 @@
+module Sprockets
+  module Rails
+    # Rewrites source mapping urls with the digested paths and protect against semicolon appending with a dummy comment line
+    class SourcemappingUrlProcessor
+      REGEX = /\/\/# sourceMappingURL=(.*\.map)/
+
+      class << self
+        def call(input)
+          env     = input[:environment]
+          context = env.context_class.new(input)
+          data    = input[:data].gsub(REGEX) do |_match|
+            sourcemap_logical_path = combine_sourcemap_logical_path(sourcefile: input[:name], sourcemap: $1)
+
+            begin
+              resolved_sourcemap_comment(sourcemap_logical_path, context: context)
+            rescue Sprockets::FileNotFound
+              removed_sourcemap_comment(sourcemap_logical_path, filename: input[:filename], env: env)
+            end
+          end
+
+          { data: data }
+        end
+
+        private
+          def combine_sourcemap_logical_path(sourcefile:, sourcemap:)
+            if (parts = sourcefile.split("/")).many?
+              parts[0..-2].append(sourcemap).join("/")
+            else
+              sourcemap
+            end
+          end
+
+          def resolved_sourcemap_comment(sourcemap_logical_path, context:)
+            "//# sourceMappingURL=#{sourcemap_asset_path(sourcemap_logical_path, context: context)}\n//!\n"
+          end
+
+          def sourcemap_asset_path(sourcemap_logical_path, context:)
+            # FIXME: Work-around for bug where if the sourcemap is nested two levels deep, it'll resolve as the source file
+            # that's being mapped, rather than the map itself. So context.resolve("a/b/c.js.map") will return "c.js?"
+            if context.resolve(sourcemap_logical_path) =~ /\.map/
+              context.asset_path(sourcemap_logical_path)
+            else
+              raise Sprockets::FileNotFound, "Failed to resolve source map asset due to nesting depth"
+            end
+          end
+
+          def removed_sourcemap_comment(sourcemap_logical_path, filename:, env:)
+            env.logger.warn "Removed sourceMappingURL comment for missing asset '#{sourcemap_logical_path}' from #{filename}"
+            nil
+          end
+      end
+    end
+  end
+end

data/lib/sprockets/rails/task.rb

@@ -2,7 +2,6 @@ require 'rake'
 require 'rake/sprocketstask'
 require 'sprockets'
 require 'action_view'
-require 'action_view/base'
 
 module Sprockets
   module Rails
@@ -16,7 +15,9 @@ module Sprockets
 
       def environment
         if app
-          app.assets
+          # Use initialized app.assets or force build an environment if
+          # config.assets.compile is disabled
+          app.assets || Sprockets::Railtie.build_environment(app)
         else
           super
         end
@@ -24,7 +25,8 @@ module Sprockets
 
       def output
         if app
-          File.join(app.root, 'public', app.config.assets.prefix)
+          config = app.config
+          File.join(config.paths['public'].first, config.assets.prefix)
         else
           super
         end
@@ -46,17 +48,12 @@ module Sprockets
         end
       end
 
-      def cache_path
-        if app
-          "#{app.config.root}/tmp/cache/assets"
-        else
-          @cache_path
-        end
-      end
-      attr_writer :cache_path
-
       def define
         namespace :assets do
+          %w( environment precompile clean clobber ).each do |task|
+            Rake::Task[task].clear if Rake::Task.task_defined?(task)
+          end
+
           # Override this task change the loaded dependencies
           desc "Load asset compile environment"
           task :environment do
@@ -73,9 +70,8 @@ module Sprockets
 
           desc "Remove old compiled assets"
           task :clean, [:keep] => :environment do |t, args|
-            keep = Integer(args.keep || 2)
             with_logger do
-              manifest.clean(keep)
+              manifest.clean(Integer(args.keep || self.keep))
             end
           end
 
@@ -83,7 +79,6 @@ module Sprockets
           task :clobber => :environment do
             with_logger do
               manifest.clobber
-              rm_rf cache_path if cache_path
             end
           end
         end