Add the ability for a PackageProvider to declare static packages.

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:convert' show Encoding;
 
 import 'package:barback/barback.dart';
@@ skipping 66 matching lines @@
 ///
 /// [assets] may either be an [Iterable] or a [Map]. If it's an [Iterable],
 /// each element may either be an [AssetId] or a string that can be parsed to
 /// one. If it's a [Map], each key should be a string that can be parsed to an
 /// [AssetId] and the value should be a string defining the contents of that
 /// asset.
 ///
 /// [transformers] is a map from package names to the transformers for each
 /// package.
 void initGraph([assets,
-    Map<String, Iterable<Iterable<Transformer>>> transformers]) {
+      Map<String, Iterable<Iterable<Transformer>>> transformers]) =>
+    initStaticGraph(assets, transformers: transformers);
+
+void initStaticGraph(assets, {Iterable<String> staticPackages,
+    Map<String, Iterable<Iterable<Transformer>>> transformers}) {
   if (assets == null) assets = [];
+  if (staticPackages == null) staticPackages = [];
   if (transformers == null) transformers = {};
 
-  _provider = new MockProvider(assets, additionalPackages: transformers.keys);
+  _provider = new MockProvider(assets,
+      staticPackages: staticPackages,
+      additionalPackages: transformers.keys);
   _barback = new Barback(_provider);
   // Add a dummy listener to the log so it doesn't print to stdout.
   _barback.log.listen((_) {});
   _nextBuildResult = 0;
   _nextLog = 0;
 
   schedule(() => transformers.forEach(_barback.updateTransformers));
 
   // There should be one successful build after adding all the transformers but
   // before adding any sources.
@@ skipping 360 matching lines @@
             "completed with result: $result"),
         trace);
   }).catchError((error) {
     currentSchedule.signalError(error);
   });
 
   return delay.then((_) => cancelable.cancel());
 }
 
 /// An [AssetProvider] that provides the given set of assets.
-class MockProvider implements PackageProvider {
-  Iterable<String> get packages => _assets.keys;
+class MockProvider implements StaticPackageProvider {
+  Iterable<String> get packages =>
+      _assets.keys.toSet().difference(staticPackages);
+
+  final Set<String> staticPackages;
 
   final Map<String, AssetSet> _assets;
 
   /// The set of assets for which [MockLoadException]s should be emitted if
   /// they're loaded.
   final _errors = new Set<AssetId>();
 
   /// The set of assets for which synchronous [MockLoadException]s should be
   /// emitted if they're loaded.
   final _syncErrors = new Set<AssetId>();
 
   /// The completer that [getAsset()] is waiting on to complete when paused.
   ///
   /// If `null` it will return the asset immediately.
   Completer _pauseCompleter;
 
   /// Tells the provider to wait during [getAsset] until [complete()]
   /// is called.
   ///
   /// Lets you test the asynchronous behavior of loading.
   void _pause() {
     _pauseCompleter = new Completer();
   }
 
   void _resume() {
     _pauseCompleter.complete();
     _pauseCompleter = null;
   }
 
-  MockProvider(assets, {Iterable<String> additionalPackages})
-      : _assets = _normalizeAssets(assets, additionalPackages);
+  MockProvider(assets, {Iterable<String> staticPackages,
+          Iterable<String> additionalPackages})
+      : staticPackages = staticPackages == null ? new Set() :
+            staticPackages.toSet(),
+        _assets = _normalizeAssets(assets, additionalPackages);
 
   static Map<String, AssetSet> _normalizeAssets(assets,
       Iterable<String> additionalPackages) {
     var assetList;
     if (assets is Map) {
       assetList = assets.keys.map((asset) {
         var id = new AssetId.parse(asset);
         return new _MockAsset(id, assets[asset]);
       });
     } else if (assets is Iterable) {
@@ skipping 25 matching lines @@
     var id = new AssetId.parse(name);
     _errors.remove(id);
     _syncErrors.remove(id);
     (_assets[id.package][id] as _MockAsset).contents = contents;
   }
 
   void _setAssetError(String name, bool async) {
     (async ? _errors : _syncErrors).add(new AssetId.parse(name));
   }
 
-  List<AssetId> listAssets(String package, {String within}) {
-    if (within != null) {
-      throw new UnimplementedError("Doesn't handle 'within' yet.");
-    }
-
-    return _assets[package].map((asset) => asset.id);
-  }
+  List<AssetId> getAllAssets(String package) =>
+      _assets[package].map((asset) => asset.id);
 
   Future<Asset> getAsset(AssetId id) {
     // Eagerly load the asset so we can test an asset's value changing between
     // when a load starts and when it finishes.
     var assets = _assets[id.package];
     var asset;
     if (assets != null) asset = assets[id];
 
     if (_syncErrors.contains(id)) throw new MockLoadException(id);
     var hasError = _errors.contains(id);
@@ skipping 29 matching lines @@
 
   _MockAsset(this.id, this.contents);
 
   Future<String> readAsString({Encoding encoding}) =>
       new Future.value(contents);
 
   Stream<List<int>> read() => throw new UnimplementedError();
 
   String toString() => "MockAsset $id $contents";
 }