Barback transforms now pass through the primary input by default.

pkg/barback/test/package_graph/transform_test.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library barback.test.package_graph.transform_test;
 
 import 'package:barback/src/utils.dart';
 import 'package:scheduled_test/scheduled_test.dart';
 
 import '../utils.dart';
@@ skipping 102 matching lines @@
     expect(transformerB.isRunning, completion(isTrue));
 
     transformerA.resumeApply();
     transformerB.resumeApply();
 
     expectAsset("app|foo.a", "foo.a");
     expectAsset("app|foo.b", "foo.b");
     buildShouldSucceed();
   });
 
-  test("outputs are inaccessible once used", () {
+  test("outputs are passed through transformers by default", () {
     initGraph(["app|foo.a"], {"app": [
       [new RewriteTransformer("a", "b")],
       [new RewriteTransformer("a", "c")]
     ]});
     updateSources(["app|foo.a"]);
+    expectAsset("app|foo.a", "foo");
     expectAsset("app|foo.b", "foo.b");
-    expectNoAsset("app|foo.a");
-    expectNoAsset("app|foo.c");
+    expectAsset("app|foo.c", "foo.c");
     buildShouldSucceed();
   });
 
   test("does not reapply transform when inputs are not modified", () {
     var transformer = new RewriteTransformer("blub", "blab");
     initGraph(["app|foo.blub"], {"app": [[transformer]]});
     updateSources(["app|foo.blub"]);
     expectAsset("app|foo.blab", "foo.blab");
     expectAsset("app|foo.blab", "foo.blab");
     expectAsset("app|foo.blab", "foo.blab");
@@ skipping 402 matching lines @@
 
     rewrite.pauseApply();
     updateSources(["app|foo.txt"]);
     expectAssetDoesNotComplete("app|foo.txt");
 
     rewrite.resumeApply();
     expectAsset("app|foo.txt", "foo.txt");
     buildShouldSucceed();
   });
 
-  test("doesn't return an asset until we know it won't be transformed",
-      () {
+  test("doesn't return a pass-through asset until we know it won't be "
+      "overwritten", () {
     var rewrite = new RewriteTransformer("txt", "txt");
     initGraph(["app|foo.a"], {"app": [[rewrite]]});
 
     rewrite.pauseIsPrimary("app|foo.a");
     updateSources(["app|foo.a"]);
     expectAssetDoesNotComplete("app|foo.a");
 
     rewrite.resumeIsPrimary("app|foo.a");
     expectAsset("app|foo.a", "foo");
     buildShouldSucceed();
   });
 
-  test("doesn't return a modified asset until we know it will still be "
-      "transformed", () {
+  test("doesn't return a pass-through asset until we know it won't be "
+      "overwritten when secondary inputs change", () {
+    var manyToOne = new ManyToOneTransformer("txt");
+    initGraph({
+      "app|foo.txt": "bar.in",
+      "app|bar.in": "bar"
+    }, {"app": [[manyToOne]]});
+
+    updateSources(["app|foo.txt", "app|bar.in"]);
+    expectAsset("app|foo.txt", "bar.in");
+    expectAsset("app|foo.out", "bar");
+
+    manyToOne.pauseApply();
+    updateSources(["app|bar.in"]);
+    expectAssetDoesNotComplete("app|foo.txt");
+
+    manyToOne.resumeApply();
+    expectAsset("app|foo.txt", "bar.in");
+    buildShouldSucceed();
+  });
+
+  test("doesn't return an overwritten asset until we know it will still "
+      "be overwritten", () {
     var rewrite = new RewriteTransformer("txt", "txt");
     initGraph(["app|foo.txt"], {"app": [[rewrite]]});
 
     updateSources(["app|foo.txt"]);
     expectAsset("app|foo.txt", "foo.txt");
     buildShouldSucceed();
 
     rewrite.pauseIsPrimary("app|foo.txt");
     updateSources(["app|foo.txt"]);
     expectAssetDoesNotComplete("app|foo.txt");
@@ skipping 260 matching lines @@
         [new RewriteTransformer("zip", "zap")],
         [new RewriteTransformer("mid", "out")],
       ]});
 
       updateSources(["app|foo.in", "app|bar.zip"]);
       expectAsset("app|foo.out", "foo.mid.out");
       expectAsset("app|bar.zap", "bar.zap");
       buildShouldSucceed();
     });
 
-    test("doesn't pass an asset through a phase in which a transform consumes "
-        "it", () {
+    test("passes an asset through a phase in which a transform uses it", () {
       initGraph([
         "app|foo.in",
       ], {"app": [
         [new RewriteTransformer("in", "mid")],
         [new RewriteTransformer("mid", "phase2")],
         [new RewriteTransformer("mid", "phase3")],
       ]});
 
       updateSources(["app|foo.in"]);
+      expectAsset("app|foo.in", "foo");
+      expectAsset("app|foo.mid", "foo.mid");
       expectAsset("app|foo.phase2", "foo.mid.phase2");
-      expectNoAsset("app|foo.phase3");
+      expectAsset("app|foo.phase3", "foo.mid.phase3");
       buildShouldSucceed();
     });
 
+    // If the asset were to get passed through, it might either cause a
+    // collision or silently supersede the overwriting asset. We want to assert
+    // that that doesn't happen.
+    test("doesn't pass an asset through a phase in which a transform "
+        "overwrites it", () {
+      initGraph([
+        "app|foo.txt"
+      ], {"app": [[new RewriteTransformer("txt", "txt")]]});
+
+      updateSources(["app|foo.txt"]);
+      expectAsset("app|foo.txt", "foo.txt");
+      buildShouldSucceed();
+    });
+
     test("removes a pass-through asset when the source is removed", () {
       initGraph([
         "app|foo.in",
         "app|bar.zip",
       ], {"app": [
         [new RewriteTransformer("zip", "zap")],
         [new RewriteTransformer("in", "out")],
       ]});
 
       updateSources(["app|foo.in", "app|bar.zip"]);
@@ skipping 77 matching lines @@
       modifyAsset("app|foo.txt", "bar");
       updateSources(["app|foo.txt"]);
       // Ensure we're waiting on [check.isPrimary]
       schedule(pumpEventQueue);
 
       removeSources(["app|foo.txt"]);
       check.resumeIsPrimary("app|foo.txt");
       expectNoAsset("app|foo.txt");
       buildShouldSucceed();
     });
+
+    test("passes an asset through when its overwriting transform becomes "
+        "non-primary during apply", () {
+      var check = new CheckContentTransformer("yes", " modified");
+      initGraph({"app|foo.txt": "yes"}, {"app": [[check]]});
+
+      check.pauseApply();
+      updateSources(["app|foo.txt"]);
+      expectAssetDoesNotComplete("app|foo.txt");
+
+      modifyAsset("app|foo.txt", "no");
+      updateSources(["app|foo.txt"]);
+      check.resumeApply();
+
+      expectAsset("app|foo.txt", "no");
+      buildShouldSucceed();
+    });
+
+    test("doesn't pass an asset through when its overwriting transform becomes "
+        "non-primary during apply if another transform overwrites it", () {
+      var check = new CheckContentTransformer("yes", " modified");
+      initGraph({
+        "app|foo.txt": "yes"
+      }, {
+        "app": [[check, new RewriteTransformer("txt", "txt")]]
+      });
+
+      check.pauseApply();
+      updateSources(["app|foo.txt"]);
+      // Ensure we're waiting on [check.apply]
+      schedule(pumpEventQueue);
+
+      modifyAsset("app|foo.txt", "no");
+      updateSources(["app|foo.txt"]);
+      check.resumeApply();
+
+      expectAsset("app|foo.txt", "no.txt");
+      buildShouldSucceed();
+    });
+
+    test("doesn't pass an asset through when one overwriting transform becomes "
+        "non-primary if another transform still overwrites it", () {
+      initGraph({
+        "app|foo.txt": "yes"
+      }, {
+        "app": [[
+          new CheckContentTransformer("yes", " modified"),
+          new RewriteTransformer("txt", "txt")
+        ]]
+      });
+
+      updateSources(["app|foo.txt"]);
+      // This could be either the output of [CheckContentTransformer] or
+      // [RewriteTransformer], depending which completes first.
+      expectAsset("app|foo.txt", anything);
+      buildShouldFail([isAssetCollisionException("app|foo.txt")]);
+
+      modifyAsset("app|foo.txt", "no");
+      updateSources(["app|foo.txt"]);
+      expectAsset("app|foo.txt", "no.txt");
+      buildShouldSucceed();
+    });
   });
 
   group('cross-package transforms', () {
     test("can access other packages' source assets", () {
       initGraph({
         "pkg1|a.txt": "pkg2|a.inc",
         "pkg2|a.inc": "a"
       }, {"pkg1": [[new ManyToOneTransformer("txt")]]});
 
       updateSources(["pkg1|a.txt", "pkg2|a.inc"]);
@@ skipping 197 matching lines @@
       transformer1.resumeApply();
 
       expectAsset("app|foo.out", "foo.mid.out");
       buildShouldSucceed();
 
       expect(transformer1.numRuns, completion(equals(2)));
       expect(transformer2.numRuns, completion(equals(2)));
     });
   });
 }