sprockets-rails 3.0.0.beta1 → 3.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a7e8197def5c64d991abb7e4c18f4d8a4f0cc6ae
-  data.tar.gz: 5f50d295b072faf5d82391d0758b9582be53b3cc
+  metadata.gz: 25923aeac0b56b286d1fa13aed70e9473d34ead2
+  data.tar.gz: 9dfd806b0fd3a1839680622882d7a01db8670f44
 SHA512:
-  metadata.gz: 1ec86dc53e523a016d690cb201fe53e7b13d3c37144025059efbbedb311bd54b2c234ae4d159e9b76f600888b772038e0524f2288705ec83b08ede2896f665fa
-  data.tar.gz: ce22650daae7b6bfd3ecf93498c08bb064b4c01cb6b770a83acff558e654baf202af8cb8721242f73255a9d7a312eebed669f19d818ff5370e906a75be8bed14
+  metadata.gz: 5f8c7541800873483a0032d728d776c5578f770708d83804d8aa77ca41d709726af9a1db5c1ad2e600afd0995f506db10e2ebeda08c8a65de9aa9bc61d41c44e
+  data.tar.gz: b7888a09152ca3686aa43e5df660dacbfcf185162e87c3818cddc9aa0698ffb183b19a8a03c6a2c5a4af3aa4fac99bfdb80fddf23f1755c9543ee0cbac677be3

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012-2014 Joshua Peek
+Copyright (c) 2014 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,7 +46,7 @@ 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
@@ -60,10 +55,6 @@ Also see [Sprockets::Rails::Task](https://github.com/rails/sprockets-rails/blob/
 
 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.raise_runtime_errors`**
-
-Set to `true` to enable additional runtime error checking. Recommended in the `development` environment to minimize unexpected behavior when deploying to `production`.
-
 **`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.
@@ -90,8 +81,6 @@ Defines the full path to be used for the asset precompiler's manifest file. Defa
 **`config.assets.digest`**
 
 When enabled, fingerprints will be added to asset filenames.
-If `config.assets.raise_runtime_errors` is also enabled, requests for assets
-will raise an error unless they contain fingerprints.
 
 **`config.assets.debug`**
 
@@ -99,7 +88,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`**
 
@@ -139,6 +128,17 @@ The following plugins provide some extras for the Sprockets Asset Pipeline.
 * `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.
 
+## Experimental
+
+### [SRI](http://www.w3.org/TR/SRI/) support
+
+Sprockets 3.x adds experimental support for subresource integrity checks. The spec is still evolving and the API may change in backwards incompatible ways.
+
+``` ruby
+javascript_include_tag :application, integrity: true
+# => "<script src="/assets/application.js" integrity="sha-256-TvVUHzSfftWg1rcfL6TIJ0XKEGrgLyEq6lEpcmrG9qs="></script>"
+```
+
 
 ## Contributing
 
@@ -156,17 +156,17 @@ $ bundle exec rake test
 
 ## Releases
 
-sprockets-rails 2.x will primarily target sprockets 2.x. And future versions will target the corresponding sprockets release line.
+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/).
 
 * Any new APIs or config options that don't break compatibility will be in a minor release
-* Any time the sprockets depedency is bumped, there will be a new minor release
+* Any time the sprockets dependency is bumped, there will be a new minor release
 * Simple bug fixes will be patch releases
 
 
 ## License
 
-Copyright &copy; 2012 Joshua Peek.
+Copyright &copy; 2014 Joshua Peek.
 
 Released under the MIT license. See `LICENSE` for details.

data/lib/sprockets/rails/context.rb

@@ -0,0 +1,48 @@
+require 'action_view'
+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,122 +1,123 @@
 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
         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 = "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"
           super(msg)
         end
       end
 
       include ActionView::Helpers::AssetUrlHelper
       include ActionView::Helpers::AssetTagHelper
+      include Sprockets::Rails::Utils
 
       VIEW_ACCESSORS = [:assets_environment, :assets_manifest,
+                        :assets_precompile, :precompiled_assets,
                         :assets_prefix, :digest_assets, :debug_assets]
 
       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)
-
-        if digest_path = asset_digest_path(path)
+        if digest_path = asset_digest_path(path, options)
           path = digest_path if digest_assets
-          path += "?body=1" if options[:debug]
+          path += "?body=1" if options[:debug] && !using_sprockets4?
           File.join(assets_prefix || "/", path)
         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)
-        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
+      # 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
 
-        if digest_path = asset_digest_path(path, options)
-          digest_path[/-(.+)\./, 1]
+        if environment = assets_environment
+          if asset = environment[path]
+            unless options[:debug]
+              if !precompiled_assets.include?(asset.logical_path)
+                raise AssetNotPrecompiled.new(asset.logical_path)
+              end
+            end
+            return asset.digest_path
+          end
         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 = {})
+      # Returns String integrity attribute or nil if no asset was found.
+      def asset_integrity(path, options = {})
+        path = path.to_s
+        if extname = compute_asset_extname(path, options)
+          path = "#{path}#{extname}"
+        end
+
         if manifest = assets_manifest
           if digest_path = manifest.assets[path]
-            return digest_path
+            if metadata = manifest.files[digest_path]
+              return metadata["integrity"]
+            end
           end
         end
 
         if environment = assets_environment
           if asset = environment[path]
-            return asset.digest_path
+            return asset.integrity
           end
         end
+
+        nil
       end
 
       # Override javascript tag helper to provide debugging support.
@@ -125,20 +126,35 @@ module Sprockets
       def javascript_include_tag(*sources)
         options = sources.extract_options!.stringify_keys
 
+        unless request_ssl?
+          options.delete("integrity")
+        end
+
+        case options["integrity"]
+        when true, false, nil
+          compute_integrity = options.delete("integrity")
+        end
+
         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|
+            super(source, compute_integrity ?
+              options.merge("integrity" => asset_integrity(source, :type => :javascript)) :
+              options)
+          }.join("\n").html_safe
         end
       end
 
@@ -147,61 +163,42 @@ module Sprockets
       # Eventually will be deprecated and replaced by source maps.
       def stylesheet_link_tag(*sources)
         options = sources.extract_options!.stringify_keys
+
+        unless request_ssl?
+          options.delete("integrity")
+        end
+
+        case options["integrity"]
+        when true, false, nil
+          compute_integrity = options.delete("integrity")
+        end
+
         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|
+            super(source, compute_integrity ?
+              options.merge("integrity" => asset_integrity(source, :type => :stylesheet)) :
+              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
-        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
-
-          source = source.to_s
-          return if source.blank? || source =~ URI_REGEXP
-
-          asset = lookup_asset_for_path(source, options)
-
-          if asset && asset_needs_precompile?(asset.logical_path, asset.pathname.to_s)
-            raise AssetFilteredError.new(asset.logical_path)
-          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)
-            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
-          else
-            true
-          end
+        def request_ssl?
+          respond_to?(:request) && self.request && self.request.ssl?
         end
 
         # Enable split asset debugging. Eventually will be deprecated
@@ -214,13 +211,21 @@ module Sprockets
 
         # Internal method to support multifile debugging. Will
         # eventually be removed w/ Sprockets 3.x.
-        def lookup_asset_for_path(path, options = {})
+        def lookup_debug_asset(path, options = {})
           return unless env = assets_environment
           path = path.to_s
           if extname = compute_asset_extname(path, options)
             path = "#{path}#{extname}"
           end
-          env[path]
+
+          if asset = env[path, pipeline: :debug]
+            original_path = asset.logical_path.gsub('.debug', '')
+            unless precompiled_assets.include?(original_path)
+              raise AssetNotPrecompiled.new(original_path)
+            end
+          end
+
+          asset
         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,16 @@
+require 'sprockets'
+
+module Sprockets
+  module Rails
+    module Utils
+      def using_sprockets4?
+        Gem::Version.new(Sprockets::VERSION) >= Gem::Version.new('4.0.0')
+      end
+
+      # Internal: Generate a Set of all precompiled assets logical paths.
+      def build_precompiled_list(manifest, assets)
+        manifest.find(assets || []).map(&:logical_path)
+      end
+    end
+  end
+end

data/lib/sprockets/rails/version.rb

@@ -1,5 +1,5 @@
 module Sprockets
   module Rails
-    VERSION = "3.0.0.beta1"
+    VERSION = "3.0.0.beta2"
   end
 end

data/lib/sprockets/railtie.rb

@@ -2,9 +2,11 @@ require 'rails'
 require 'rails/railtie'
 require 'action_controller/railtie'
 require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/numeric/bytes'
 require 'sprockets'
-require 'sprockets/rails/environment'
+require 'sprockets/rails/context'
 require 'sprockets/rails/helper'
+require 'sprockets/rails/route_wrapper'
 require 'sprockets/rails/version'
 
 module Rails
@@ -19,27 +21,36 @@ module Rails
     remove_possible_method :assets
     remove_possible_method :assets=
 
-    # Returns Sprockets::Rails::Environment for app config.
-    def assets
-      @assets ||= Sprockets::Rails::Environment.new(root.to_s) do |env|
-        env.version = ::Rails.env
+    # Returns Sprockets::Environment for app config.
+    attr_accessor :assets
 
-        path = "#{config.root}/tmp/cache/assets/#{::Rails.env}"
-        env.cache = Sprockets::Cache::FileStore.new(path)
+    # Returns Sprockets::Manifest for app config.
+    attr_accessor :assets_manifest
 
-        env.context_class.class_eval do
-          include ::Sprockets::Rails::Helper
-        end
+    # Returns array of already precompiled assets
+    attr_accessor :precompiled_assets
+  end
+
+  class Engine < Railtie
+    # Skip defining append_assets_path on Rails <= 4.2
+    unless initializers.find { |init| init.name == :append_assets_path }
+      initializer :append_assets_path, :group => :all do |app|
+        app.config.assets.paths.unshift(*paths["vendor/assets"].existent_directories)
+        app.config.assets.paths.unshift(*paths["lib/assets"].existent_directories)
+        app.config.assets.paths.unshift(*paths["app"].existent_directories.grep(/\/assets\z/))
+        app.config.assets.paths.unshift(*paths["app/assets"].existent_directories)
       end
     end
-    attr_writer :assets
   end
 end
 
 module Sprockets
   class Railtie < ::Rails::Railtie
-    LOOSE_APP_ASSETS = lambda do |filename, path|
-      path =~ /app\/assets/ && !%w(.js .css).include?(File.extname(filename))
+    include Sprockets::Rails::Utils
+
+    LOOSE_APP_ASSETS = lambda do |logical_path, filename|
+        filename.start_with?(::Rails.root.join("app/assets").to_s) &&
+        !%w(.js .css).include?(File.extname(logical_path))
     end
 
     class OrderedOptions < ActiveSupport::OrderedOptions
@@ -49,88 +60,129 @@ module Sprockets
     end
 
     config.assets = OrderedOptions.new
-    config.assets._blocks    = []
-    config.assets.paths      = []
-    config.assets.prefix     = "/assets"
-    config.assets.manifest   = nil
-    config.assets.precompile = [LOOSE_APP_ASSETS, /(?:\/|\\|\A)application\.(css|js)$/]
-    config.assets.version    = ""
-    config.assets.debug      = false
-    config.assets.compile    = true
-    config.assets.digest     = false
+    config.assets._blocks     = []
+    config.assets.paths       = []
+    config.assets.prefix      = "/assets"
+    config.assets.manifest    = nil
+    if using_sprockets4?
+      config.assets.precompile  = %w( manifest.js )
+    else
+      config.assets.precompile  = [LOOSE_APP_ASSETS, /(?:\/|\\|\A)application\.(css|js)$/]
+    end
+    config.assets.version     = ""
+    config.assets.debug       = false
+    config.assets.compile     = true
+    config.assets.digest      = true
+    config.assets.cache_limit = 50.megabytes
+
+    config.assets.configure do |env|
+      config.assets.paths.each { |path| env.append_path(path) }
+    end
 
-    rake_tasks do |app|
-      require 'sprockets/rails/task'
-      Sprockets::Rails::Task.new(app)
+    config.assets.configure do |env|
+      env.js_compressor  = config.assets.js_compressor
+      env.css_compressor = config.assets.css_compressor
     end
 
-    config.after_initialize do |app|
-      config = app.config
+    config.assets.configure do |env|
+      env.context_class.send :include, ::Sprockets::Rails::Context
+      env.context_class.assets_prefix = config.assets.prefix
+      env.context_class.digest_assets = config.assets.digest
+      env.context_class.config        = config.action_controller
+    end
 
-      manifest_assets_path = File.join(config.paths['public'].first, config.assets.prefix)
-
-      # Configuration options that should invalidate
-      # the Sprockets cache when changed.
-      app.assets.version = [
-        app.assets.version,
-        config.assets.version,
-        config.action_controller.relative_url_root,
-        (config.action_controller.asset_host unless config.action_controller.asset_host.respond_to?(:call)),
-        Sprockets::Rails::VERSION
-      ].compact.join('-')
-
-      # Copy config.assets.paths to Sprockets
-      config.assets.paths.each do |path|
-        app.assets.append_path path
-      end
+    config.assets.configure do |env|
+      env.cache = Sprockets::Cache::FileStore.new(
+        "#{env.root}/tmp/cache",
+        config.assets.cache_limit,
+        env.logger
+      )
+    end
 
-      ActiveSupport.on_load(:action_view) do
-        include Sprockets::Rails::Helper
+    Sprockets.register_dependency_resolver 'rails-env' do
+      ::Rails.env
+    end
+    config.assets.configure do |env|
+      env.depend_on 'environment-version'
+    end
 
-        # Copy relevant config to AV context
-        self.debug_assets  = config.assets.debug
-        self.digest_assets = config.assets.digest
-        self.assets_prefix = config.assets.prefix
+    config.assets.configure do |env|
+      env.version = config.assets.version
+    end
 
-        # Copy over to Sprockets as well
-        context = app.assets.context_class
-        context.assets_prefix = config.assets.prefix
-        context.digest_assets = config.assets.digest
-        context.config        = config.action_controller
+    rake_tasks do |app|
+      require 'sprockets/rails/task'
+      Sprockets::Rails::Task.new(app)
+    end
 
-        if config.assets.compile
-          self.assets_environment = app.assets
-          self.assets_manifest    = Sprockets::Manifest.new(app.assets, manifest_assets_path, config.assets.manifest)
-        else
-          self.assets_manifest = Sprockets::Manifest.new(manifest_assets_path, config.assets.manifest)
-        end
+    def build_environment(app, initialized = nil)
+      initialized = app.initialized? if initialized.nil?
+      unless initialized
+        ::Rails.logger.warn "Application uninitialized: Try calling YourApp::Application.initialize!"
       end
 
-      app.assets.js_compressor  = config.assets.js_compressor
-      app.assets.css_compressor = config.assets.css_compressor
+      env = Sprockets::Environment.new(app.root.to_s)
 
       # Run app.assets.configure blocks
-      config.assets._blocks.each do |block|
-        block.call app.assets
+      app.config.assets._blocks.each do |block|
+        block.call(env)
       end
 
       # No more configuration changes at this point.
       # With cache classes on, Sprockets won't check the FS when files
       # change. Preferable in production when the FS only changes on
       # deploys when the app restarts.
-      if config.cache_classes
-        app.assets = app.assets.index
+      if app.config.cache_classes
+        env = env.cached
       end
 
+      env
+    end
+
+    def self.build_manifest(app)
+      config = app.config
+      path = File.join(config.paths['public'].first, config.assets.prefix)
+      Sprockets::Manifest.new(app.assets, path, config.assets.manifest)
+    end
 
-      Sprockets::Rails::Helper.precompile         ||= app.config.assets.precompile
-      Sprockets::Rails::Helper.assets             ||= app.assets
-      Sprockets::Rails::Helper.raise_runtime_errors = app.config.assets.raise_runtime_errors
+    config.after_initialize do |app|
+      config = app.config
 
       if config.assets.compile
+        app.assets = self.build_environment(app, true)
         app.routes.prepend do
           mount app.assets => config.assets.prefix
         end
+        app.assets_manifest = build_manifest(app)
+        app.precompiled_assets = build_precompiled_list(app.assets_manifest, config.assets.precompile)
+      else
+        app.assets_manifest = build_manifest(app)
+      end
+
+      ActionDispatch::Routing::RouteWrapper.class_eval do
+        class_attribute :assets_prefix
+
+        if defined?(prepend) && ::Rails.version >= '4'
+          prepend Sprockets::Rails::RouteWrapper
+        else
+          include Sprockets::Rails::RouteWrapper
+        end
+
+        self.assets_prefix = config.assets.prefix
+      end
+
+      ActiveSupport.on_load(:action_view) do
+        include Sprockets::Rails::Helper
+
+        # Copy relevant config to AV context
+        self.debug_assets      = config.assets.debug
+        self.digest_assets     = config.assets.digest
+        self.assets_prefix     = config.assets.prefix
+        self.assets_precompile = config.assets.precompile
+
+        self.assets_environment = app.assets
+        self.assets_manifest = app.assets_manifest
+        self.precompiled_assets = app.precompiled_assets
       end
     end
   end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: sprockets-rails
 version: !ruby/object:Gem::Version
-  version: 3.0.0.beta1
+  version: 3.0.0.beta2
 platform: ruby
 authors:
 - Joshua Peek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-19 00:00:00.000000000 Z
+date: 2015-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sprockets
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.8'
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -67,19 +81,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: railties
+  name: sass
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: uglifier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email: josh@joshpeek.com
 executables: []
@@ -89,9 +117,11 @@ files:
 - LICENSE
 - README.md
 - lib/sprockets/rails.rb
-- lib/sprockets/rails/environment.rb
+- lib/sprockets/rails/context.rb
 - lib/sprockets/rails/helper.rb
+- lib/sprockets/rails/route_wrapper.rb
 - lib/sprockets/rails/task.rb
+- lib/sprockets/rails/utils.rb
 - lib/sprockets/rails/version.rb
 - lib/sprockets/railtie.rb
 homepage: https://github.com/rails/sprockets-rails
@@ -106,7 +136,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">"
@@ -114,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.3.0
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: Sprockets Rails integration

data/lib/sprockets/rails/environment.rb

@@ -1,39 +0,0 @@
-require 'sprockets'
-require 'sprockets/rails/helper'
-
-module Sprockets
-  module Rails
-    class Environment < Sprockets::Environment
-      class NoDigestError < StandardError
-        def initialize(asset)
-          msg = "Assets should not be requested directly without their digests: " <<
-                "Use the helpers in ActionView::Helpers to request #{asset}"
-          super(msg)
-        end
-      end
-
-      def call(env)
-        if Sprockets::Rails::Helper.raise_runtime_errors && context_class.digest_assets
-          path = unescape(env['PATH_INFO'].to_s.sub(/^\//, ''))
-
-          if fingerprint = path_fingerprint(path)
-            path = path.sub("-#{fingerprint}", '')
-          else
-            raise NoDigestError.new(path)
-          end
-
-          asset = find_asset(path)
-          if asset && asset.digest != fingerprint
-            asset_path = File.join(context_class.assets_prefix || "/", asset.digest_path)
-            asset_path += '?' + env['QUERY_STRING'] if env['QUERY_STRING']
-            [302, {"Location" => asset_path}, []]
-          else
-            super(env)
-          end
-        else
-          super(env)
-        end
-      end
-    end
-  end
-end