Match Dev Asset Experience to Production

Rails is opinionated about how assets should be served in production. In Production assets should be precompiled and then served directly from the public directory. If an asset is not precompiled, than a 404 will be served instead which can render a site useless if an asset is missing. 

In development if an asset is __NOT__ flagged to be precompiled (`config.assets.precompile`), and you reference a file:

```ruby
<%= asset_path('search.js') %>
```

Then rails will render the file anyway giving the illusion that the your development code is correct although it will fail in production. 

This PR improves the production experience by raising errors in development. When an asset is referenced via `asset_path` or `asset_url` an error will be raised in non production environments when the asset is not flagged to be precompiled:

```ruby
Asset filtered out and will not be served: add `config.assets.precompile += %w( foo.js )` to `config/application.rb` and restart your server
```

This change only affects the user facing methods, the auto concatenation feature for javascript and CSS will still function correctly in debug mode.

Assets behaving differently in dev and prod is the number one source of invalid support tickets for Heroku. Since the file displays correctly on their machine locally in development, the production problem is incorrectly attributed to a system problem. Once the source of the problem is identified identified it can be difficult to find the exact file with the problem on systems with many assets. This PR will reduce the chances of deploying broken assets to production by increasing visibility into correct behavior in development.

This PR introduces a new config flag:


```
# Development
config.assets.raise_runtime_errors = true

# Test
config.assets.raise_runtime_errors = false

# Production
config.assets.raise_runtime_errors = false
```

Author: schneems

CHANGELOG.md

@@ -1,3 +1,11 @@
+### Master
+
+*   Assets not in the precompile list can be checked for errors by setting
+     `config.assets.raise_runtime_errors  = true` in any environment
+
+     *Richard Schneeman*
+
+
 ### 2.0.1
 
 *   Allow keep value to be specified for `assets:clean` run with args

lib/sprockets/rails/helper.rb

@@ -8,7 +8,7 @@ module Helper
       # support for Ruby 1.9.3 && Rails 3.0.x
       @_config = ActiveSupport::InheritableOptions.new({}) unless defined?(ActiveSupport::Configurable::Configuration)
       include ActiveSupport::Configurable
-      config_accessor :raise_runtime_errors
+      config_accessor :precompile, :assets, :raise_runtime_errors
 
       class DependencyError < StandardError
         def initialize(path, dep)
@@ -18,6 +18,15 @@ def initialize(path, dep)
         end
       end
 
+      class AssetFilteredError < StandardError
+        def initialize(source)
+          msg = "Asset filtered out and will not be served: " <<
+                "add `config.assets.precompile += %w( #{source} )` " <<
+                "to `config/application.rb` and restart your server"
+          super(msg)
+        end
+      end
+
       if defined? ActionView::Helpers::AssetUrlHelper
         include ActionView::Helpers::AssetUrlHelper
         include ActionView::Helpers::AssetTagHelper
@@ -62,6 +71,21 @@ def compute_asset_path(path, options = {})
         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 = {})
+        check_errors_for(source)
+        path_to_asset(source, options)
+      end
+      alias :path_to_asset_with_errors :asset_path
+
+      # Computes the full URL to a asset in the public directory. This
+      # will use +asset_path+ internally, so most of their behaviors
+      # will be the same.
+      def asset_url(source, options = {})
+        path_to_asset_with_errors(source, options.merge(:protocol => :request))
+      end
+
       # Get digest for asset path.
       #
       # path    - String path
@@ -104,6 +128,7 @@ def javascript_include_tag(*sources)
 
         if options["debug"] != false && request_debug_assets?
           sources.map { |source|
+            check_errors_for(source)
             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)
@@ -123,9 +148,9 @@ def javascript_include_tag(*sources)
       # Eventually will be deprecated and replaced by source maps.
       def stylesheet_link_tag(*sources)
         options = sources.extract_options!.stringify_keys
-
         if options["debug"] != false && request_debug_assets?
           sources.map { |source|
+            check_errors_for(source)
             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)
@@ -141,14 +166,33 @@ def stylesheet_link_tag(*sources)
       end
 
       protected
-
         # Checks if the asset is included in the dependencies list.
         def check_dependencies!(dep)
           if raise_runtime_errors && !_dependency_assets.detect { |asset| asset.include?(dep) }
             raise DependencyError.new(self.pathname, dep)
           end
         end
 
+        # Raise errors when source does not exist or is not in the precompiled list
+        def check_errors_for(source)
+          source = source.to_s
+          return source if !self.raise_runtime_errors || source.blank? || source =~ URI_REGEXP
+          asset = lookup_asset_for_path(source)
+
+          if asset && asset_needs_precompile?(source, asset.pathname.to_s)
+            raise AssetFilteredError.new(source)
+          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
+        end
+
         # Enable split asset debugging. Eventually will be deprecated
         # and replaced by source maps in Sprockets 3.x.
         def request_debug_assets?

lib/sprockets/railtie.rb

@@ -113,6 +113,9 @@ def configure(&block)
         app.assets = app.assets.index
       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
 
       if config.assets.compile

test/fixtures/error/dependency.js.erb

@@ -1 +1 @@
-<%= asset_path("bar.js") %>
+<%= asset_path("bar.js") %>

test/test_helper.rb

@@ -372,6 +372,56 @@ def test_stylesheet_path
     assert_equal "/assets/foo-#{@foo_css_digest}.css", @view.stylesheet_path("foo")
   end
 
+  def test_public_folder_fallback_works_correctly
+    @view.raise_runtime_errors = true
+    @view.debug_assets       = true
+
+    @view.asset_path("asset-does-not-exist-foo.js")
+    @view.asset_url("asset-does-not-exist-foo.js")
+    @view.stylesheet_link_tag("asset-does-not-exist-foo.js")
+    @view.javascript_include_tag("asset-does-not-exist-foo.js")
+  end
+
+  def test_asset_not_precompiled_error
+    @view.raise_runtime_errors = true
+    @view.precompile         = [ lambda {|logical_path| false } ]
+    @view.assets_environment = @assets
+    @view.debug_assets       = true
+
+    assert_raise(Sprockets::Rails::Helper::AssetFilteredError) do
+      @view.asset_path("foo.js")
+    end
+
+    assert_raise(Sprockets::Rails::Helper::AssetFilteredError) do
+      @view.asset_url("foo.js")
+    end
+
+    assert_raise(Sprockets::Rails::Helper::AssetFilteredError) do
+      @view.javascript_include_tag("foo.js")
+    end
+
+    assert_raise(Sprockets::Rails::Helper::AssetFilteredError) do
+      @view.javascript_include_tag("foo")
+    end
+
+    error = assert_raise(Sprockets::Rails::Helper::AssetFilteredError) do
+      @view.javascript_include_tag(:foo)
+    end
+
+    assert_raise(Sprockets::Rails::Helper::AssetFilteredError) do
+      @view.stylesheet_link_tag("foo.js")
+    end
+
+    @view.precompile  = [ lambda {|logical_path| true } ]
+
+    @view.asset_path("foo.js")
+    @view.asset_url("foo.js")
+    @view.javascript_include_tag("foo.js")
+    @view.javascript_include_tag("foo")
+    @view.javascript_include_tag(:foo)
+    @view.stylesheet_link_tag("foo.js")
+  end
+
   def test_asset_digest_path
     assert_equal "foo-#{@foo_js_digest}.js", @view.asset_digest_path("foo.js")
     assert_equal "foo-#{@foo_css_digest}.css", @view.asset_digest_path("foo.css")
@@ -384,13 +434,17 @@ def test_asset_digest
 end
 
 class ErrorsInHelpersTest < HelperTest
+
   def test_dependency_error
     @view.raise_runtime_errors = true
+    @view.precompile           = [ lambda {|logical_path| true } ]
+    @view.assets_environment   = @assets
+
     assert_raise Sprockets::Rails::Helper::DependencyError do
-      @assets['error/dependency.js'].to_s
+      @view.asset_path("error/dependency.js")
     end
 
     @view.raise_runtime_errors = false
-    @assets['error/dependency.js'].to_s
+    @view.asset_path("error/dependency.js")
   end
-end
+end