Make Assets know their ID.

pkg/barback/test/utils.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.utils;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:barback/barback.dart';
@@ skipping 113 matching lines @@
 }
 
 /// Pauses the schedule until the currently running build completes.
 ///
 /// Validates that the build completed successfully.
 void waitForBuild() {
   schedule(() {
     return _graph.results.first.then((result) {
       expect(result.succeeded, isTrue);
     });
-  });
+  }, "wait for build");
 }
 
 /// Schedules an expectation that the graph will deliver an asset matching
 /// [name] and [contents].
 ///
 /// If [contents] is omitted, defaults to the asset's filename without an
 /// extension (which is the same default that [initGraph] uses).
 void expectAsset(String name, [String contents]) {
   var id = new AssetId.parse(name);
 
   if (contents == null) {
     contents = pathos.basenameWithoutExtension(id.path);
   }
 
   schedule(() {
     return _graph.getAssetById(id).then((asset) {
       // TODO(rnystrom): Make an actual Matcher class for this.
       expect(asset, new isInstanceOf<MockAsset>());
-      expect(asset._id.package, equals(id.package));
-      expect(asset._id.path, equals(id.path));
+      expect(asset.id, equals(id));
       expect(asset._contents, equals(contents));
     });
   }, "get asset $name");
 }
 
 /// Schedules an expectation that the graph will not find an asset matching
 /// [name].
 void expectNoAsset(String name) {
   var id = new AssetId.parse(name);
 
@@ skipping 70 matching lines @@
         var id = new AssetId.parse(asset);
         var package = _packages.putIfAbsent(id.package, () => []);
         var contents = pathos.basenameWithoutExtension(id.path);
         package.add(new MockAsset(id, contents));
       }
     }
   }
 
   void _modifyAsset(String name, String contents) {
     var id = new AssetId.parse(name);
-    var asset = _packages[id.package].firstWhere((a) => a._id == id);
+    var asset = _packages[id.package].firstWhere((a) => a.id == id);
     asset._contents = contents;
   }
 
   List<AssetId> listAssets(String package, {String within}) {
     if (within != null) {
       throw new UnimplementedError("Doesn't handle 'within' yet.");
     }
 
     return _packages[package].map((asset) => asset.id);
   }
 
   Future<Asset> getAsset(AssetId id) {
     var future;
     if (_pauseCompleter != null) {
       future = _pauseCompleter.future;
     } else {
       future = new Future.value();
     }
 
     return future.then((_) {
       var package = _packages[id.package];
       if (package == null) throw new AssetNotFoundException(id);
 
-      return package.firstWhere((asset) => asset._id == id,
+      return package.firstWhere((asset) => asset.id == id,
           orElse: () => throw new AssetNotFoundException(id));
     });
   }
 }
 
 /// A [Transformer] that takes assets ending with one extension and generates
 /// assets with a given extension.
 ///
 /// Appends the output extension to the contents of the input file.
 class RewriteTransformer extends Transformer {
@@ skipping 31 matching lines @@
   /// Lets you test the asynchronous behavior of transformers.
   void wait() {
     _wait = new Completer();
   }
 
   void complete() {
     _wait.complete();
     _wait = null;
   }
 
-  Future<bool> isPrimary(AssetId asset) {
-    return new Future.value(asset.extension == ".$from");
+  Future<bool> isPrimary(Asset asset) {
+    return new Future.value(asset.id.extension == ".$from");
   }
 
   Future apply(Transform transform) {
     numRuns++;
     if (!_started.isCompleted) _started.complete();
     _runningTransforms++;
     return transform.primaryInput.then((input) {
       for (var extension in to.split(" ")) {
         var id = transform.primaryId.changeExtension(".$extension");
         var content = input.readAsString() + ".$extension";
-        transform.addOutput(id, new MockAsset(id, content));
-
+        transform.addOutput(new MockAsset(id, content));
       }
 
       if (_wait != null) return _wait.future;
     }).whenComplete(() {
       _runningTransforms--;
     });
   }
 
   String toString() => "$from->$to";
 }
 
 /// A [Transformer] that takes an input asset that contains a comma-separated
 /// list of paths and outputs a file for each path.
 class OneToManyTransformer extends Transformer {
   final String extension;
 
   /// The number of times the transformer has been applied.
   int numRuns = 0;
 
   /// Creates a transformer that consumes assets with [extension].
   ///
   /// That file contains a comma-separated list of paths and it will output
   /// files at each of those paths.
   OneToManyTransformer(this.extension);
 
-  Future<bool> isPrimary(AssetId asset) {
-    return new Future.value(asset.extension == ".$extension");
+  Future<bool> isPrimary(Asset asset) {
+    return new Future.value(asset.id.extension == ".$extension");
   }
 
   Future apply(Transform transform) {
     numRuns++;
     return transform.primaryInput.then((input) {
       for (var line in input.readAsString().split(",")) {
         var id = new AssetId(transform.primaryId.package, line);
-        transform.addOutput(id, new MockAsset(id, "spread $extension"));
+        transform.addOutput(new MockAsset(id, "spread $extension"));
       }
     });
   }
 
   String toString() => "1->many $extension";
 }
 
 /// A transformer that uses the contents of a file to define the other inputs.
 ///
 /// Outputs a file with the same name as the primary but with an "out"
 /// extension containing the concatenated contents of all non-primary inputs.
 class ManyToOneTransformer extends Transformer {
   final String extension;
 
   /// The number of times the transformer has been applied.
   int numRuns = 0;
 
   /// Creates a transformer that consumes assets with [extension].
   ///
   /// That file contains a comma-separated list of paths and it will input
   /// files at each of those paths.
   ManyToOneTransformer(this.extension);
 
-  Future<bool> isPrimary(AssetId asset) {
-    return new Future.value(asset.extension == ".$extension");
+  Future<bool> isPrimary(Asset asset) {
+    return new Future.value(asset.id.extension == ".$extension");
   }
 
   Future apply(Transform transform) {
     numRuns++;
     return transform.primaryInput.then((primary) {
       // Get all of the included inputs.
       var inputs = primary.readAsString().split(",").map((path) {
         var id = new AssetId(transform.primaryId.package, path);
         return transform.getInput(id);
       });
 
       // Concatenate them to one output.
       return Future.wait(inputs).then((inputs) {
         var id = transform.primaryId.changeExtension(".out");
         var contents = inputs.map((input) => input.readAsString()).join();
-        transform.addOutput(id, new MockAsset(id, contents));
+        transform.addOutput(new MockAsset(id, contents));
       });
     });
   }
 
   String toString() => "many->1 $extension";
 }
 
 /// A transformer that throws an exception when run, after generating the
 /// given outputs.
 class BadTransformer extends Transformer {
   /// The error it throws.
   static const ERROR = "I am a bad transformer!";
 
   /// The list of asset names that it should output.
   final List<String> outputs;
 
   BadTransformer(this.outputs);
 
-  Future<bool> isPrimary(AssetId asset) => new Future.value(true);
+  Future<bool> isPrimary(Asset asset) => new Future.value(true);
   Future apply(Transform transform) {
     return new Future(() {
       // Create the outputs first.
       for (var output in outputs) {
         var id = new AssetId.parse(output);
-        transform.addOutput(id, new MockAsset(id, output));
+        transform.addOutput(new MockAsset(id, output));
       }
 
       // Then fail.
       throw ERROR;
     });
   }
 }
 
 /// An implementation of [Asset] that never hits the file system.
 class MockAsset implements Asset {
-  final AssetId _id;
+  final AssetId id;
   String _contents;
 
-  MockAsset(this._id, this._contents);
+  MockAsset(this.id, this._contents);
 
   String readAsString() => _contents;
   Stream<List<int>> read() => throw new UnimplementedError();
 
   serialize() => throw new UnimplementedError();
 
-  String toString() => "MockAsset $_id $_contents";
+  String toString() => "MockAsset $id $_contents";
 }