Barback transforms now pass through the primary input by default.

pkg/barback/test/package_graph/group_test.dart

Index: pkg/barback/test/package_graph/group_test.dart
diff --git a/pkg/barback/test/package_graph/group_test.dart b/pkg/barback/test/package_graph/group_test.dart
index bc77c37aa460c3d2e81c295957c755f5a9d355a6..168644747b2c3b88aca24e230697cda8cbfa2bf8 100644
--- a/pkg/barback/test/package_graph/group_test.dart
+++ b/pkg/barback/test/package_graph/group_test.dart
@@ -21,7 +21,7 @@ main() {
       ])]
     ]});
     updateSources(["app|foo.a"]);
-    expectNoAsset("app|foo.b");
+    expectAsset("app|foo.b", "foo.b");

[Bob Nystrom, 2014/02/26 01:09:15]

Why keep this one but delete the others?

[nweiz, 2014/02/26 19:37:14]

I want to assert that a pass-through asset makes it out of the group.

[Bob Nystrom, 2014/02/26 20:28:50]

That's not what this test description is about. If that's what you want to test
document that or make a separate test.

[nweiz, 2014/02/27 21:04:20]

Done.

     expectAsset("app|foo.c", "foo.b.c");
     buildShouldSucceed();
   });
@@ -35,7 +35,6 @@ main() {
       [new RewriteTransformer("c", "d")]
     ]});
     updateSources(["app|foo.a"]);
-    expectNoAsset("app|foo.c");
     expectAsset("app|foo.d", "foo.b.c.d");
     buildShouldSucceed();
   });
@@ -49,7 +48,6 @@ main() {
       ])]
     ]});
     updateSources(["app|foo.a"]);
-    expectNoAsset("app|foo.b");
     expectAsset("app|foo.d", "foo.b.c.d");
     buildShouldSucceed();
   });
@@ -100,7 +98,6 @@ main() {
     ]});
 
     updateSources(["app|foo.a"]);
-    expectNoAsset("app|foo.b");
     expectAsset("app|foo.c", "foo.b.c");
     buildShouldSucceed();
 
@@ -121,7 +118,6 @@ main() {
     ]});
 
     updateSources(["app|foo.a", "app|bar.x"]);
-    expectNoAsset("app|foo.b");
     expectAsset("app|foo.c", "foo.b.c");
     expectAsset("app|bar.c", "bar.b.c");
     buildShouldSucceed();
@@ -196,21 +192,23 @@ main() {
       buildShouldSucceed();
     });
 
-    test("parallel groups' intermediate assets can't collide", () {
-      initGraph(["app|foo.a", "app|foo.x"], {"app": [
-        [new TransformerGroup([
-          [new RewriteTransformer("a", "b")],
-          [new RewriteTransformer("b", "c")]
-        ]), new TransformerGroup([
-          [new RewriteTransformer("x", "b")],
-          [new RewriteTransformer("b", "z")]
-        ])]
-      ]});
-      updateSources(["app|foo.a", "app|foo.x"]);
-      expectAsset("app|foo.c", "foo.b.c");
-      expectAsset("app|foo.z", "foo.b.z");
-      buildShouldSucceed();
-    });
+    // TODO(nweiz): re-enable this test when a transformer can consume its
+    // primary input (issue 16612).
+    // test("parallel groups' intermediate assets can't collide", () {
+    //   initGraph(["app|foo.a", "app|foo.x"], {"app": [
+    //     [new TransformerGroup([
+    //       [new RewriteTransformer("a", "b")],
+    //       [new RewriteTransformer("b", "c")]
+    //     ]), new TransformerGroup([
+    //       [new RewriteTransformer("x", "b")],
+    //       [new RewriteTransformer("b", "z")]
+    //     ])]
+    //   ]});
+    //   updateSources(["app|foo.a", "app|foo.x"]);
+    //   expectAsset("app|foo.c", "foo.b.c");
+    //   expectAsset("app|foo.z", "foo.b.z");
+    //   buildShouldSucceed();
+    // });
   });
 
   group("pass-through", () {
@@ -259,35 +257,32 @@ main() {
       buildShouldSucceed();
     });
 
-    test("doesn't pass through an input that's used by a group but not by "
-        "transformers", () {
+    test("doesn't pass through an input that's overwritten by a group but not "
+        "by transformers", () {

[Bob Nystrom, 2014/02/26 01:09:15]

It does pass it through now.

[nweiz, 2014/02/26 19:37:14]

No, the output is "foo.a", which is the overwritten value. The original value is
just "foo".

[Bob Nystrom, 2014/02/26 20:28:50]

I guess I just don't understand the utility of this test. How could the input
possibly be passed through if it's being overwritten?

[nweiz, 2014/02/27 21:04:20]

It shouldn't be able to; if it did, it might cause a collision or the resulting
"foo.a" asset might just silently be the source asset rather than the
overwritten asset. This test validates that neither of those happen.

[Bob Nystrom, 2014/02/27 21:33:40]

SGTM, though a comment to this affect would be nice too.

[nweiz, 2014/02/27 21:47:56]

I'll add one to the simplest/most general test case for this stuff.

       initGraph(["app|foo.a"], {"app": [[
         new TransformerGroup([
-          [new RewriteTransformer("a", "b")],
-          [new RewriteTransformer("b", "c")]
+          [new RewriteTransformer("a", "a")],
         ]),
         new RewriteTransformer("x", "y")
       ]]});
       updateSources(["app|foo.a"]);
-      expectNoAsset("app|foo.a");
       expectNoAsset("app|foo.y");
-      expectAsset("app|foo.c", "foo.b.c");
+      expectAsset("app|foo.a", "foo.a");
       buildShouldSucceed();
     });
 
-    test("doesn't pass through an input that's used by transformers but not by "
-        "a group", () {
+    test("doesn't pass through an input that's overwritten by transformers but "

[Bob Nystrom, 2014/02/26 01:09:15]

Does.

[nweiz, 2014/02/26 19:37:14]

See above.

+        "not by a group", () {
       initGraph(["app|foo.x"], {"app": [[
         new TransformerGroup([
           [new RewriteTransformer("a", "b")],
           [new RewriteTransformer("b", "c")]
         ]),
-        new RewriteTransformer("x", "y")
+        new RewriteTransformer("x", "x")
       ]]});
       updateSources(["app|foo.x"]);
-      expectNoAsset("app|foo.x");
       expectNoAsset("app|foo.c");
-      expectAsset("app|foo.y", "foo.y");
+      expectAsset("app|foo.x", "foo.x");
       buildShouldSucceed();
     });
 
@@ -315,31 +310,6 @@ main() {
       expectAsset("app|foo.a", "foo.a");
       buildShouldSucceed();
     });
-
-    test("doesn't pass-through an asset that ceases to be forwarded due to a "
-        "resolved collision", () {
-      initGraph({
-        "app|foo.a": "foo.a",
-        "app|foo.x": "foo.x"
-      }, {"app": [
-        [new TransformerGroup([[
-          new CheckContentAndRenameTransformer(
-              "a", "new foo.a", "z", "modified foo.a"),
-          new RewriteTransformer('x', 'a')
-        ]])]
-      ]});
-
-      updateSources(["app|foo.a", "app|foo.x"]);
-      expectAsset("app|foo.a", "foo.a");
-      expectNoAsset("app|foo.z");
-      buildShouldFail([isAssetCollisionException("app|foo.a")]);
-
-      modifyAsset('app|foo.a', 'new foo.a');
-      updateSources(["app|foo.a"]);
-      expectAsset("app|foo.a", "foo.x.a");
-      expectAsset("app|foo.z", "modified foo.a");
-      buildShouldSucceed();
-    });
   });
 
   test("runs transforms in an added group", () {
@@ -383,7 +353,8 @@ main() {
     expect(rewrite2.numRuns, completion(equals(1)));
   });
 
-  test("doesn't pass through an input that's used by an added group", () {
+  test("doesn't pass through an input that's overwritten by an added group",
+      () {
     var rewrite = new RewriteTransformer("x", "z");
     initGraph(["app|foo.a"], {"app": [[rewrite]]});
 
@@ -392,13 +363,9 @@ main() {
     buildShouldSucceed();
 
     updateTransformers("app", [
-      [rewrite, new TransformerGroup([
-        [new RewriteTransformer("a", "b")],
-        [new RewriteTransformer("b", "c")]
-      ])]
+      [rewrite, new TransformerGroup([[new RewriteTransformer("a", "a")]])]
     ]);
-    expectNoAsset("app|foo.a");
-    expectAsset("app|foo.c", "foo.b.c");
+    expectAsset("app|foo.a", "foo.a");
     buildShouldSucceed();
   });