First pass at build dependency graph for barback.

pkg/barback/test/asset_graph/transform_test.dart

Index: pkg/barback/test/asset_graph/transform_test.dart
diff --git a/pkg/barback/test/asset_graph/transform_test.dart b/pkg/barback/test/asset_graph/transform_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..e460ebfd023bc27a7163f9d0fabbddb099fca4ef
--- /dev/null
+++ b/pkg/barback/test/asset_graph/transform_test.dart
@@ -0,0 +1,280 @@
+// 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.asset_graph.transform_test;
+
+import 'dart:async';
+
+import 'package:scheduled_test/scheduled_test.dart';
+
+import 'package:barback/barback.dart';
+import 'package:barback/src/asset_graph.dart';
+
+import '../utils.dart';
+
+main() {
+  initConfig();
+  test("gets a transformed asset with a different path", () {
+    var provider = new MockProvider({"app|foo.blub": "foo"});
+    var graph = new AssetGraph(provider, [
+      [new RewriteTransformer("blub", "blab")]
+    ]);
+    graph.updateSources([AssetId.parse("app|foo.blub")]);
+
+    expectAsset(graph, "app|foo.blab", "foo.blab");
+  });
+
+  test("gets a transformed asset with the same path", () {
+    var provider = new MockProvider({"app|foo.blub": "blub"});
+    var graph = new AssetGraph(provider, [
+      [new RewriteTransformer("blub", "blub")]
+    ]);
+    graph.updateSources([AssetId.parse("app|foo.blub")]);
+
+    expectAsset(graph, "app|foo.blub", "blub.blub");
+  });
+
+  test("doesn't find an output from a later phase", () {
+    var provider = new MockProvider({"app|foo.a": "a"});
+    var graph = new AssetGraph(provider, [
+      [new RewriteTransformer("b", "c")],
+      [new RewriteTransformer("a", "b")]
+    ]);
+    graph.updateSources([AssetId.parse("app|foo.a")]);
+
+    expectNoAsset(graph, "app|foo.c");
+  });
+
+  test("doesn't find an output from the same stage", () {

[nweiz, 2013/06/14 00:57:57]

You're using "phase" and "stage" interchangeably. It's confusing.

[Bob Nystrom, 2013/06/17 23:35:05]

Done.

+    var provider = new MockProvider({"app|foo.a": "a"});
+    var graph = new AssetGraph(provider, [
+      [
+        new RewriteTransformer("a", "b"),
+        new RewriteTransformer("b", "c")
+      ]
+    ]);
+    graph.updateSources([AssetId.parse("app|foo.a")]);
+
+    expectNoAsset(graph, "app|foo.c");

[nweiz, 2013/06/14 00:57:57]

Expect that "foo.b" exists.

[Bob Nystrom, 2013/06/17 23:35:05]

Done.

+  });
+
+  test("errors if two transformers output the same file", () {
+    var provider = new MockProvider({"app|foo.a": "foo"});
+    var graph = new AssetGraph(provider, [
+      [
+        new RewriteTransformer("a", "b"),
+        new RewriteTransformer("a", "b")
+      ]
+    ]);
+    graph.updateSources([AssetId.parse("app|foo.a")]);
+
+    expectCollision(graph, "app|foo.b");
+  });
+
+  test("finds the latest output before the transformer's stage", () {
+    var provider = new MockProvider({"app|foo.blub": "foo"});
+    var graph = new AssetGraph(provider, [
+      [new RewriteTransformer("blub", "blub")],
+      [
+        new RewriteTransformer("blub", "blub"),
+        new RewriteTransformer("blub", "done")
+      ],
+      [new RewriteTransformer("blub", "blub")]
+    ]);
+    graph.updateSources([AssetId.parse("app|foo.blub")]);
+
+    expectAsset(graph, "app|foo.done", "foo.blub.done");
+  });
+
+  test("applies multiple transformations to an asset", () {
+    var provider = new MockProvider({"app|foo.a": "a"});
+    var graph = new AssetGraph(provider, [
+      [new RewriteTransformer("a", "b")],
+      [new RewriteTransformer("b", "c")],
+      [new RewriteTransformer("c", "d")],
+      [new RewriteTransformer("d", "e")],
+      [new RewriteTransformer("e", "f")],
+      [new RewriteTransformer("f", "g")],
+      [new RewriteTransformer("g", "h")],
+      [new RewriteTransformer("h", "i")],
+      [new RewriteTransformer("i", "j")],
+      [new RewriteTransformer("j", "k")],
+    ]);
+    graph.updateSources([AssetId.parse("app|foo.a")]);
+
+    expectAsset(graph, "app|foo.k", "a.b.c.d.e.f.g.h.i.j.k");
+  });
+
+  test("only runs a transform once for all of its outputs", () {
+    var provider = new MockProvider(["app|foo.blub"]);
+    var transformer = new RewriteTransformer("blub", "a b c");
+    var graph = new AssetGraph(provider, [[transformer]]);
+    graph.updateSources([AssetId.parse("app|foo.blub")]);
+
+    expectAsset(graph, "app|foo.a", ".a");
+    expectAsset(graph, "app|foo.b", ".b");
+    expectAsset(graph, "app|foo.c", ".c");
+    schedule(() {
+      expect(transformer.numRuns, equals(1));
+    });
+  });
+
+  test("does not reapply transform when inputs are not modified", () {
+    var provider = new MockProvider({"app|foo.blub": "foo"});
+    var transformer = new RewriteTransformer("blub", "blab");
+    var graph = new AssetGraph(provider, [[transformer]]);
+    graph.updateSources([AssetId.parse("app|foo.blub")]);
+    expectAsset(graph, "app|foo.blab", "foo.blab");
+    expectAsset(graph, "app|foo.blab", "foo.blab");
+    expectAsset(graph, "app|foo.blab", "foo.blab");
+
+    schedule(() {
+      expect(transformer.numRuns, equals(1));
+    });
+  });
+
+  test("reapplies a transform when its input is modified", () {
+    var provider = new MockProvider({"app|foo.blub": "foo"});
+    var transformer = new RewriteTransformer("blub", "blab");
+    var graph = new AssetGraph(provider, [[transformer]]);
+
+    schedule(() {
+      graph.updateSources([AssetId.parse("app|foo.blub")]);
+    });
+
+    expectAsset(graph, "app|foo.blab", "foo.blab");
+
+    schedule(() {
+      graph.updateSources([AssetId.parse("app|foo.blub")]);
+    });
+
+    expectAsset(graph, "app|foo.blab", "foo.blab");
+
+    schedule(() {
+      graph.updateSources([AssetId.parse("app|foo.blub")]);
+    });
+
+    expectAsset(graph, "app|foo.blab", "foo.blab");
+
+    schedule(() {
+      expect(transformer.numRuns, equals(3));
+    });
+  });
+
+  test("allows a transform to generate multiple outputs", () {
+    var provider = new MockProvider({"app|foo.txt": "a.out,b.out"});
+    var graph = new AssetGraph(provider, [
+      [new OneToManyTransformer("txt")]

[nweiz, 2013/06/14 00:57:57]

Can't RewriteTransformer already produce multiple outputs?

[Bob Nystrom, 2013/06/17 23:35:05]

Not for a single input. It's a 1-1 transform*er*, it's just that it will have
multiple transforms for multiple different primary inputs.

[nweiz, 2013/06/18 23:14:45]

In that case, what's going on in "only runs a transform once for all of its
outputs"?

[Bob Nystrom, 2013/06/20 00:23:59]

Oh, right. I forgot I added support for outputting to multiple extensions with
that. They do slightly different things. RewriteTransformer can have multiple
outputs, but that's a property of the *transformer* itself. If you create a
RewriteTransformer with two extensions, it will always output two files for each
input.

OneToManyTransformer() uses the *contents* of the primary input to determine the
outputs. That means you can change what it outputs in the middle of a test by
updating the primary input file.

For this specific test, I could have used either of those mock transformers.

+    ]);
+
+    graph.updateSources([AssetId.parse("app|foo.txt")]);
+
+    expectAsset(graph, "app|a.out", "spread txt");
+    expectAsset(graph, "app|b.out", "spread txt");
+  });
+
+  test("does not rebuild transforms that don't use modified source", () {
+    var provider = new MockProvider(["app|foo.a", "app|foo.b"]);
+    var a = new RewriteTransformer("a", "aa");
+    var aa = new RewriteTransformer("aa", "aaa");
+    var b = new RewriteTransformer("b", "bb");
+    var bb = new RewriteTransformer("bb", "bbb");
+
+    var graph = new AssetGraph(provider, [
+      [a, b],
+      [aa, bb],
+    ]);
+
+    graph.updateSources([AssetId.parse("app|foo.a")]);
+    graph.updateSources([AssetId.parse("app|foo.b")]);
+
+    expectAsset(graph, "app|foo.aaa", ".aa.aaa");
+    expectAsset(graph, "app|foo.bbb", ".bb.bbb");
+
+    schedule(() {
+      graph.updateSources([AssetId.parse("app|foo.a")]);
+    });
+
+    expectAsset(graph, "app|foo.aaa", ".aa.aaa");
+    expectAsset(graph, "app|foo.bbb", ".bb.bbb");
+
+    schedule(() {
+      expect(aa.numRuns, equals(2));
+      expect(bb.numRuns, equals(1));
+    });
+  });
+
+  test("doesn't get an output from a transform whose primary was removed", () {

[nweiz, 2013/06/14 00:57:57]

"primary" -> "primary input"

I don't understand this test. There's only one primary input here -- foo.txt --
and it's not removed.

[Bob Nystrom, 2013/06/17 23:35:05]

Some sort of copy/paste screw up on my part. I think I copied a test, updated
its description, but then didn't actually implement the test. Fixed.

+    var provider = new MockProvider({"app|foo.txt": "a.out,b.out"});
+    var graph = new AssetGraph(provider, [
+      [new OneToManyTransformer("txt")]
+    ]);
+
+    graph.updateSources([AssetId.parse("app|foo.txt")]);
+
+    expectAsset(graph, "app|a.out", "spread txt");
+    expectAsset(graph, "app|b.out", "spread txt");
+
+    schedule(() {
+      provider.modifyAsset("app|foo.txt", "a.out");
+      graph.updateSources([AssetId.parse("app|foo.txt")]);
+    });
+
+    expectAsset(graph, "app|a.out", "spread txt");
+    expectNoAsset(graph, "app|b.out");
+  });
+
+  test("reapplies a transform when a non-primary input changes", () {
+    var provider = new MockProvider({
+      "app|a.txt": "a.inc",
+      "app|a.inc": "a"
+    });
+
+    var graph = new AssetGraph(provider, [
+      [new ManyToOneTransformer("txt")]
+    ]);
+
+    graph.updateSources([
+      AssetId.parse("app|a.txt"),
+      AssetId.parse("app|a.inc")
+    ]);
+
+    expectAsset(graph, "app|a.out", "a");
+
+    schedule(() {
+      provider.modifyAsset("app|a.inc", "after");
+      graph.updateSources([AssetId.parse("app|a.inc")]);
+    });
+
+    expectAsset(graph, "app|a.out", "after");
+  });
+
+
+  test("fails if a non-primary input is removed", () {
+    var provider = new MockProvider({
+      "app|a.txt": "a.inc,b.inc,c.inc",
+      "app|a.inc": "a",
+      "app|b.inc": "b",
+      "app|c.inc": "c"
+    });
+
+    var graph = new AssetGraph(provider, [
+      [new ManyToOneTransformer("txt")]
+    ]);
+
+    graph.updateSources([
+      AssetId.parse("app|a.txt"),
+      AssetId.parse("app|a.inc"),
+      AssetId.parse("app|b.inc"),
+      AssetId.parse("app|c.inc")
+    ]);
+
+    expectAsset(graph, "app|a.out", "abc");
+
+    schedule(() {
+      graph.removeSources([AssetId.parse("app|b.inc")]);
+    });
+
+    expectMissingInput(graph, "app|a.out", "app|b.inc");
+  });
+}