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._contents, equals(contents));
+      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);
 
   // Make sure the future gets the error.
@@ skipping 69 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);
-    asset._contents = contents;
+    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) {
       return Future.wait(to.split(" ").map((extension) {
         var id = transform.primaryId.changeExtension(".$extension");
         return input.readAsString().then((content) {
-          transform.addOutput(id, new MockAsset(id, "$content.$extension"));
+          transform.addOutput(new MockAsset(id, "$content.$extension"));
         });
       })).then((_) {
         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) {
       return input.readAsString().then((lines) {
         for (var line in lines.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) {
       return primary.readAsString().then((contents) {
         // Get all of the included inputs.
         var inputs = contents.split(",").map((path) {
           var id = new AssetId(transform.primaryId.package, path);
           return transform.getInput(id);
         });
 
         return Future.wait(inputs);
       }).then((inputs) {
         // Concatenate them to one output.
         var output = "";
         return Future.forEach(inputs, (input) {
           return input.readAsString().then((contents) {
             output += contents;
           });
         }).then((_) {
           var id = transform.primaryId.changeExtension(".out");
-          transform.addOutput(id, new MockAsset(id, output));
+          transform.addOutput(new MockAsset(id, output));
         });
       });
     });
   }
 
   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;
-  String _contents;
+  final AssetId id;
+  String contents;
 
-  MockAsset(this._id, this._contents);
+  MockAsset(this.id, this.contents);
 
-  Future<String> readAsString() => new Future.value(_contents);
+  Future<String> readAsString() => new Future.value(contents);
   Stream<List<int>> read() => throw new UnimplementedError();
 
   serialize() => throw new UnimplementedError();
 
-  String toString() => "MockAsset $_id $_contents";
+  String toString() => "MockAsset $id $contents";
 }