condenser 0.0.1

data/lib/condenser/templating_engine/erb.rb

@@ -0,0 +1,21 @@
+require "erubi"
+
+class Condenser
+  class Erubi
+    
+    def self.call(environment, data)
+      source = ::Erubi::Engine.new(data[:source], {
+        preamble:   "@output_buffer = String.new;",
+        bufvar:     "@output_buffer",
+        postamble:  "@output_buffer.to_s"
+      }).src
+      
+      source = eval("proc { #{source} }", nil, data[:filename] || "(erubi)")
+      source = environment.new_context_class.instance_eval(&source)
+
+      
+      data[:source] = source
+    end
+    
+  end
+end

data/lib/condenser/utils.rb

@@ -0,0 +1,32 @@
+class Condenser
+  module Utils
+
+    # Public: Write to a file atomically. Useful for situations where you
+    # don't want other processes or threads to see half-written files.
+    #
+    #   Utils.atomic_write('important.file') do |file|
+    #     file.write('hello')
+    #   end
+    #
+    # Returns nothing.
+    def self.atomic_write(filename)
+      dirname, basename = File.split(filename)
+      basename = [
+        basename,
+        Thread.current.object_id,
+        Process.pid,
+        rand(1000000)
+      ].join('.'.freeze)
+      tmpname = File.join(dirname, basename)
+
+      File.open(tmpname, 'wb+') do |f|
+        yield f
+      end
+
+      File.rename(tmpname, filename)
+    ensure
+      File.delete(tmpname) if File.exist?(tmpname)
+    end
+    
+  end
+end

data/lib/condenser/version.rb

@@ -0,0 +1,3 @@
+class Condenser
+  VERSION = '0.0.1'
+end

data/lib/condenser/writers/file_writer.rb

@@ -0,0 +1,28 @@
+require 'condenser/utils'
+
+class Condenser
+  # Writes a an asset file to disk
+  class FileWriter
+
+    def skip?(asset, logger)
+      if ::File.exist?(asset.path)
+        logger.debug "Skipping #{ asset.filename }, already exists"
+        true
+      else
+        logger.info "Writing #{ asset.filename }"
+        false
+      end
+    end
+
+    def call(output_directory, asset)
+      filename = File.join(output_directory, asset.path)
+      FileUtils.mkdir_p(File.dirname(filename))
+      Utils.atomic_write(filename) do |file|
+        file.write(asset.source)
+      end
+      
+      [asset.filename]
+    end
+    
+  end
+end

data/lib/condenser/writers/zlib_writer.rb

@@ -0,0 +1,42 @@
+require 'zlib'
+require 'condenser/utils'
+
+class Condenser
+  # Generates a `.gz` file using the zlib algorithm built into
+  # Ruby's standard library.
+  class ZlibWriter
+
+    # What mime types should we compress? This list comes from:
+    # https://www.fastly.com/blog/new-gzip-settings-and-deciding-what-compress
+    COMPRESSALBE_TYPES = %w( text/html application/x-javascript text/css
+      application/javascript text/javascript text/plain text/xml
+      application/json application/vnd.ms-fontobject application/x-font-opentype
+      application/x-font-truetype application/x-font-ttf application/xml font/eot
+      font/opentype font/otf image/svg+xml image/vnd.microsoft.icon image/x-icon)
+
+    def skip?(asset, logger)
+      target = "#{asset.path}.gz"
+      if ::File.exist?(target)
+        logger.debug "Skipping #{ target }, already exists"
+        true
+      else
+        logger.info "Writing #{ target }"
+        false
+      end
+    end
+
+    def call(output_directory, asset)
+      filename = File.join(output_directory, "#{asset.path}.gz")
+      FileUtils.mkdir_p(File.dirname(filename))
+      Utils.atomic_write(filename) do |file|
+        gz = Zlib::GzipWriter.new(file, Zlib::BEST_COMPRESSION)
+        gz.write(asset.source)
+        gz.close
+        # File.utime(mtime, mtime, file.path)
+      end
+      
+      ["#{asset.filename}.gz"]
+    end
+    
+  end
+end

data/test/cache_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class CacheTest < ActiveSupport::TestCase
+  
+  def setup
+    super
+    @env.cache = Condenser::Cache::MemoryStore.new
+  end
+  
+  test 'resolving and asset twice only compiles once' do
+    file 'test.txt.erb', "1<%= 1 + 1 %>3\n"
+    
+    assert_file 'test.txt', 'text/plain', <<~CSS
+    123
+    CSS
+    
+    Condenser::Erubi.stubs(:call).never
+
+    assert_file 'test.txt', 'text/plain', <<~CSS
+    123
+    CSS
+  end
+
+end

data/test/environment_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class EnvironmentTest < ActiveSupport::TestCase
+  
+  def setup
+    super
+    @env.clear_path
+  end
+  
+  test "working directory is the default root" do
+    assert_equal Dir.pwd, Condenser.new.root
+  end
+
+  test "default logger level is set to warn" do
+    assert_equal Logger::WARN, @env.logger.level
+  end
+
+  test "paths" do
+    assert_equal [], @env.path
+  end
+  
+  test "prepend_path" do
+    assert_equal [], @env.path
+    @env.prepend_path 'a'
+    @env.prepend_path 'b'
+    assert_equal ['b', 'a'].map { |d| File.expand_path(d, @path) }, @env.path
+  end
+  
+  test "append_path" do
+    assert_equal [], @env.path
+    @env.append_path 'a'
+    @env.append_path 'b'
+    assert_equal ['a', 'b'].map { |d| File.expand_path(d, @path) }, @env.path
+  end
+  
+  test "clear_path" do
+    @env.append_path 'a'
+    assert_not_empty @env.path
+    @env.clear_path
+    assert_empty @env.path
+  end
+
+  test "digestor=" do
+    assert_equal @env.digestor, Digest::SHA256
+    @env.digestor = Digest::MD5
+    assert_equal @env.digestor, Digest::MD5
+  end
+  
+end

data/test/manifest_test.rb

@@ -0,0 +1,513 @@
+require 'test_helper'
+
+class ManifestTest < ActiveSupport::TestCase
+  
+  def setup
+    super
+    @dir = Dir.mktmpdir
+  end
+  
+  def teardown
+    super
+    FileUtils.remove_entry(@dir, true)
+  end
+
+  test "specify full manifest filename" do
+    directory = Dir::tmpdir
+    filename  = File.join(directory, 'manifest.json')
+
+    manifest = Condenser::Manifest.new(@env, filename)
+
+    assert_equal directory, manifest.directory
+    assert_equal filename,  manifest.filename
+  end
+
+  test "specify manifest directory yields manifest.json" do
+    manifest = Condenser::Manifest.new(@env, @dir)
+
+    assert_equal @dir, manifest.directory
+    assert_match('manifest.json', File.basename(manifest.filename))
+  end
+
+  test "must specify manifest directory or filename" do
+    assert_raises ArgumentError do
+      Condenser::Manifest.new(@env)
+    end
+  end
+
+  test "must specify env to compile assets" do
+    manifest = Condenser::Manifest.new(@dir)
+
+    assert_raises Condenser::Error do
+      manifest.compile('application.js')
+    end
+  end
+
+  test "compile asset" do
+    file 'application.js', <<-JS
+      console.log(1);
+    JS
+    manifest = Condenser::Manifest.new(@env, File.join(@dir, 'manifest.json'))
+
+    asset = @env['application.js']
+    assert !File.exist?("#{@dir}/#{asset.path}")
+
+    manifest.compile('application.js')
+    assert File.directory?(manifest.directory)
+    assert File.file?(manifest.filename)
+
+    assert File.exist?("#{@dir}/manifest.json")
+    assert File.exist?("#{@dir}/#{asset.path}")
+    assert File.exist?("#{@dir}/#{asset.path}.gz")
+
+    data = JSON.parse(File.read(manifest.filename))
+    assert data['application.js']
+    assert data['application.js']['size'] > 16
+    assert_equal asset.path, data['application.js']['path']
+  end
+
+  # TODO:
+  # test "compile asset with aliased index links" do
+  #   manifest = Sprockets::Manifest.new(@env, File.join(@dir, 'manifest.json'))
+  #
+  #   main_digest_path = @env['alias-index-link.js'].path
+  #   dep_digest_path = @env['coffee.js'].path
+  #
+  #   assert !File.exist?("#{@dir}/#{main_digest_path}")
+  #   assert !File.exist?("#{@dir}/#{dep_digest_path}")
+  #
+  #   manifest.compile('alias-index-link.js')
+  #   assert File.directory?(manifest.directory)
+  #   assert File.file?(manifest.filename)
+  #
+  #   assert File.exist?("#{@dir}/manifest.json")
+  #   assert File.exist?("#{@dir}/#{main_digest_path}")
+  #   assert File.exist?("#{@dir}/#{dep_digest_path}")
+  #
+  #   data = JSON.parse(File.read(manifest.filename))
+  #
+  #   assert data['files'][main_digest_path]
+  #   assert data['files'][dep_digest_path]
+  #   assert_equal "alias-index-link.js", data['files'][main_digest_path]['logical_path']
+  #   assert_equal "coffee.js", data['files'][dep_digest_path]['logical_path']
+  #   assert_equal main_digest_path, data['assets']['alias-index-link.js']
+  #   assert_equal dep_digest_path, data['assets']['coffee.js']
+  # end
+  #
+  test "compile to directory and seperate location" do
+    file 'application.js', <<-JS
+      console.log(1);
+    JS
+
+    root  = File.join(Dir::tmpdir, 'public')
+    dir   = File.join(root, 'assets')
+    path  = File.join(root, 'manifests', 'manifest-123.json')
+
+    FileUtils.remove_entry(root, true)
+
+    assert !File.exist?(root)
+    manifest = Condenser::Manifest.new(@env, dir, path)
+
+    manifest.compile('application.js')
+    assert File.directory?(manifest.directory)
+    assert File.file?(path)
+    FileUtils.remove_entry(root, true)
+  end
+
+  # TODO:
+  # test "compile asset with absolute path" do
+  #   manifest = Sprockets::Manifest.new(@env, File.join(@dir, 'manifest.json'))
+  #
+  #   digest_path = @env['gallery.js'].path
+  #
+  #   assert !File.exist?("#{@dir}/#{digest_path}")
+  #
+  #   manifest.compile(fixture_path('default/gallery.js'))
+  #
+  #   assert File.exist?("#{@dir}/manifest.json")
+  #   assert File.exist?("#{@dir}/#{digest_path}")
+  #
+  #   data = JSON.parse(File.read(manifest.filename))
+  #   assert data['files'][digest_path]
+  #   assert_equal digest_path, data['assets']['gallery.js']
+  # end
+
+  test "compile multiple assets" do
+    file 'application.js', <<-JS
+      console.log(1);
+    JS
+    
+    file 'gallery.css', <<-CSS
+      * { color: green }
+    CSS
+    
+    manifest = Condenser::Manifest.new(@env, File.join(@dir, 'manifest.json'))
+
+    app_digest_path = @env.find_export('application.js').path
+    gallery_digest_path = @env.find_export('gallery.css').path
+
+    assert !File.exist?("#{@dir}/#{app_digest_path}")
+    assert !File.exist?("#{@dir}/#{gallery_digest_path}")
+
+    manifest.compile('application.js', 'gallery.css')
+
+    assert File.exist?("#{@dir}/manifest.json")
+    puts app_digest_path
+    puts Dir.glob(File.join(@dir, '**/*'))
+    assert File.exist?("#{@dir}/#{app_digest_path}")
+    assert File.exist?("#{@dir}/#{gallery_digest_path}")
+
+    data = JSON.parse(File.read(manifest.filename))
+    assert data['application.js']
+    assert data['gallery.css']
+    assert_equal app_digest_path, data['application.js']['path']
+    assert_equal gallery_digest_path, data['gallery.css']['path']
+  end
+
+  # TODO:
+  # test "compile with transformed asset" do
+  #   assert svg_digest_path = @env['logo.svg'].path
+  #   assert png_digest_path = @env['logo.png'].path
+  #
+  #   assert !File.exist?("#{@dir}/#{svg_digest_path}")
+  #   assert !File.exist?("#{@dir}/#{png_digest_path}")
+  #
+  #   manifest = Sprockets::Manifest.new(@env, File.join(@dir, 'manifest.json'))
+  #   manifest.compile('logo.svg', 'logo.png')
+  #
+  #   assert File.exist?("#{@dir}/manifest.json")
+  #   assert File.exist?("#{@dir}/#{svg_digest_path}")
+  #   assert File.exist?("#{@dir}/#{png_digest_path}")
+  #
+  #   data = JSON.parse(File.read(manifest.filename))
+  #   assert data['files'][svg_digest_path]
+  #   assert data['files'][png_digest_path]
+  #   assert_equal svg_digest_path, data['assets']['logo.svg']
+  #   assert_equal png_digest_path, data['assets']['logo.png']
+  # end
+
+  # TODO:
+  # test "compile asset with links" do
+  #   manifest = Sprockets::Manifest.new(@env, File.join(@dir, 'manifest.json'))
+  #
+  #   main_digest_path = @env['gallery-link.js'].path
+  #   dep_digest_path  = @env['gallery.js'].path
+  #
+  #   assert !File.exist?("#{@dir}/#{main_digest_path}")
+  #   assert !File.exist?("#{@dir}/#{dep_digest_path}")
+  #
+  #   manifest.compile('gallery-link.js')
+  #   assert File.directory?(manifest.directory)
+  #   assert File.file?(manifest.filename)
+  #
+  #   assert File.exist?("#{@dir}/manifest.json")
+  #   assert File.exist?("#{@dir}/#{main_digest_path}")
+  #   assert File.exist?("#{@dir}/#{dep_digest_path}")
+  #
+  #   data = JSON.parse(File.read(manifest.filename))
+  #   assert data['files'][main_digest_path]
+  #   assert data['files'][dep_digest_path]
+  #   assert_equal "gallery-link.js", data['files'][main_digest_path]['logical_path']
+  #   assert_equal "gallery.js", data['files'][dep_digest_path]['logical_path']
+  #   assert_equal main_digest_path, data['assets']['gallery-link.js']
+  #   assert_equal dep_digest_path, data['assets']['gallery.js']
+  # end
+
+  # TODO:
+  # test "compile nested asset with links" do
+  #   manifest = Sprockets::Manifest.new(@env, File.join(@dir, 'manifest.json'))
+  #
+  #   main_digest_path   = @env['explore-link.js'].path
+  #   dep_digest_path    = @env['gallery-link.js'].path
+  #   subdep_digest_path = @env['gallery.js'].path
+  #
+  #   assert !File.exist?("#{@dir}/#{main_digest_path}")
+  #   assert !File.exist?("#{@dir}/#{dep_digest_path}")
+  #   assert !File.exist?("#{@dir}/#{subdep_digest_path}")
+  #
+  #   manifest.compile('explore-link.js')
+  #   assert File.directory?(manifest.directory)
+  #   assert File.file?(manifest.filename)
+  #
+  #   assert File.exist?("#{@dir}/manifest.json")
+  #   assert File.exist?("#{@dir}/#{main_digest_path}")
+  #   assert File.exist?("#{@dir}/#{dep_digest_path}")
+  #   assert File.exist?("#{@dir}/#{subdep_digest_path}")
+  #
+  #   data = JSON.parse(File.read(manifest.filename))
+  #   assert data['files'][main_digest_path]
+  #   assert data['files'][dep_digest_path]
+  #   assert data['files'][subdep_digest_path]
+  #   assert_equal "explore-link.js", data['files'][main_digest_path]['logical_path']
+  #   assert_equal "gallery-link.js", data['files'][dep_digest_path]['logical_path']
+  #   assert_equal "gallery.js", data['files'][subdep_digest_path]['logical_path']
+  #   assert_equal main_digest_path, data['assets']['explore-link.js']
+  #   assert_equal dep_digest_path, data['assets']['gallery-link.js']
+  #   assert_equal subdep_digest_path, data['assets']['gallery.js']
+  # end
+
+  test "recompile asset" do
+    file 'application.js', "console.log(1);"
+
+    manifest = Condenser::Manifest.new(@env, File.join(@dir, 'manifest.json'))
+
+    digest_path = @env['application.js'].path
+    assert !File.exist?("#{@dir}/#{digest_path}"), Dir["#{@dir}/*"].inspect
+
+    manifest.compile('application.js')
+
+    assert File.exist?("#{@dir}/manifest.json")
+    assert File.exist?("#{@dir}/#{digest_path}")
+
+    data = JSON.parse(File.read(manifest.filename))
+    assert data['application.js']
+    assert_equal digest_path, data['application.js']['path']
+
+    File.write(File.join(@path, 'application.js'), "console.log(2);")
+
+    # mtime = Time.now + 1
+    # File.utime(mtime, mtime, filename)
+    new_digest_path = @env['application.js'].path
+    assert_not_equal new_digest_path, digest_path
+
+    manifest.compile('application.js')
+
+    assert File.exist?("#{@dir}/manifest.json")
+    assert File.exist?("#{@dir}/#{digest_path}")
+    assert File.exist?("#{@dir}/#{new_digest_path}")
+
+    data = JSON.parse(File.read(manifest.filename))
+    assert data['application.js']
+    assert_equal new_digest_path, data['application.js']['path']
+  end
+
+  test "test manifest does not exist" do
+    file 'application.js', "console.log(1);"
+
+    assert !File.exist?("#{@dir}/manifest.json")
+
+    manifest = Condenser::Manifest.new(@env, File.join(@dir, 'manifest.json'))
+    manifest.compile('application.js')
+
+    assert File.exist?("#{@dir}/manifest.json")
+    data = JSON.parse(File.read(manifest.filename))
+    assert data['application.js']
+  end
+
+  test "test blank manifest" do
+    file 'application.js', "console.log(1);"
+
+    assert !File.exist?("#{@dir}/manifest.json")
+
+    FileUtils.mkdir_p(@dir)
+    File.write("#{@dir}/manifest.json", '{}')
+    assert_equal "{}", File.read("#{@dir}/manifest.json")
+
+    manifest = Condenser::Manifest.new(@env, File.join(@dir, 'manifest.json'))
+    manifest.compile('application.js')
+
+    assert File.exist?("#{@dir}/manifest.json")
+    data = JSON.parse(File.read(manifest.filename))
+    assert data['application.js']
+  end
+
+  test "test skip invalid manifest" do
+    file 'application.js', "console.log(1);"
+
+    assert !File.exist?("#{@dir}/manifest.json")
+
+    FileUtils.mkdir_p(@dir)
+    File.write("#{@dir}/manifest.json", "not valid json;")
+    assert_equal "not valid json;", File.read("#{@dir}/manifest.json")
+
+    manifest = Condenser::Manifest.new(@env, File.join(@dir, 'manifest.json'))
+    manifest.compile('application.js')
+
+    assert File.exist?("#{@dir}/manifest.json")
+    data = JSON.parse(File.read(manifest.filename))
+    assert data['application.js']
+  end
+
+  test "nil environment raises compilation error" do
+    assert !File.exist?("#{@dir}/manifest.json")
+
+    manifest = Condenser::Manifest.new(nil, File.join(@dir, 'manifest.json'))
+    assert_raises Condenser::Error do
+      manifest.compile('application.js')
+    end
+  end
+
+  test "no environment raises compilation error" do
+    assert !File.exist?("#{@dir}/manifest.json")
+
+    manifest = Condenser::Manifest.new(File.join(@dir, 'manifest.json'))
+    assert_raises Condenser::Error do
+      manifest.compile('application.js')
+    end
+  end
+
+  # TODO:
+  # test "find_sources with environment" do
+  #   manifest = Sprockets::Manifest.new(@env, @dir)
+  #
+  #   result = manifest.find_sources("mobile/a.js", "mobile/b.js")
+  #   assert_equal ["var A;\n", "var B;\n"], result.to_a.sort
+  #
+  #   result = manifest.find_sources("not_existent.js", "also_not_existent.js")
+  #   assert_equal [], result.to_a
+  #
+  #   result = manifest.find_sources("mobile/a.js", "also_not_existent.js")
+  #   assert_equal ["var A;\n"], result.to_a
+  # end
+
+  # TODO:
+  # test "find_sources without environment" do
+  #   manifest = Sprockets::Manifest.new(@env, @dir)
+  #   manifest.compile('mobile/a.js', 'mobile/b.js')
+  #
+  #   manifest = Sprockets::Manifest.new(nil, @dir)
+  #
+  #   result = manifest.find_sources("mobile/a.js", "mobile/b.js")
+  #   assert_equal ["var A;\n", "var B;\n"], result.to_a
+  #
+  #   result = manifest.find_sources("not_existent.js", "also_not_existent.js")
+  #   assert_equal [], result.to_a
+  #
+  #   result = manifest.find_sources("mobile/a.js", "also_not_existent.js")
+  #   assert_equal ["var A;\n"], result.to_a
+  # end
+
+  test "compress non-binary assets" do
+    file 'gallery.css', 'x'
+    file 'application.js', 'x'
+    file 'logo.svg', 'x'
+    file 'favicon.ico', 'x'
+
+    manifest = Condenser::Manifest.new(@env, @dir)
+    %W{ gallery.css application.js logo.svg favicon.ico }.each do |file_name|
+      original_path = @env[file_name].path
+      manifest.compile(file_name)
+      assert File.exist?("#{@dir}/#{original_path}.gz"), "Expecting '#{original_path}' to generate gzipped file: '#{original_path}.gz' but it did not"
+    end
+  end
+
+  # TODO:
+  # test "writes gzip files even if files were already on disk" do
+  #   @env.gzip = false
+  #   manifest = Sprockets::Manifest.new(@env, @dir)
+  #   files = %W{ gallery.css application.js logo.svg favicon.ico}
+  #   files.each do |file_name|
+  #     original_path = @env[file_name].path
+  #     manifest.compile(file_name)
+  #     assert File.exist?("#{@dir}/#{original_path}"), "Expecting '#{@dir}/#{original_path}' to exist but did not"
+  #   end
+  #
+  #   @env.gzip = true
+  #   files.each do |file_name|
+  #     original_path = @env[file_name].path
+  #     manifest.compile(file_name)
+  #     assert File.exist?("#{@dir}/#{original_path}.gz"), "Expecting '#{original_path}' to generate gzipped file: '#{original_path}.gz' but it did not"
+  #   end
+  # end
+
+  # TODO:
+  # test "disable file gzip" do
+  #   @env.gzip = false
+  #   manifest = Sprockets::Manifest.new(@env, @dir)
+  #   %W{ gallery.css application.js logo.svg favicon.ico }.each do |file_name|
+  #     original_path = @env[file_name].path
+  #     manifest.compile(file_name)
+  #     refute File.exist?("#{@dir}/#{original_path}.gz"), "Expecting '#{original_path}' to not generate gzipped file: '#{original_path}.gz' but it did"
+  #   end
+  # end
+
+  test "do not compress binary assets" do
+    file 'blank.gif', Random.new.bytes(128)
+
+    manifest = Condenser::Manifest.new(@env, @path)
+    %W{ blank.gif }.each do |file_name|
+      original_path = @env[file_name].path
+      manifest.compile(file_name)
+      refute File.exist?("#{@path}/#{original_path}.gz"), "Expecting '#{original_path}' to not generate gzipped file: '#{original_path}.gz' but it did"
+    end
+  end
+
+  # TODO:
+  # test 'raises exception when gzip fails' do
+  #   manifest = Sprockets::Manifest.new(@env, @dir)
+  #   Zlib::GzipWriter.stub(:new, -> (io, level) { fail 'kaboom' }) do
+  #     ex = assert_raises(RuntimeError) { manifest.compile('application.js') }
+  #     assert_equal 'kaboom', ex.message
+  #   end
+  # end
+  #
+  # # Sleep duration to context switch between concurrent threads.
+  # CONTEXT_SWITCH_DURATION = 0.1
+  #
+  # # Record Exporter sequence with a delay to test concurrency.
+  # class SlowExporter < Sprockets::Exporters::Base
+  #   class << self
+  #     attr_accessor :seq
+  #   end
+  #
+  #   def call
+  #     SlowExporter.seq << '0'
+  #     sleep CONTEXT_SWITCH_DURATION
+  #     SlowExporter.seq << '1'
+  #   end
+  # end
+  #
+  # class SlowExporter2 < SlowExporter
+  # end
+  #
+  # test 'concurrent exporting' do
+  #   # Register 2 exporters and compile 2 files to ensure that
+  #   # all 4 exporting tasks run concurrently.
+  #   SlowExporter.seq = []
+  #   @env.register_exporter 'image/png',SlowExporter
+  #   @env.register_exporter 'image/png',SlowExporter2
+  #   Sprockets::Manifest.new(@env, @dir).compile('logo.png', 'troll.png')
+  #   refute_equal %w(0 1 0 1 0 1 0 1), SlowExporter.seq
+  # end
+  #
+  # test 'sequential exporting' do
+  #   @env.export_concurrent = false
+  #   SlowExporter.seq = []
+  #   @env.register_exporter 'image/png',SlowExporter
+  #   @env.register_exporter 'image/png',SlowExporter2
+  #   Sprockets::Manifest.new(@env, @dir).compile('logo.png', 'troll.png')
+  #   assert_equal %w(0 1 0 1 0 1 0 1), SlowExporter.seq
+  # end
+  #
+  # # Record Processor sequence with a delay to test concurrency.
+  # class SlowProcessor
+  #   attr_reader :seq
+  #
+  #   def initialize
+  #     @seq = []
+  #   end
+  #
+  #   def call(_)
+  #     seq << '0'
+  #     sleep CONTEXT_SWITCH_DURATION
+  #     seq << '1'
+  #     nil
+  #   end
+  # end
+  #
+  # test 'concurrent processing' do
+  #   processor = SlowProcessor.new
+  #   @env.register_postprocessor 'image/png', processor
+  #   Sprockets::Manifest.new(@env, @dir).compile('logo.png', 'troll.png')
+  #   refute_equal %w(0 1 0 1), processor.seq
+  # end
+  #
+  # test 'sequential processing' do
+  #   @env.export_concurrent = false
+  #   processor = SlowProcessor.new
+  #   @env.register_postprocessor 'image/png', processor
+  #   Sprockets::Manifest.new(@env, @dir).compile('logo.png', 'troll.png')
+  #   assert_equal %w(0 1 0 1), processor.seq
+  # end
+
+end