sprockets-rails 2.3.3 → 3.0.0

data/lib/sprockets/rails/helper.rb

@@ -1,128 +1,119 @@
 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 AssetFilteredError < StandardError
+      class AssetNotPrecompiled < StandardError
+        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 `assets/config/manifest.js`.\n" +
+            "Examples:\n" +
+            "`//= link ../javascripts/application.js`\n" +
+            "`//= link_directory ../javascripts .js`\n" +
+            "`//= link_directory ../stylesheets .css`\n" +
+            "`//= link_tree ../javascripts .js`\n" +
+            "`//= link_tree ../images`\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
+      ]
 
       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
           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
 
       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
           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 +122,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 +151,205 @@ 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.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
+
+        # 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
 
-          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)
+        # 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
+        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 find_asset(path)
+            raise_unless_precompiled_asset 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 path unless allow_non_precompiled
+            asset.digest_path
           end
-          env[path]
         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
+        end
+
+        private
+          def find_asset(path, options = {})
+            @env[path, options]
+          end
+
+          def precompiled?(path)
+            @precompiled_asset_checker.call path
+          end
+
+          def raise_unless_precompiled_asset(path)
+            raise Helper::AssetNotPrecompiled.new(path) unless precompiled?(path)
+          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/task.rb

@@ -16,7 +16,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 +26,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 +49,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 +71,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 +80,6 @@ module Sprockets
           task :clobber => :environment do
             with_logger do
               manifest.clobber
-              rm_rf cache_path if cache_path
             end
           end
         end

data/lib/sprockets/rails/utils.rb

@@ -0,0 +1,11 @@
+require 'sprockets'
+
+module Sprockets
+  module Rails
+    module Utils
+      def using_sprockets4?
+        Gem::Version.new(Sprockets::VERSION) >= Gem::Version.new('4.0.0')
+      end
+    end
+  end
+end

data/lib/sprockets/rails/version.rb

@@ -1,5 +1,5 @@
 module Sprockets
   module Rails
-    VERSION = "2.3.3"
+    VERSION = "3.0.0"
   end
 end