condenser 0.0.1

data/test/pipeline_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class PipelineTest < ActiveSupport::TestCase
+  
+  def setup
+    super
+    @env.clear_pipeline
+  end
+  
+  test 'clear_pipeline' do
+    @env.register_mime_type      'application/javascript', extension: 'js', charset: :unicode
+    @env.register_template       'application/erb', PipelineTest
+    @env.register_preprocessor   'application/javascript', PipelineTest
+    @env.register_transformer    'application/scss', 'application/css', PipelineTest
+    @env.register_postprocessor  'application/javascript', PipelineTest
+    @env.register_minifier       'application/javascript', PipelineTest
+    @env.register_writer         '*/*', PipelineTest
+
+    vars = %w(templates preprocessors transformers postprocessors minifiers writers)
+    vars.each do |var|
+      assert_not_empty @env.send(var)
+    end
+    
+    @env.clear_pipeline
+    
+    vars.each do |var|
+      assert_empty @env.send(var)
+    end
+  end
+  
+end

data/test/preprocessor/babel_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+class CondenserBabelTest < ActiveSupport::TestCase
+  
+  test 'find' do
+    file 'name.js', <<~JS
+    var t = { 'var': () => { return 2; } };
+    
+    export {t as name1};
+    JS
+
+    assert_file 'name.js', 'application/javascript', <<~JS
+    var t = { 'var': function _var() {
+        return 2;
+      } };
+    
+    export { t as name1 };
+    JS
+  end
+  
+end

data/test/processors/rollup_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class RollupTest < ActiveSupport::TestCase
+  
+  def setup
+    super
+    @env.unregister_preprocessor('application/javascript', Condenser::BabelProcessor)
+  end
+  
+  test 'import file' do
+    file 'main.js', <<~JS
+      import { cube } from './math.js';
+
+      console.log( cube( 5 ) ); // 125
+    JS
+    file 'math.js', <<~JS
+    
+      // This function isn't used anywhere, so
+      // Rollup excludes it from the bundle...
+      export function square ( x ) {
+        return x * x;
+      }
+
+      // This function gets included
+      export function cube ( x ) {
+        return x * x * x;
+      }
+    JS
+
+    assert_exported_file 'main.js', 'application/javascript', <<~FILE
+      (function () {
+      'use strict';
+
+      // This function gets included
+      function cube ( x ) {
+        return x * x * x;
+      }
+
+      console.log( cube( 5 ) ); // 125
+
+      }());
+    FILE
+  end
+  
+  test 'import an erb file' do
+    file 'main.js', <<~JS
+      import { cube } from './math.js';
+
+      console.log( cube( 5 ) ); // 125
+    JS
+    file 'math.js.erb', <<~JS
+      export function cube ( x ) {
+        return <%= 2 %> * x * x;
+      }
+    JS
+    
+    assert_exported_file 'main.js', 'application/javascript', <<~FILE
+      (function () {
+      'use strict';
+
+      function cube ( x ) {
+        return 2 * x * x;
+      }
+
+      console.log( cube( 5 ) ); // 125
+
+      }());
+    FILE
+  end
+  
+end

data/test/resolve_test.rb

@@ -0,0 +1,105 @@
+require 'test_helper'
+
+class ResolveTest < ActiveSupport::TestCase
+  
+  def setup
+    super
+    @env.clear_pipeline
+    @env.register_template  'application/erb', Condenser::Erubi
+    @env.register_transformer 'text/scss', 'text/css', Condenser::Erubi
+    @env.register_exporter     'application/javascript', Condenser::RollupProcessor
+    @env.register_writer 'application/javascript', Condenser::Erubi, 'application/gzip'
+  end
+  
+  test 'decompose_path' do
+    assert_equal [nil, 'test', ['.text'], ['text/plain']], @env.decompose_path('test.text')
+    
+    assert_equal ['dir', 'test', ['.text'], ['text/plain']], @env.decompose_path('dir/test.text')
+    
+    assert_equal ['dir', 'test.unkownmime', ['.text'], ['text/plain']], @env.decompose_path('dir/test.unkownmime.text')
+    
+    assert_equal [nil, '*', nil, []], @env.decompose_path('*')
+    assert_equal ['*', '*', nil, []], @env.decompose_path('*/*')
+    assert_equal ['**', '*', nil, []], @env.decompose_path('**/*')
+    
+    assert_equal ['test', '*', nil, []], @env.decompose_path('test/*')
+    assert_equal ['test/*', '*', nil, []], @env.decompose_path('test/*/*')
+    assert_equal ['test/**', '*', nil, []], @env.decompose_path('test/**/*')
+    
+    assert_equal [nil, '*', ['.js'], ['application/javascript']], @env.decompose_path('*.js')
+    assert_equal ['*', '*', ['.js'], ['application/javascript']], @env.decompose_path('*/*.js')
+    assert_equal ['**', '*', ['.js'], ['application/javascript']], @env.decompose_path('**/*.js')
+    
+    assert_equal ['test', '*', ['.js'], ['application/javascript']], @env.decompose_path('test/*.js')
+    assert_equal ['test/*', '*', ['.js'], ['application/javascript']], @env.decompose_path('test/*/*.js')
+    assert_equal ['test/**', '*', ['.js'], ['application/javascript']], @env.decompose_path('test/**/*.js')
+  end
+  
+  test 'resolve' do
+    file 'file.js', 'test'
+    file 'test/file.scss', 'test'
+    file 'test/z/file.js', 'test'
+    
+    assert_file('file.js', 'application/javascript')
+    assert_file('test/file.css', 'text/css')
+    
+    assert_equal %w(file.js test/file.css test/z/file.js), @env.resolve('**/*').map(&:filename)
+    assert_equal %w(file.js test/file.css test/z/file.js), @env.resolve('**/*', accept: ['text/css', 'application/javascript']).map(&:filename)
+    assert_equal %w(file.js), @env.resolve('*', accept: ['application/javascript']).map(&:filename)
+    assert_equal %w(file.js test/z/file.js), @env.resolve('**/*', accept: ['application/javascript']).map(&:filename)
+    assert_equal %w(file.js), @env.resolve('*.js').map(&:filename)
+    assert_equal %w(file.js test/z/file.js), @env.resolve('**/*.js').map(&:filename)
+
+    
+    assert_equal %w(test/file.css), @env.resolve('test/*').map(&:filename)
+    assert_equal %w(test/file.css), @env.resolve('test/*', accept: ['text/css', 'application/javascript']).map(&:filename)
+    assert_equal %w(test/file.css test/z/file.js), @env.resolve('test/**/*').map(&:filename)
+    assert_equal %w(test/file.css test/z/file.js), @env.resolve('test/**/*', accept: ['text/css', 'application/javascript']).map(&:filename)
+    assert_equal %w(test/z/file.js), @env.resolve('test/z/*', accept: ['application/javascript']).map(&:filename)
+    assert_equal %w(test/z/file.js), @env.resolve('test/**/*', accept: ['application/javascript']).map(&:filename)
+    assert_equal %w(test/z/file.js), @env.resolve('test/z/*.js').map(&:filename)
+    assert_equal %w(test/z/file.js), @env.resolve('test/**/*.js').map(&:filename)
+  end
+  
+  test 'relative require' do
+    file 'a/main.js', <<~JS
+      import { cube } from './math.js';
+      console.log( cube( 5 ) ); // 125
+    JS
+    file 'a/math.js', <<~JS
+      export function cube ( x ) {
+        return x * x * x;
+      }
+    JS
+
+    file 'b/math.js', <<~JS
+      export function square ( x ) {
+        return x * x;
+      }
+    JS
+
+    @env.append_path File.join(@path, 'b')
+    @env.append_path File.join(@path, 'a')
+
+    
+    assert_exported_file('main.js', 'application/javascript', <<~JS)
+      (function () {
+      'use strict';
+
+      function cube ( x ) {
+        return x * x * x;
+      }
+
+      console.log( cube( 5 ) ); // 125
+
+      }());
+    JS
+  end
+  
+  test 'resolve! raises NotFound' do
+    assert_raises Condenser::FileNotFound do
+      @env.resolve!('**/*')
+    end
+  end
+  
+end

data/test/server_test.rb

@@ -0,0 +1,361 @@
+require 'test_helper'
+require 'rack/builder'
+require 'rack/test'
+
+class ServerTest < ActiveSupport::TestCase
+  include Rack::Test::Methods
+  
+  def setup
+    super
+    server = Condenser::Server.new(@env)
+    @app = nil
+    @condenser_server = Rack::Builder.new do
+      map "/assets" do
+        run server
+      end
+    end
+
+    file 'foo.js', <<~JS
+      console.log(1);
+    JS
+  end
+  
+  def app
+    @app ||= Rack::Lint.new(@condenser_server)
+  end
+  
+  test "serve single source file" do
+    get "/assets/foo.js"
+    assert_equal 200, last_response.status
+    assert_equal "53", last_response.headers['Content-Length']
+    assert_equal "Accept-Encoding", last_response.headers['Vary']
+    assert_equal <<~JS, last_response.body
+      (function () {
+      'use strict';
+
+      console.log(1);
+
+      }());
+    JS
+  end
+
+  # TODO:
+  # test "serve single source file from cached environment" do
+  #   get "/cached/javascripts/foo.js"
+  #   assert_equal "var foo;\n", last_response.body
+  # end
+
+  test "serve source with dependencies" do
+    file 'main.js', <<~JS
+      import { cube } from './math.js';
+
+      console.log( cube( 5 ) ); // 125
+    JS
+    file 'math.js', <<~JS
+      export function cube ( x ) {
+        return x * x * x;
+      }
+    JS
+
+    get "/assets/main.js"
+    assert_equal <<~JS, last_response.body
+      (function () {
+      'use strict';
+
+      function cube(x) {
+        return x * x * x;
+      }
+
+      console.log(cube(5)); // 125
+
+      }());
+    JS
+  end
+
+  test "serve source with content type headers" do
+    file 'main.css', <<~CSS
+      body { background: green ; }
+    CSS
+
+    get "/assets/foo.js"
+    assert_equal "application/javascript", last_response.headers['Content-Type']
+
+    get "/assets/main.css"
+    assert_equal "text/css; charset=utf-8", last_response.headers['Content-Type']
+  end
+
+  test "serve source with etag headers" do
+    get "/assets/foo.js"
+
+    digest = '85b4185243c9cf4935e686f910a410762c2632a044118ac7ef030094be635c18'
+    assert_equal "\"#{digest}\"", last_response.headers['ETag']
+  end
+
+  test "not modified partial response when if-none-match etags match" do
+    get "/assets/foo.js"
+    assert_equal 200, last_response.status
+    etag, cache_control, expires, vary = last_response.headers.values_at(
+      'ETag', 'Cache-Control', 'Expires', 'Vary'
+    )
+
+    assert_nil expires
+    get "/assets/foo.js", {},
+      'HTTP_IF_NONE_MATCH' => etag
+
+    assert_equal 304, last_response.status
+
+    # Allow 304 headers
+    assert_equal cache_control, last_response.headers['Cache-Control']
+    assert_equal etag, last_response.headers['ETag']
+    assert_nil last_response.headers['Expires']
+    assert_equal vary, last_response.headers['Vary']
+
+    # Disallowed 304 headers
+    refute last_response.headers['Content-Type']
+    refute last_response.headers['Content-Length']
+    refute last_response.headers['Content-Encoding']
+  end
+
+  test "response when if-none-match etags don't match" do
+    get "/assets/foo.js", {},
+      'HTTP_IF_NONE_MATCH' => "nope"
+
+    assert_equal 200, last_response.status
+    assert_equal '"85b4185243c9cf4935e686f910a410762c2632a044118ac7ef030094be635c18"', last_response.headers['ETag']
+    assert_equal '53', last_response.headers['Content-Length']
+  end
+
+  test "not modified partial response with fingerprint and if-none-match etags match" do
+    get "/assets/foo.js"
+    assert_equal 200, last_response.status
+
+    etag   = last_response.headers['ETag']
+    digest = etag[/"(.+)"/, 1]
+
+    get "/assets/foo-#{digest}.js", {},
+      'HTTP_IF_NONE_MATCH' => etag
+    assert_equal 304, last_response.status
+  end
+
+  test "ok response with fingerprint and if-nonematch etags don't match" do
+    get "/assets/foo.js"
+    assert_equal 200, last_response.status
+
+    etag   = last_response.headers['ETag']
+    digest = etag[/"(.+)"/, 1]
+
+    get "/assets/foo-#{digest}.js", {},
+      'HTTP_IF_NONE_MATCH' => "nope"
+    assert_equal 200, last_response.status
+  end
+
+  test "not found with if-none-match" do
+    get "/assets/missing.js", {},
+      'HTTP_IF_NONE_MATCH' => '"000"'
+    assert_equal 404, last_response.status
+  end
+
+  test "not found fingerprint with if-none-match" do
+    get "/assets/missing-b452c9ae1d5c8d9246653e0d93bc83abce0ee09ef725c0f0a29a41269c217b83.js", {},
+      'HTTP_IF_NONE_MATCH' => '"b452c9ae1d5c8d9246653e0d93bc83abce0ee09ef725c0f0a29a41269c217b83"'
+    assert_equal 404, last_response.status
+  end
+
+  test "not found with response with incorrect fingerprint and matching if-none-match etags" do
+    get "/assets/foo.js"
+    assert_equal 200, last_response.status
+
+    etag = last_response.headers['ETag']
+
+    get "/assets/foo-0000000000000000000000000000000000000000.js", {},
+      'HTTP_IF_NONE_MATCH' => etag
+    assert_equal 404, last_response.status
+  end
+
+  test "ok partial response when if-match etags match" do
+    get "/assets/foo.js"
+    assert_equal 200, last_response.status
+    etag = last_response.headers['ETag']
+
+    get "/assets/foo.js", {},
+      'HTTP_IF_MATCH' => etag
+
+    assert_equal 200, last_response.status
+    assert_equal '"85b4185243c9cf4935e686f910a410762c2632a044118ac7ef030094be635c18"', last_response.headers['ETag']
+    assert_equal '53', last_response.headers['Content-Length']
+  end
+
+  test "precondition failed with if-match is a mismatch" do
+    get "/assets/foo.js", {},
+      'HTTP_IF_MATCH' => '"000"'
+    assert_equal 412, last_response.status
+
+    refute last_response.headers['ETag']
+  end
+
+  test "not found with if-match" do
+    get "/assets/missing.js", {},
+      'HTTP_IF_MATCH' => '"000"'
+    assert_equal 404, last_response.status
+  end
+
+  # TODO:
+  # test "if sources didnt change the server shouldnt rebundle" do
+  #   get "/assets/application.js"
+  #   asset_before = @env["application.js"]
+  #   assert asset_before
+  #
+  #   get "/assets/application.js"
+  #   asset_after = @env["application.js"]
+  #   assert asset_after
+  #
+  #   assert asset_before.eql?(asset_after)
+  # end
+  #
+  test "fingerprint digest sets expiration to the future" do
+    get "/assets/foo.js"
+    digest = last_response.headers['ETag'][/"(.+)"/, 1]
+
+    get "/assets/foo-#{digest}.js"
+    assert_equal 200, last_response.status
+    assert_match %r{max-age}, last_response.headers['Cache-Control']
+    assert_match %r{immutable}, last_response.headers['Cache-Control']
+  end
+
+  test "bad fingerprint digest returns a 404" do
+    get "/assets/foo-0000000000000000000000000000000000000000.js"
+    assert_equal 404, last_response.status
+
+    head "/assets/foo-0000000000000000000000000000000000000000.js"
+    assert_equal 404, last_response.status
+    assert_equal "0", last_response.headers['Content-Length']
+    assert_equal "", last_response.body
+  end
+
+  test "missing source" do
+    get "/assets/none.js"
+    assert_equal 404, last_response.status
+    assert_equal "pass", last_response.headers['X-Cascade']
+  end
+
+  test "re-throw JS exceptions in the browser" do
+    file 'error.js', "var error = {;"
+
+    get "/assets/error.js"
+    assert_equal 200, last_response.status
+    assert_match(/SyntaxError: error\.js: Unexpected token/, last_response.body)
+  end
+
+  test "display CSS exceptions in the browser" do
+    file 'error.scss', "* { color: $test; }"
+
+    get "/assets/error.css"
+    assert_equal 200, last_response.status
+    assert_match %r{content: ".*?Sass::SyntaxError}, last_response.body
+  end
+
+  test "serve encoded utf-8 filename" do
+    file '日本語.js', <<~JS
+      var japanese = "日本語";
+
+      console.log(japanese);
+    JS
+    get "/assets/%E6%97%A5%E6%9C%AC%E8%AA%9E.js"
+    assert_equal <<~JS, last_response.body
+    (function () {
+    'use strict';
+
+    var japanese = "日本語";
+
+    console.log(japanese);
+
+    }());
+    JS
+  end
+
+  test "illegal require outside load path" do
+    get "/assets//etc/passwd"
+    assert_equal 403, last_response.status
+
+    get "/assets/%2fetc/passwd"
+    assert_equal 403, last_response.status
+
+    get "/assets//%2fetc/passwd"
+    assert_equal 403, last_response.status
+
+    get "/assets/%2f/etc/passwd"
+    assert_equal 403, last_response.status
+
+    get "/assets/../etc/passwd"
+    assert_equal 403, last_response.status
+
+    get "/assets/%2e%2e/etc/passwd"
+    assert_equal 403, last_response.status
+
+    get "/assets/.-0000000./etc/passwd"
+    assert_equal 403, last_response.status
+
+    head "/assets/.-0000000./etc/passwd"
+    assert_equal 403, last_response.status
+    assert_equal "0", last_response.headers['Content-Length']
+    assert_equal "", last_response.body
+  end
+
+  # TODO:
+  # test "add new source to tree" do
+  #   filename = fixture_path("server/app/javascripts/baz.js")
+  #
+  #   sandbox filename do
+  #     get "/assets/tree.js"
+  #     assert_equal "var foo;\n\n(function () {\n  application.boot();\n})();\nvar bar;\nvar japanese = \"日本語\";\n", last_response.body
+  #
+  #     File.open(filename, "w") do |f|
+  #       f.write "var baz;\n"
+  #     end
+  #
+  #     path = fixture_path "server/app/javascripts"
+  #     mtime = Time.now + 60
+  #     File.utime(mtime, mtime, path)
+  #
+  #     get "/assets/tree.js"
+  #     assert_equal "var foo;\n\n(function () {\n  application.boot();\n})();\nvar bar;\nvar baz;\nvar japanese = \"日本語\";\n", last_response.body
+  #   end
+  # end
+
+  test "serving static assets" do
+    bytes = Random.new.bytes(128)
+    file 'logo.png', bytes
+
+    get "/assets/logo.png"
+    assert_equal 200, last_response.status
+    assert_equal "image/png", last_response.headers['Content-Type']
+    refute last_response.headers['Content-Encoding']
+    assert_equal bytes, last_response.body
+  end
+
+  test "disallow non-get methods" do
+    get "/assets/foo.js"
+    assert_equal 200, last_response.status
+
+    head "/assets/foo.js"
+    assert_equal 200, last_response.status
+    assert_equal "application/javascript", last_response.headers['Content-Type']
+    assert_equal "0", last_response.headers['Content-Length']
+    assert_equal "", last_response.body
+
+    post "/assets/foo.js"
+    assert_equal 405, last_response.status
+
+    put "/assets/foo.js"
+    assert_equal 405, last_response.status
+
+    delete "/assets/foo.js"
+    assert_equal 405, last_response.status
+  end
+
+  test "invalid URLs" do
+    get "/assets/%E2%EF%BF%BD%A6.js"
+    assert_equal 400, last_response.status
+  end
+  
+end