sprockets-rails 1.0.0 → 2.0.0.backport1

data/lib/sprockets/rails/version.rb

@@ -1,5 +0,0 @@
-module Sprockets
-  module Rails
-    VERSION = "1.0.0"
-  end
-end

data/lib/tasks/assets.rake

@@ -1,105 +0,0 @@
-require "fileutils"
-
-namespace :assets do
-  def ruby_rake_task(task, fork = true)
-    env    = ENV['RAILS_ENV'] || 'production'
-    groups = ENV['RAILS_GROUPS'] || 'assets'
-    args   = [$0, task,"RAILS_ENV=#{env}","RAILS_GROUPS=#{groups}"]
-    args << "--trace" if Rake.application.options.trace
-    if $0 =~ /rake\.bat\Z/i
-      Kernel.exec $0, *args
-    else
-      fork ? ruby(*args) : Kernel.exec(FileUtils::RUBY, *args)
-    end
-  end
-
-  # We are currently running with no explicit bundler group
-  # and/or no explicit environment - we have to reinvoke rake to
-  # execute this task.
-  def invoke_or_reboot_rake_task(task)
-    if ENV['RAILS_GROUPS'].to_s.empty? || ENV['RAILS_ENV'].to_s.empty?
-      ruby_rake_task task
-    else
-      Rake::Task[task].invoke
-    end
-  end
-
-  desc "Compile all the assets named in config.assets.precompile"
-  task :precompile do
-    invoke_or_reboot_rake_task "assets:precompile:all"
-  end
-
-  namespace :precompile do
-    def internal_precompile(digest=nil)
-      unless ::Rails.application.config.assets.enabled
-        warn "Cannot precompile assets if sprockets is disabled. Please set config.assets.enabled to true"
-        exit
-      end
-
-      # Ensure that action view is loaded and the appropriate
-      # sprockets hooks get executed
-      _ = ActionView::Base
-
-      config = ::Rails.application.config
-      config.assets.compile = true
-      config.assets.digest  = digest unless digest.nil?
-      config.assets.digests = {}
-
-      env      = ::Rails.application.assets
-      target   = File.join(::Rails.public_path, config.assets.prefix)
-      compiler = Sprockets::Rails::StaticCompiler.new(env,
-                                                      target,
-                                                      config.assets.precompile,
-                                                      :manifest_path => config.assets.manifest,
-                                                      :digest => config.assets.digest,
-                                                      :manifest => digest.nil?)
-      compiler.compile
-    end
-
-    task :all do
-      Rake::Task["assets:precompile:primary"].invoke
-      # We need to reinvoke in order to run the secondary digestless
-      # asset compilation run - a fresh Sprockets environment is
-      # required in order to compile digestless assets as the
-      # environment has already cached the assets on the primary
-      # run.
-      ruby_rake_task("assets:precompile:nondigest", false) if ::Rails.application.config.assets.digest
-    end
-
-    task :primary => ["assets:cache:clean"] do
-      internal_precompile
-    end
-
-    task :nondigest => ["assets:cache:clean"] do
-      internal_precompile(false)
-    end
-  end
-
-  desc "Remove compiled assets"
-  task :clean do
-    invoke_or_reboot_rake_task "assets:clean:all"
-  end
-
-  namespace :clean do
-    task :all => ["assets:cache:clean"] do
-      config = ::Rails.application.config
-      public_asset_path = File.join(::Rails.public_path, config.assets.prefix)
-      rm_rf public_asset_path, :secure => true
-    end
-  end
-
-  namespace :cache do
-    task :clean => ["assets:environment"] do
-      ::Rails.application.assets.cache.clear
-    end
-  end
-
-  task :environment do
-    if ::Rails.application.config.assets.initialize_on_precompile
-      Rake::Task["environment"].invoke
-    else
-      ::Rails.application.initialize!(:assets)
-      Sprockets::Rails::Bootstrap.new(Rails.application).run
-    end
-  end
-end

data/test/abstract_unit.rb

@@ -1,145 +0,0 @@
-lib = File.expand_path("#{File.dirname(__FILE__)}/../lib")
-$:.unshift(lib) unless $:.include?('lib') || $:.include?(lib)
-
-require 'sprockets-rails'
-require 'fileutils'
-require 'minitest/autorun'
-require 'active_support/test_case'
-require 'rails/generators'
-require "active_support/testing/isolation"
-require "active_support/testing/declarative"
-require "active_support/core_ext/kernel/reporting"
-
-module TestHelpers
-  module Paths
-    module_function
-
-    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 $` + "\nmatch ':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
-  extend  ActiveSupport::Testing::Declarative
-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
-
-  # This is temporary, disable sprockets-rails railtie done in rails
-  file = "#{tmp_path}/app_template/config/application.rb"
-  contents = File.read(file)
-  contents.sub!(/require \"sprockets\/railtie\"/, "")
-  File.open(file, "w+") { |f| f.puts contents }
-end

data/test/assets_debugging_test.rb

@@ -1,65 +0,0 @@
-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
-          match '/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" type="text\/javascript"><\/script>/, last_response.body)
-      assert_no_match(/<script src="\/assets\/xmlhr-([0-z]+)\.js" type="text\/javascript"><\/script>/, 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" type="text\/javascript"><\/script>/, last_response.body)
-      assert_match(/<script src="\/assets\/xmlhr-([0-z]+)\.js\?body=1" type="text\/javascript"><\/script>/, last_response.body)
-    end
-  end
-end

data/test/assets_test.rb

@@ -1,532 +0,0 @@
-# -*- 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!
-      quietly do
-        Dir.chdir(app_path){ `bundle exec rake assets:precompile` }
-      end
-    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
-          match '*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", "happy.face", "-happyface",
-                               "-happy.png", "-happy.face.png", "_happyface", "_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 !File.exists?("#{app_path}/public/assets/someapplication.js")
-      assert !File.exists?("#{app_path}/public/assets/someapplication.css")
-
-      assert !File.exists?("#{app_path}/public/assets/something.min.js")
-      assert !File.exists?("#{app_path}/public/assets/something.min.css")
-
-      assert !File.exists?("#{app_path}/public/assets/something.else.js")
-      assert !File.exists?("#{app_path}/public/assets/something.else.css")
-    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"
-
-      assets = YAML.load_file(manifest)
-      assert_match(/application-([0-z]+)\.js/, assets["application.js"])
-      assert_match(/application-([0-z]+)\.css/, assets["application.css"])
-    end
-
-    test "precompile creates a manifest file in a custom path 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"
-      add_to_config "config.assets.manifest = '#{app_path}/shared'"
-
-      precompile!
-      manifest = "#{app_path}/shared/manifest.yml"
-
-      assets = YAML.load_file(manifest)
-      assert_match(/application-([0-z]+)\.js/, assets["application.js"])
-      assert_match(/application-([0-z]+)\.css/, assets["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"
-      assets = YAML.load_file(manifest)
-      assert_match(/application-([0-z]+)\.js/, assets["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"
-
-      assets = YAML.load_file(manifest)
-      assert_equal "application.js", assets["application.js"]
-      assert_equal "application.css", assets["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"
-      assets = YAML.load_file(manifest)
-      asset_path = assets["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
-          match '/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)
-      assert_match(/app.js isn't precompiled/, 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"
-
-      app_file "config/routes.rb", <<-RUBY
-        AppTemplate::Application.routes.draw do
-          match '/posts', :to => "posts#index"
-        end
-      RUBY
-
-      ENV["RAILS_ENV"] = "development"
-      precompile!
-
-      # Create file after of precompile
-      app_file "app/assets/javascripts/app.js", "alert();"
-
-      require "#{app_path}/config/environment"
-      class ::PostsController < ActionController::Base ; end
-
-      get '/posts'
-      assert_match(/AssetNotPrecompiledError/, last_response.body)
-      assert_match(/app.js isn't precompiled/, 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"
-
-      quietly do
-        Dir.chdir(app_path){ `bundle exec rake assets:precompile RAILS_ENV=test` }
-      end
-      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!
-      assets = YAML.load_file(manifest)
-
-      assert_not_equal asset_path, assets["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
-      quietly do
-        Dir.chdir(app_path){ `bundle exec rake assets:precompile RAILS_GROUPS=assets` }
-      end
-      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"
-
-      quietly do
-        Dir.chdir(app_path){ `bundle exec rake assets:clean` }
-      end
-
-      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
-          match '/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" type="text\/javascript"><\/script>/, last_response.body)
-      assert_no_match(/<script src="\/assets\/xmlhr-([0-z]+)\.js" type="text\/javascript"><\/script>/, last_response.body)
-    end
-
-    test "assets aren't concatened when compile is true 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" type="text\/javascript"><\/script>/, last_response.body)
-      assert_match(/<script src="\/assets\/xmlhr-([0-z]+)\.js\?body=1" type="text\/javascript"><\/script>/, 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"
-
-      quietly do
-        Dir.chdir(app_path){ `bundle exec rake assets:clean assets:precompile` }
-      end
-
-      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
-      quietly do
-        Dir.chdir(app_path){ `bundle exec rake assets:clean` }
-      end
-
-      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
-          match '/posts', :to => "posts#index"
-        end
-      RUBY
-    end
-  end
-end