Add the ability for a PackageProvider to declare static packages.

pkg/barback/lib/src/graph/package_graph.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.graph.package_graph;
 
 import 'dart:async';
 import 'dart:collection';
 
 import '../asset/asset_id.dart';
 import '../asset/asset_node.dart';
 import '../asset/asset_set.dart';
 import '../build_result.dart';
 import '../errors.dart';
 import '../log.dart';
 import '../package_provider.dart';
 import '../utils.dart';
 import 'asset_cascade.dart';
 import 'node_status.dart';
+import 'static_asset_cascade.dart';
 
 /// The collection of [AssetCascade]s for an entire application.
 ///
 /// This tracks each package's [AssetCascade] and routes asset requests between
 /// them.
 class PackageGraph {
   /// The provider that exposes asset and package information.
   final PackageProvider provider;
 
   /// The [AssetCascade] for each package.
@@ skipping 58 matching lines @@
     _inErrorZone(() {
       for (var package in provider.packages) {
         var cascade = new AssetCascade(this, package);
         _cascades[package] = cascade;
         cascade.onLog.listen(_onLog);
         cascade.onStatusChange.listen((status) {
           if (status == NodeStatus.IDLE) _tryScheduleResult();
         });
       }
 
+      if (provider is StaticPackageProvider) {
+        StaticPackageProvider staticProvider = provider;
+        for (var package in staticProvider.staticPackages) {
+          if (_cascades.containsKey(package)) {
+            throw new StateError('Package "$package" is in both '
+                'PackageProvider.packages and PackageProvider.staticPackages.');
+          }
+
+          var cascade = new StaticAssetCascade(this, package);
+          _cascades[package] = cascade;
+        }
+      }
+
       _errors = mergeStreams(_cascades.values.map((cascade) => cascade.errors),
           broadcast: true);
       _errors.listen(_accumulatedErrors.add);
+
+      // Make sure a result gets scheduled even if there are no cascades or all
+      // of them are static.
+      if (provider.packages.isEmpty) _tryScheduleResult();
     });
   }
 
   /// Gets the asset node identified by [id].
   ///
   /// If [id] is for a generated or transformed asset, this will wait until it
   /// has been created and return it. This means that the returned asset will
   /// always be [AssetState.AVAILABLE].
   ///
   /// If the asset cannot be found, returns null.
@@ skipping 29 matching lines @@
       _lastUnexpectedError = null;
       return new Future.error(error, _lastUnexpectedErrorTrace);
     }
 
     // If the last build completed with an error, complete the future with it.
     if (!_lastResult.succeeded) {
       return new Future.error(BarbackException.aggregate(_lastResult.errors));
     }
 
     // Otherwise, return all of the final output assets.
-    var assets = unionAll(_cascades.values.map(
-        (cascade) => cascade.availableOutputs.toSet()));
-
-    return new Future.value(new AssetSet.from(assets));
+    return Future.wait(_cascades.values.map(
+            (cascade) => cascade.availableOutputs))
+          .then((assetSets) {
+      var assets = unionAll(assetSets.map((assetSet) => assetSet.toSet()));
+      return new Future.value(new AssetSet.from(assets));
+    });
   }
 
   /// Adds [sources] to the graph's known set of source assets.
   ///
   /// Begins applying any transforms that can consume any of the sources. If a
   /// given source is already known, it is considered modified and all
   /// transforms that use it will be re-applied.
   void updateSources(Iterable<AssetId> sources) {
     groupBy(sources, (id) => id.package).forEach((package, ids) {
       var cascade = _cascades[package];
@@ skipping 89 matching lines @@
         completer.completeError(error, stackTrace);
       });
     }, onError: (error, stackTrace) {
       _lastUnexpectedError = error;
       _lastUnexpectedErrorTrace = stackTrace;
       _resultsController.addError(error, stackTrace);
     });
     return completer.future;
   }
 }