Introduce polymer transformers (inlined code extraction, inlining html imports,

pkg/polymer/test/transform/common.dart

Index: pkg/polymer/test/transform/common.dart
diff --git a/pkg/polymer/test/transform/common.dart b/pkg/polymer/test/transform/common.dart
new file mode 100644
index 0000000000000000000000000000000000000000..c0fd47ef43e5328f898739ebc23c872b41be94a5
--- /dev/null
+++ b/pkg/polymer/test/transform/common.dart
@@ -0,0 +1,97 @@
+// 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 polymer.test.transfom.common;
+
+import 'dart:async';
+
+import 'package:barback/barback.dart';
+import 'package:stack_trace/stack_trace.dart';
+import 'package:unittest/unittest.dart';
+
+String idToString(AssetId id) => '${id.package}|${id.path}';
+AssetId idFromString(String s) {
+  int index = s.indexOf('|');
+  return new AssetId(s.substring(0, index), s.substring(index + 1));
+}
+
+/**
+ * A helper package provider that has files stored in memory, also wraps
+ * [Barback] to simply our tests.
+ */
+class TestHelper implements PackageProvider {
+  /**
+   * Maps from an asset string identifier of the form 'package|path' to the
+   * file contents. 
+   */
+  final Map<String, String> files;
+  final Iterable<String> packages;
+
+  Barback barback;
+  var errorSubscription;
+  var resultSubscription;
+
+  Future<Asset> getAsset(AssetId id) =>
+      new Future.value(new Asset.fromString(id, files[idToString(id)]));
+  TestHelper(List<List<Transformer>> transformers, Map<String, String> files)
+      : files = files,
+        packages = files.keys.map((s) => idFromString(s).package) {
+    barback = new Barback(this);
+    for (var p in packages) {
+      barback.updateTransformers(p, transformers);
+    }
+    errorSubscription = barback.errors.listen((e) {
+      var trace = getAttachedStackTrace(e);
+      if (trace != null) {
+        print(Trace.format(trace));
+      }
+      fail('error running barback: $e');
+    });
+    resultSubscription = barback.results.listen((result) {
+      expect(result.succeeded, isTrue, reason: "${result.errors}");
+    });
+  }
+
+  void tearDown() {
+    errorSubscription.cancel();
+    resultSubscription.cancel();
+  }
+
+  /**
+   * Tells barback which files have changed, and thus anything that depends on
+   * it on should be computed. By default mark all the input files.
+   */
+  void run([Iterable<String> paths]) {
+    if (paths == null) paths = files.keys;
+    barback.updateSources(paths.map(idFromString));
+  }
+
+  Future<String> operator [](String assetString){
+    return barback.getAssetById(idFromString(assetString))
+        .then((asset) => asset.readAsString());
+  }
+
+  Future check(String assetIdString, String content) {
+    return this[assetIdString].then((value) {
+      expect(value, content, reason: 'Final output of $assetIdString differs.');
+    });
+  }
+
+  Future checkAll(Map<String, String> files) {
+    var futures = [];
+    files.forEach((k, v) {
+      futures.add(check(k, v));
+    });
+    return Future.wait(futures);
+  }
+}
+
+testPhases(String testName, List<List<Transformer>> phases,
+    Map<String, String> inputFiles, Map<String, String> expectedFiles) {
+  test(testName, () {
+    var helper = new TestHelper(phases, inputFiles)..run();
+    return helper.checkAll(expectedFiles).then((_) => helper.tearDown());
+  });
+}
+