turbo-sprockets-rails3 0.1.4 → 0.1.5

data/README.md

@@ -1,7 +1,9 @@
-# Turbo Sprockets for Rails 3
+# Turbo Sprockets for Rails 3.2.x
 
-* Speeds up the Rails 3 asset pipeline by only recompiling changed assets
-* Generates non-digest assets from precompiled assets - Only compile once!
+[![Build Status](https://secure.travis-ci.org/ndbroadbent/turbo-sprockets-rails3.png)](http://travis-ci.org/ndbroadbent/turbo-sprockets-rails3)
+
+* Speeds up the Rails 3 asset pipeline by only recompiling changed assets, based on a hash of their source files
+* Generates both non-fingerprinted and fingerprinted assets from a single compile
 
 This is a backport of the work I've done for Rails 4.0.0, released as
 a gem for Rails 3.2.x. (See [sprockets-rails #21](https://github.com/rails/sprockets-rails/pull/21) and [sprockets #367](https://github.com/sstephenson/sprockets/pull/367) for the Rails 4 pull requests.)
@@ -11,10 +13,16 @@ a gem for Rails 3.2.x. (See [sprockets-rails #21](https://github.com/rails/sproc
 
 Please test this out thoroughly on your local machine before deploying to a production site, and open an issue on GitHub if you have any problems. By using this software you agree to the terms and conditions in the [MIT license](https://github.com/ndbroadbent/turbo-sprockets-rails3/blob/master/MIT-LICENSE).
 
-## Dependencies
+## Supported Versions
+
+### Ruby
+
+All versions of Ruby that are supported by Rails `3.2.x`, including `1.9.3`, `1.9.2`, `1.8.7` and REE.
+
+### Rails
 
-* sprockets `~> 2.1.3`
-* railties `~> 3.2.0`
+This gem only supports Rails `3.2.0` or higher.
+Rails `3.1.x` support is not available at this time, because it depends on an outdated version of `sprockets`.
 
 ## Usage
 
@@ -43,12 +51,11 @@ Enjoy your lightning fast deploys!
 
 You won't be able to do an 'incremental update' on heroku, since your `public/assets`
 folder will be empty at the start of each push. However, this gem can still cut your
-precompile time in half, since it only compiles assets once to generate both digest and non-digest assets.
+precompile time in half, since it only needs to compile assets once.
 
-If you want to make the most of `turbo-sprockets-rails3`, you can run `assets:precompile` on your local machine
-and commit the compiled assets. When you push compiled assets to Heroku, it automatically skips the `assets:precompile` task.
+If you want to make the most of `turbo-sprockets-rails3`, you can run `assets:precompile` on your local machine and commit the compiled assets. When you push compiled assets to Heroku, it will automatically skip the `assets:precompile` task.
 
-I've automated this process in a Rake task for my own projects. It uses a temporary deploy repo so you can keep working, and it also rebases and amends the assets commit so your repo doesn't grow out of control. You can find my deploy task in a gist at https://gist.github.com/3802355. Save this file to `lib/tasks/deploy.rake`, and run `rake deploy` to deploy your app to Heroku.
+I've automated this process in a Rake task for my own projects. My task creates a deployment repo at `tmp/heroku_deploy` so that you can keep working while deploying, and it also rebases and amends the assets commit to keep your repo's history from growing out of control. You can find the deploy task in a gist at https://gist.github.com/3802355. Save this file to `lib/tasks/deploy.rake`, and make sure you have added a `heroku` remote to your repo. You will now be able to run `rake deploy` to deploy your app to Heroku.
 
 ## Debugging
 

data/lib/sprockets/static_non_digest_generator.rb

@@ -63,14 +63,17 @@ module Sprockets
           env.logger.debug "Stripped digests, copied to #{logical_path}, and created gzipped asset"
 
         else
-          # Otherwise, treat file as binary and copy it
-          FileUtils.cp_r abs_digest_path, abs_logical_path, :remove_destination => true
-          env.logger.debug "Copied binary asset to #{logical_path}"
-
-          # Copy gzipped asset if exists
-          if File.exist? "#{abs_digest_path}.gz"
-            FileUtils.cp_r "#{abs_digest_path}.gz", "#{abs_logical_path}.gz", :remove_destination => true
-            env.logger.debug "Copied gzipped asset to #{logical_path}.gz"
+          # Otherwise, treat file as binary and copy it.
+          # Ignore paths that have no digests, such as READMEs
+          unless abs_digest_path == abs_logical_path
+            FileUtils.cp_r abs_digest_path, abs_logical_path, :remove_destination => true
+            env.logger.debug "Copied binary asset to #{logical_path}"
+
+            # Copy gzipped asset if exists
+            if File.exist? "#{abs_digest_path}.gz"
+              FileUtils.cp_r "#{abs_digest_path}.gz", "#{abs_logical_path}.gz", :remove_destination => true
+              env.logger.debug "Copied gzipped asset to #{logical_path}.gz"
+            end
           end
         end
       end

data/lib/turbo-sprockets-rails3.rb

@@ -2,4 +2,6 @@ Dir[File.expand_path('../turbo-sprockets/sprockets_overrides/**/*.rb', __FILE__)
   require f
 end
 
+require 'sprockets/railtie'
+require 'sprockets/helpers'
 require 'turbo-sprockets/railtie'

data/lib/turbo-sprockets/sprockets_overrides/static_compiler.rb

@@ -1,74 +1,80 @@
-require 'sprockets/static_compiler'
+begin
+  require 'sprockets/static_compiler'
+rescue LoadError
+end
 
-module Sprockets
-  StaticCompiler.class_eval do
-    def initialize(env, target, paths, options = {})
-      @env = env
-      @target = target
-      @paths = paths
-      @digest = options.fetch(:digest, true)
-      @manifest = options.fetch(:manifest, true)
-      @manifest_path = options.delete(:manifest_path) || target
-      @zip_files = options.delete(:zip_files) || /\.(?:css|html|js|svg|txt|xml)$/
+# Sprockets::StaticCompiler was only introduced in Rails 3.2.x
+if defined?(Sprockets::StaticCompiler)
+  module Sprockets
+    StaticCompiler.class_eval do
+      def initialize(env, target, paths, options = {})
+        @env = env
+        @target = target
+        @paths = paths
+        @digest = options.fetch(:digest, true)
+        @manifest = options.fetch(:manifest, true)
+        @manifest_path = options.delete(:manifest_path) || target
+        @zip_files = options.delete(:zip_files) || /\.(?:css|html|js|svg|txt|xml)$/
 
-      @current_source_digests = options.fetch(:source_digests, {})
-      @current_digest_files   = options.fetch(:digest_files,   {})
+        @current_source_digests = options.fetch(:source_digests, {})
+        @current_digest_files   = options.fetch(:digest_files,   {})
 
-      @digest_files   = {}
-      @source_digests = {}
-    end
+        @digest_files   = {}
+        @source_digests = {}
+      end
 
-    def compile
-      start_time = Time.now.to_f
+      def compile
+        start_time = Time.now.to_f
 
-      env.each_logical_path do |logical_path|
-        if File.basename(logical_path)[/[^\.]+/, 0] == 'index'
-          logical_path.sub!(/\/index\./, '.')
-        end
-        next unless compile_path?(logical_path)
+        env.each_logical_path do |logical_path|
+          if File.basename(logical_path)[/[^\.]+/, 0] == 'index'
+            logical_path.sub!(/\/index\./, '.')
+          end
+          next unless compile_path?(logical_path)
 
-        # Fetch asset without any processing or compression,
-        # to calculate a digest of the concatenated source files
-        asset = env.find_asset(logical_path, :process => false)
+          # Fetch asset without any processing or compression,
+          # to calculate a digest of the concatenated source files
+          asset = env.find_asset(logical_path, :process => false)
 
-        # Force digest to UTF-8 for Ruby 1.9, otherwise YAML dumps ASCII-8BIT as !binary
-        @source_digests[logical_path] = if RUBY_VERSION.to_f >= 1.9
-          asset.digest.force_encoding("UTF-8")
-        else
-          asset.digest
-        end
+          # Force digest to UTF-8 for Ruby 1.9, otherwise YAML dumps ASCII-8BIT as !binary
+          @source_digests[logical_path] = if RUBY_VERSION.to_f >= 1.9
+            asset.digest.force_encoding("UTF-8")
+          else
+            asset.digest
+          end
 
-        # Recompile if digest has changed or compiled digest file is missing
-        current_digest_file = @current_digest_files[logical_path]
+          # Recompile if digest has changed or compiled digest file is missing
+          current_digest_file = @current_digest_files[logical_path]
 
-        if @source_digests[logical_path] != @current_source_digests[logical_path] ||
-           !(current_digest_file && File.exists?("#{@target}/#{current_digest_file}"))
+          if @source_digests[logical_path] != @current_source_digests[logical_path] ||
+             !(current_digest_file && File.exists?("#{@target}/#{current_digest_file}"))
 
-          if asset = env.find_asset(logical_path)
-            @digest_files[logical_path] = write_asset(asset)
-          end
+            if asset = env.find_asset(logical_path)
+              @digest_files[logical_path] = write_asset(asset)
+            end
 
-        else
-          # Set asset file from manifest.yml
-          digest_file = @current_digest_files[logical_path]
-          @digest_files[logical_path] = digest_file
+          else
+            # Set asset file from manifest.yml
+            digest_file = @current_digest_files[logical_path]
+            @digest_files[logical_path] = digest_file
 
-          env.logger.debug "Not compiling #{logical_path}, sources digest has not changed " <<
-                           "(#{@source_digests[logical_path][0...7]})"
+            env.logger.debug "Not compiling #{logical_path}, sources digest has not changed " <<
+                             "(#{@source_digests[logical_path][0...7]})"
+          end
         end
-      end
 
-      if @manifest
-        write_manifest(:source_digests => @source_digests, :digest_files => @digest_files)
-      end
+        if @manifest
+          write_manifest(:source_digests => @source_digests, :digest_files => @digest_files)
+        end
 
-      # Store digests in Rails config. (Important if non-digest is run after primary)
-      config = ::Rails.application.config
-      config.assets.digest_files   = @digest_files
-      config.assets.source_digests = @source_digests
+        # Store digests in Rails config. (Important if non-digest is run after primary)
+        config = ::Rails.application.config
+        config.assets.digest_files   = @digest_files
+        config.assets.source_digests = @source_digests
 
-      elapsed_time = ((Time.now.to_f - start_time) * 1000).to_i
-      env.logger.debug "Processed #{'non-' unless @digest}digest assets in #{elapsed_time}ms"
+        elapsed_time = ((Time.now.to_f - start_time) * 1000).to_i
+        env.logger.debug "Processed #{'non-' unless @digest}digest assets in #{elapsed_time}ms"
+      end
     end
   end
 end

data/lib/turbo-sprockets/tasks/assets.rake

@@ -2,7 +2,7 @@ require "fileutils"
 
 # Clear all assets tasks from sprockets railtie
 Rake::Task.tasks.each do |task|
-  if task.name.starts_with? 'assets:'
+  if task.name.match '^assets:'
     task.clear_prerequisites.clear_actions
   end
 end

data/lib/turbo-sprockets/version.rb

@@ -1,3 +1,3 @@
 module TurboSprockets
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/test/abstract_unit.rb

@@ -0,0 +1,143 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'turbo-sprockets-rails3'
+require 'fileutils'
+
+# Require minitest for 1.9 and test/unit for 1.8
+# 'active_support/test_case' supports both.
+begin
+  require 'minitest/autorun'
+rescue LoadError
+  require 'test/unit'
+end
+
+require 'active_support/test_case'
+require 'rails/generators'
+require "active_support/testing/isolation"
+require "active_support/core_ext/kernel/reporting"
+
+module TestHelpers
+  module Paths
+    TMP_PATH = File.expand_path(File.join(File.dirname(__FILE__), *%w[.. tmp]))
+
+    def tmp_path(*args)
+      File.join(TMP_PATH, *args)
+    end
+
+    def app_path(*args)
+      tmp_path(*%w[app] + args)
+    end
+
+    def rails_root
+      app_path
+    end
+  end
+
+  module Rack
+    def app(env = "production")
+      old_env = ENV["RAILS_ENV"]
+      @app ||= begin
+        ENV["RAILS_ENV"] = env
+        require "#{app_path}/config/environment"
+        Rails.application
+      end
+    ensure
+      ENV["RAILS_ENV"] = old_env
+    end
+
+    def get(path)
+      @app.call(::Rack::MockRequest.env_for(path))
+    end
+  end
+
+  module Generation
+    # Build an application by invoking the generator and going through the whole stack.
+    def build_app(options = {})
+      @prev_rails_env = ENV['RAILS_ENV']
+      ENV['RAILS_ENV'] = 'development'
+
+      FileUtils.rm_rf(app_path)
+      FileUtils.cp_r(tmp_path('app_template'), app_path)
+
+      # Delete the initializers unless requested
+      unless options[:initializers]
+        Dir["#{app_path}/config/initializers/*.rb"].each do |initializer|
+          File.delete(initializer)
+        end
+      end
+
+      unless options[:gemfile]
+        File.delete"#{app_path}/Gemfile"
+      end
+
+      routes = File.read("#{app_path}/config/routes.rb")
+      if routes =~ /(\n\s*end\s*)\Z/
+        File.open("#{app_path}/config/routes.rb", 'w') do |f|
+          f.puts $` + "\nget ':controller(/:action(/:id))(.:format)'\n" + $1
+        end
+      end
+
+      add_to_config 'config.secret_token = "3b7cd727ee24e8444053437c36cc66c4"; config.session_store :cookie_store, :key => "_myapp_session"; config.active_support.deprecation = :log'
+    end
+
+    def teardown_app
+      ENV['RAILS_ENV'] = @prev_rails_env if @prev_rails_env
+    end
+
+    def add_to_config(str)
+      environment = File.read("#{app_path}/config/application.rb")
+      if environment =~ /(\n\s*end\s*end\s*)\Z/
+        File.open("#{app_path}/config/application.rb", 'w') do |f|
+          f.puts $` + "\n#{str}\n" + $1
+        end
+      end
+    end
+
+    def add_to_env_config(env, str)
+      environment = File.read("#{app_path}/config/environments/#{env}.rb")
+      if environment =~ /(\n\s*end\s*)\Z/
+        File.open("#{app_path}/config/environments/#{env}.rb", 'w') do |f|
+          f.puts $` + "\n#{str}\n" + $1
+        end
+      end
+    end
+
+    def app_file(path, contents)
+      FileUtils.mkdir_p File.dirname("#{app_path}/#{path}")
+      File.open("#{app_path}/#{path}", 'w') do |f|
+        f.puts contents
+      end
+    end
+
+    def boot_rails
+      require 'rubygems' unless defined? Gem
+      require 'bundler'
+      Bundler.setup
+    end
+  end
+end
+
+class ActiveSupport::TestCase
+  include TestHelpers::Paths
+  include TestHelpers::Rack
+  include TestHelpers::Generation
+end
+
+# Create a scope and build a fixture rails app
+Module.new do
+  extend TestHelpers::Paths
+  # Build a rails app
+  if File.exist?(tmp_path)
+    FileUtils.rm_rf(tmp_path)
+  end
+  FileUtils.mkdir(tmp_path)
+
+  quietly do
+    Rails::Generators.invoke('app', ["#{tmp_path('app_template')}", "--skip-active-record", "--skip-test-unit"])
+  end
+
+  File.open("#{tmp_path}/app_template/config/boot.rb", 'w') do |f|
+    f.puts 'require "action_controller/railtie"'
+  end
+end

data/test/assets_debugging_test.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.dirname(__FILE__) + "/abstract_unit")
+require 'rack/test'
+
+module ApplicationTests
+  class AssetsDebuggingTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+    include Rack::Test::Methods
+
+    def setup
+      build_app(:initializers => true)
+
+      app_file "app/assets/javascripts/application.js", "//= require_tree ."
+      app_file "app/assets/javascripts/xmlhr.js", "function f1() { alert(); }"
+      app_file "app/views/posts/index.html.erb", "<%= javascript_include_tag 'application' %>"
+
+      app_file "config/routes.rb", <<-RUBY
+        AppTemplate::Application.routes.draw do
+          get '/posts', :to => "posts#index"
+        end
+      RUBY
+
+      app_file "app/controllers/posts_controller.rb", <<-RUBY
+        class PostsController < ActionController::Base
+        end
+      RUBY
+
+      ENV["RAILS_ENV"] = "production"
+
+      boot_rails
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    test "assets are concatenated when debug is off and compile is off either if debug_assets param is provided" do
+      # config.assets.debug and config.assets.compile are false for production environment
+      ENV["RAILS_ENV"] = "production"
+      capture(:stdout) do
+        Dir.chdir(app_path){ `bundle exec rake assets:precompile` }
+      end
+      require "#{app_path}/config/environment"
+
+      class ::PostsController < ActionController::Base ; end
+
+      # the debug_assets params isn't used if compile is off
+      get '/posts?debug_assets=true'
+      assert_match(/<script src="\/assets\/application-([0-z]+)\.js"/, last_response.body)
+      assert_no_match(/<script src="\/assets\/xmlhr-([0-z]+)\.js"/, last_response.body)
+    end
+
+    test "assets aren't concatened when compile is true is on and debug_assets params is true" do
+      app_file "config/initializers/compile.rb", "Rails.application.config.assets.compile = true"
+
+      ENV["RAILS_ENV"] = "production"
+      require "#{app_path}/config/environment"
+
+      class ::PostsController < ActionController::Base ; end
+
+      get '/posts?debug_assets=true'
+      assert_match(/<script src="\/assets\/application-([0-z]+)\.js\?body=1"/, last_response.body)
+      assert_match(/<script src="\/assets\/xmlhr-([0-z]+)\.js\?body=1"/, last_response.body)
+    end
+  end
+end

data/test/assets_test.rb

@@ -0,0 +1,542 @@
+# -*- coding: utf-8 -*-
+require File.expand_path(File.dirname(__FILE__) + "/abstract_unit")
+require 'rack/test'
+
+module ApplicationTests
+  class AssetsTest < ActiveSupport::TestCase
+    include ActiveSupport::Testing::Isolation
+    include Rack::Test::Methods
+
+    def setup
+      build_app(:initializers => true)
+      boot_rails
+    end
+
+    def teardown
+      teardown_app
+    end
+
+    def precompile!(env = nil)
+      quietly do
+        precompile_task = "bundle exec rake assets:precompile #{env} 2>&1"
+        output = Dir.chdir(app_path) { %x[ #{precompile_task} ] }
+        assert $?.success?, output
+        output
+      end
+    end
+
+    def clean_assets!
+      quietly do
+        assert Dir.chdir(app_path) { system('bundle exec rake assets:clean') }
+      end
+    end
+
+    def assert_file_exists(filename)
+      assert File.exists?(filename), "missing #{filename}"
+    end
+
+    def assert_no_file_exists(filename)
+      assert !File.exists?(filename), "#{filename} does exist"
+    end
+
+    test "assets routes have higher priority" do
+      app_file "app/assets/javascripts/demo.js.erb", "a = <%= image_path('rails.png').inspect %>;"
+
+      app_file 'config/routes.rb', <<-RUBY
+        AppTemplate::Application.routes.draw do
+          get '*path', :to => lambda { |env| [200, { "Content-Type" => "text/html" }, "Not an asset"] }
+        end
+      RUBY
+
+      require "#{app_path}/config/environment"
+
+      get "/assets/demo.js"
+      assert_equal 'a = "/assets/rails.png";', last_response.body.strip
+    end
+
+    test "assets do not require compressors until it is used" do
+      app_file "app/assets/javascripts/demo.js.erb", "<%= :alert %>();"
+      add_to_env_config "production", "config.assets.compile = true"
+
+      ENV["RAILS_ENV"] = "production"
+      require "#{app_path}/config/environment"
+
+      assert !defined?(Uglifier)
+      get "/assets/demo.js"
+      assert_match "alert()", last_response.body
+      assert defined?(Uglifier)
+    end
+
+    test "precompile creates the file, gives it the original asset's content and run in production as default" do
+      app_file "app/assets/javascripts/application.js", "alert();"
+      app_file "app/assets/javascripts/foo/application.js", "alert();"
+
+      ENV["RAILS_ENV"] = nil
+      precompile!
+
+      files = Dir["#{app_path}/public/assets/application-*.js"]
+      files << Dir["#{app_path}/public/assets/application.js"].first
+      files << Dir["#{app_path}/public/assets/foo/application-*.js"].first
+      files << Dir["#{app_path}/public/assets/foo/application.js"].first
+      files.each do |file|
+        assert_not_nil file, "Expected application.js asset to be generated, but none found"
+        assert_equal "alert();", File.read(file)
+      end
+    end
+
+    test "precompile application.js and application.css and all other non JS/CSS files" do
+      app_file "app/assets/javascripts/application.js", "alert();"
+      app_file "app/assets/stylesheets/application.css", "body{}"
+
+      app_file "app/assets/javascripts/someapplication.js", "alert();"
+      app_file "app/assets/stylesheets/someapplication.css", "body{}"
+
+      app_file "app/assets/javascripts/something.min.js", "alert();"
+      app_file "app/assets/stylesheets/something.min.css", "body{}"
+
+      app_file "app/assets/javascripts/something.else.js.erb", "alert();"
+      app_file "app/assets/stylesheets/something.else.css.erb", "body{}"
+
+      images_should_compile = ["a.png", "happyface.png", "happy_face.png", "happy.face.png",
+                               "happy-face.png", "happy.happy_face.png", "happy_happy.face.png",
+                               "happy.happy.face.png", "-happy.png", "-happy.face.png",
+                               "_happy.face.png", "_happy.png"]
+
+      images_should_compile.each do |filename|
+        app_file "app/assets/images/#{filename}", "happy"
+      end
+
+      precompile!
+
+      images_should_compile.each do |filename|
+        assert_file_exists("#{app_path}/public/assets/#{filename}")
+      end
+
+      assert_file_exists("#{app_path}/public/assets/application.js")
+      assert_file_exists("#{app_path}/public/assets/application.css")
+
+      assert_no_file_exists("#{app_path}/public/assets/someapplication.js")
+      assert_no_file_exists("#{app_path}/public/assets/someapplication.css")
+
+      assert_no_file_exists("#{app_path}/public/assets/something.min.js")
+      assert_no_file_exists("#{app_path}/public/assets/something.min.css")
+
+      assert_no_file_exists("#{app_path}/public/assets/something.else.js")
+      assert_no_file_exists("#{app_path}/public/assets/something.else.css")
+    end
+
+    test "precompile something.js for directory containing index file" do
+      add_to_config "config.assets.precompile = [ 'something.js' ]"
+      app_file "app/assets/javascripts/something/index.js.erb", "alert();"
+
+      precompile!
+
+      assert_file_exists("#{app_path}/public/assets/something.js")
+    end
+
+    test "asset pipeline should use a Sprockets::Index when config.assets.digest is true" do
+      add_to_config "config.assets.digest = true"
+      add_to_config "config.action_controller.perform_caching = false"
+
+      ENV["RAILS_ENV"] = "production"
+      require "#{app_path}/config/environment"
+
+      assert_equal Sprockets::Index, Rails.application.assets.class
+    end
+
+    test "precompile creates a manifest file with all the assets listed" do
+      app_file "app/assets/stylesheets/application.css.erb", "<%= asset_path('rails.png') %>"
+      app_file "app/assets/javascripts/application.js", "alert();"
+      # digest is default in false, we must enable it for test environment
+      add_to_config "config.assets.digest = true"
+
+      precompile!
+      manifest = "#{app_path}/public/assets/manifest.yml"
+
+      digests = YAML.load_file(manifest)
+      digest_files, source_digests = digests[:digest_files], digests[:source_digests]
+
+      assert_match(/application-([0-z]+)\.js/,  digest_files["application.js"])
+      assert_match(/application-([0-z]+)\.css/, digest_files["application.css"])
+
+      assert_match(/[0-z]+/, source_digests["application.js"])
+      assert_match(/[0-z]+/, source_digests["application.css"])
+    end
+
+    test "the manifest file should be saved by default in the same assets folder" do
+      app_file "app/assets/javascripts/application.js", "alert();"
+      # digest is default in false, we must enable it for test environment
+      add_to_config "config.assets.digest = true"
+      add_to_config "config.assets.prefix = '/x'"
+
+      precompile!
+
+      manifest = "#{app_path}/public/x/manifest.yml"
+      digest_files = YAML.load_file(manifest)[:digest_files]
+      assert_match(/application-([0-z]+)\.js/, digest_files["application.js"])
+    end
+
+    test "precompile does not append asset digests when config.assets.digest is false" do
+      app_file "app/assets/stylesheets/application.css.erb", "<%= asset_path('rails.png') %>"
+      app_file "app/assets/javascripts/application.js", "alert();"
+      add_to_config "config.assets.digest = false"
+
+      precompile!
+
+      assert_file_exists("#{app_path}/public/assets/application.js")
+      assert_file_exists("#{app_path}/public/assets/application.css")
+
+      manifest = "#{app_path}/public/assets/manifest.yml"
+
+      digest_files = YAML.load_file(manifest)[:digest_files]
+      assert_equal "application.js", digest_files["application.js"]
+      assert_equal "application.css", digest_files["application.css"]
+    end
+
+    test "assets do not require any assets group gem when manifest file is present" do
+      app_file "app/assets/javascripts/application.js", "alert();"
+      add_to_env_config "production", "config.serve_static_assets = true"
+
+      ENV["RAILS_ENV"] = "production"
+      precompile!
+
+      manifest = "#{app_path}/public/assets/manifest.yml"
+      digest_files = YAML.load_file(manifest)[:digest_files]
+      asset_path = digest_files["application.js"]
+
+      require "#{app_path}/config/environment"
+
+      # Checking if Uglifier is defined we can know if Sprockets was reached or not
+      assert !defined?(Uglifier)
+      get "/assets/#{asset_path}"
+      assert_match "alert()", last_response.body
+      assert !defined?(Uglifier)
+    end
+
+    test "assets raise AssetNotPrecompiledError when manifest file is present and requested file isn't precompiled" do
+      app_file "app/views/posts/index.html.erb", "<%= javascript_include_tag 'app' %>"
+
+      app_file "config/routes.rb", <<-RUBY
+        AppTemplate::Application.routes.draw do
+          get '/posts', :to => "posts#index"
+        end
+      RUBY
+
+      ENV["RAILS_ENV"] = "production"
+      precompile!
+
+      # Create file after of precompile
+      app_file "app/assets/javascripts/app.js", "alert();"
+
+      require "#{app_path}/config/environment"
+      class ::PostsController < ActionController::Base
+        def show_detailed_exceptions?() true end
+      end
+
+      get '/posts'
+      assert_match(/AssetNotPrecompiledError/, last_response.body)
+    end
+
+    test "assets raise AssetNotPrecompiledError when manifest file is present and requested file isn't precompiled if digest is disabled" do
+      app_file "app/views/posts/index.html.erb", "<%= javascript_include_tag 'app' %>"
+      add_to_config "config.assets.compile = false"
+      add_to_config "config.assets.digest_files = false"
+
+      app_file "config/routes.rb", <<-RUBY
+        AppTemplate::Application.routes.draw do
+          get '/posts', :to => "posts#index"
+        end
+      RUBY
+
+      ENV["RAILS_ENV"] = "production"
+      precompile!
+
+      # Create file after of precompile
+      app_file "app/assets/javascripts/app.js", "alert();"
+
+      require "#{app_path}/config/environment"
+      class ::PostsController < ActionController::Base
+        def show_detailed_exceptions?() true end
+      end
+
+      get '/posts'
+      assert_match(/AssetNotPrecompiledError/, last_response.body)
+    end
+
+    test "precompile properly refers files referenced with asset_path and and run in the provided RAILS_ENV" do
+      app_file "app/assets/stylesheets/application.css.erb", "<%= asset_path('rails.png') %>"
+      # digest is default in false, we must enable it for test environment
+      add_to_env_config "test", "config.assets.digest = true"
+
+      precompile!('RAILS_ENV=test')
+
+      file = Dir["#{app_path}/public/assets/application.css"].first
+      assert_match(/\/assets\/rails\.png/, File.read(file))
+      file = Dir["#{app_path}/public/assets/application-*.css"].first
+      assert_match(/\/assets\/rails-([0-z]+)\.png/, File.read(file))
+    end
+
+    test "precompile shouldn't use the digests present in manifest.yml" do
+      app_file "app/assets/stylesheets/application.css.erb", "<%= asset_path('rails.png') %>"
+
+      ENV["RAILS_ENV"] = "production"
+      precompile!
+
+      manifest = "#{app_path}/public/assets/manifest.yml"
+      assets = YAML.load_file(manifest)
+      asset_path = assets["application.css"]
+
+      app_file "app/assets/images/rails.png", "image changed"
+
+      precompile!
+      digest_files = YAML.load_file(manifest)[:digest_files]
+
+      assert_not_equal asset_path, digest_files["application.css"]
+    end
+
+    test "precompile appends the md5 hash to files referenced with asset_path and run in production as default even using RAILS_GROUPS=assets" do
+      app_file "app/assets/stylesheets/application.css.erb", "<%= asset_path('rails.png') %>"
+      add_to_config "config.assets.compile = true"
+
+      ENV["RAILS_ENV"] = nil
+
+      precompile!('RAILS_GROUPS=assets')
+
+      file = Dir["#{app_path}/public/assets/application-*.css"].first
+      assert_match(/\/assets\/rails-([0-z]+)\.png/, File.read(file))
+    end
+
+    test "precompile should handle utf8 filenames" do
+      filename = "レイルズ.png"
+      app_file "app/assets/images/#{filename}", "not a image really"
+      add_to_config "config.assets.precompile = [ /\.png$/, /application.(css|js)$/ ]"
+
+      precompile!
+      require "#{app_path}/config/environment"
+
+      get "/assets/#{URI.parser.escape(filename)}"
+      assert_match "not a image really", last_response.body
+      assert_file_exists("#{app_path}/public/assets/#{filename}")
+    end
+
+    test "assets are cleaned up properly" do
+      app_file "public/assets/application.js", "alert();"
+      app_file "public/assets/application.css", "a { color: green; }"
+      app_file "public/assets/subdir/broken.png", "not really an image file"
+
+      clean_assets!
+
+      files = Dir["#{app_path}/public/assets/**/*", "#{app_path}/tmp/cache/assets/*"]
+      assert_equal 0, files.length, "Expected no assets, but found #{files.join(', ')}"
+    end
+
+    test "assets routes are not drawn when compilation is disabled" do
+      app_file "app/assets/javascripts/demo.js.erb", "<%= :alert %>();"
+      add_to_config "config.assets.compile = false"
+
+      ENV["RAILS_ENV"] = "production"
+      require "#{app_path}/config/environment"
+
+      get "/assets/demo.js"
+      assert_equal 404, last_response.status
+    end
+
+    test "does not stream session cookies back" do
+      app_file "app/assets/javascripts/demo.js.erb", "<%= :alert %>();"
+
+      app_file "config/routes.rb", <<-RUBY
+        AppTemplate::Application.routes.draw do
+          get '/omg', :to => "omg#index"
+        end
+      RUBY
+
+      require "#{app_path}/config/environment"
+
+      class ::OmgController < ActionController::Base
+        def index
+          flash[:cool_story] = true
+          render :text => "ok"
+        end
+      end
+
+      get "/omg"
+      assert_equal 'ok', last_response.body
+
+      get "/assets/demo.js"
+      assert_match "alert()", last_response.body
+      assert_equal nil, last_response.headers["Set-Cookie"]
+    end
+
+    test "files in any assets/ directories are not added to Sprockets" do
+      %w[app lib vendor].each do |dir|
+        app_file "#{dir}/assets/#{dir}_test.erb", "testing"
+      end
+
+      app_file "app/assets/javascripts/demo.js", "alert();"
+
+      require "#{app_path}/config/environment"
+
+      get "/assets/demo.js"
+      assert_match "alert();", last_response.body
+      assert_equal 200, last_response.status
+    end
+
+    test "assets are concatenated when debug is off and compile is off either if debug_assets param is provided" do
+      app_with_assets_in_view
+
+      # config.assets.debug and config.assets.compile are false for production environment
+      ENV["RAILS_ENV"] = "production"
+      precompile!
+
+      require "#{app_path}/config/environment"
+
+      class ::PostsController < ActionController::Base ; end
+
+      # the debug_assets params isn't used if compile is off
+      get '/posts?debug_assets=true'
+      assert_match(/<script src="\/assets\/application-([0-z]+)\.js"/, last_response.body)
+      assert_no_match(/<script src="\/assets\/xmlhr-([0-z]+)\.js"/, last_response.body)
+    end
+
+    test "assets aren't concatenated when compile is on and debug_assets params is true" do
+      app_with_assets_in_view
+      add_to_env_config "production", "config.assets.compile  = true"
+      add_to_env_config "production", "config.assets.allow_debugging = true"
+
+      ENV["RAILS_ENV"] = "production"
+      require "#{app_path}/config/environment"
+
+      class ::PostsController < ActionController::Base ; end
+
+      get '/posts?debug_assets=true'
+      assert_match(/<script src="\/assets\/application-([0-z]+)\.js\?body=1"/, last_response.body)
+      assert_match(/<script src="\/assets\/xmlhr-([0-z]+)\.js\?body=1"/, last_response.body)
+    end
+
+    test "assets can access model information when precompiling" do
+      app_file "app/models/post.rb", "class Post; end"
+      app_file "app/assets/javascripts/application.js", "//= require_tree ."
+      app_file "app/assets/javascripts/xmlhr.js.erb", "<%= Post.name %>"
+
+      add_to_config "config.assets.digest = false"
+      precompile!
+      assert_equal "Post;\n", File.read("#{app_path}/public/assets/application.js")
+    end
+
+    test "assets can't access model information when precompiling if not initializing the app" do
+      app_file "app/models/post.rb", "class Post; end"
+      app_file "app/assets/javascripts/application.js", "//= require_tree ."
+      app_file "app/assets/javascripts/xmlhr.js.erb", "<%= defined?(Post) || :NoPost %>"
+
+      add_to_config "config.assets.digest = false"
+      add_to_config "config.assets.initialize_on_precompile = false"
+
+      precompile!
+      assert_equal "NoPost;\n", File.read("#{app_path}/public/assets/application.js")
+    end
+
+    test "initialization on the assets group should set assets_dir" do
+      require "#{app_path}/config/application"
+      Rails.application.initialize!(:assets)
+      assert_not_nil Rails.application.config.action_controller.assets_dir
+    end
+
+    test "enhancements to assets:precompile should only run once" do
+      app_file "lib/tasks/enhance.rake", "Rake::Task['assets:precompile'].enhance { puts 'enhancement' }"
+      output = precompile!
+      assert_equal 1, output.scan("enhancement").size
+    end
+
+    test "digested assets are not mistakenly removed" do
+      app_file "app/assets/application.js", "alert();"
+      add_to_config "config.assets.compile = true"
+      add_to_config "config.assets.digest = true"
+
+      precompile!
+
+      files = Dir["#{app_path}/public/assets/application-*.js"]
+      assert_equal 1, files.length, "Expected digested application.js asset to be generated, but none found"
+    end
+
+    test "digested assets are removed from configured path" do
+      app_file "public/production_assets/application.js", "alert();"
+      add_to_env_config "production", "config.assets.prefix = 'production_assets'"
+
+      ENV["RAILS_ENV"] = nil
+
+      clean_assets!
+
+      files = Dir["#{app_path}/public/production_assets/application.js"]
+      assert_equal 0, files.length, "Expected application.js asset to be removed, but still exists"
+    end
+
+    test "asset urls should use the request's protocol by default" do
+      app_with_assets_in_view
+      add_to_config "config.asset_host = 'example.com'"
+      require "#{app_path}/config/environment"
+      class ::PostsController < ActionController::Base; end
+
+      get '/posts', {}, {'HTTPS'=>'off'}
+      assert_match('src="http://example.com/assets/application.js', last_response.body)
+      get '/posts', {}, {'HTTPS'=>'on'}
+      assert_match('src="https://example.com/assets/application.js', last_response.body)
+    end
+
+    test "asset urls should be protocol-relative if no request is in scope" do
+      app_file "app/assets/javascripts/image_loader.js.erb", 'var src="<%= image_path("rails.png") %>";'
+      add_to_config "config.assets.precompile = %w{image_loader.js}"
+      add_to_config "config.asset_host = 'example.com'"
+      precompile!
+
+      assert_match 'src="//example.com/assets/rails.png"', File.read("#{app_path}/public/assets/image_loader.js")
+    end
+
+    test "asset paths should use RAILS_RELATIVE_URL_ROOT by default" do
+      ENV["RAILS_RELATIVE_URL_ROOT"] = "/sub/uri"
+
+      app_file "app/assets/javascripts/app.js.erb", 'var src="<%= image_path("rails.png") %>";'
+      add_to_config "config.assets.precompile = %w{app.js}"
+      precompile!
+
+      assert_match 'src="/sub/uri/assets/rails.png"', File.read("#{app_path}/public/assets/app.js")
+    end
+
+    test "html assets are compiled when executing precompile" do
+      app_file "app/assets/pages/page.html.erb", "<%= javascript_include_tag :application %>"
+      ENV["RAILS_ENV"]   = "production"
+      ENV["RAILS_GROUP"] = "assets"
+
+      quietly do
+        Dir.chdir(app_path){ `bundle exec rake assets:precompile` }
+      end
+
+      assert_file_exists("#{app_path}/public/assets/page.html")
+    end
+
+    test "assets:cache:clean should clean cache" do
+      ENV["RAILS_ENV"] = "production"
+      precompile!
+
+      quietly do
+        Dir.chdir(app_path){ `bundle exec rake assets:cache:clean` }
+      end
+
+      require "#{app_path}/config/environment"
+      assert_equal 0, Dir.entries(Rails.application.assets.cache.cache_path).size - 2 # reject [".", ".."]
+    end
+
+    private
+
+    def app_with_assets_in_view
+      app_file "app/assets/javascripts/application.js", "//= require_tree ."
+      app_file "app/assets/javascripts/xmlhr.js", "function f1() { alert(); }"
+      app_file "app/views/posts/index.html.erb", "<%= javascript_include_tag 'application' %>"
+
+      app_file "config/routes.rb", <<-RUBY
+        AppTemplate::Application.routes.draw do
+          get '/posts', :to => "posts#index"
+        end
+      RUBY
+    end
+  end
+end