Start sketching out a buildAll() method.

pkg/barback/lib/src/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.package_graph;
 
 import 'dart:async';
 
 import 'asset_cascade.dart';
 import 'asset_id.dart';
 import 'asset_node.dart';
+import 'asset_set.dart';
 import 'build_result.dart';
 import 'errors.dart';
 import 'package_provider.dart';
 import 'utils.dart';
 
 /// The collection of [AssetCascade]s for an entire application.
 ///
 /// This tracks each package's [AssetCascade] and routes asset requests between
 /// them.
 class PackageGraph {
@@ skipping 23 matching lines @@
   /// A stream that emits any errors from the graph or the transformers.
   ///
   /// This emits errors as they're detected. If an error occurs in one part of
   /// the graph, unrelated parts will continue building.
   ///
   /// This will not emit programming errors from barback itself. Those will be
   /// emitted through the [results] stream's error channel.
   Stream<BarbackException> get errors => _errors;
   Stream<BarbackException> _errors;
 
+  /// The error associated with the previous build, or `null` if the last build
+  /// was successful.
+  BarbackException _lastError;

[nweiz, 2013/08/20 19:59:26]

I don't understand this. Why does the user only care about the errors from the
last cascade to complete? If they're getting all the assets, wouldn't they care
about all the errors from all the cascades? If so, why not just collect the
errors from _cascadeResults?

[Bob Nystrom, 2013/08/20 21:29:20]

They don't. This was aggregating all cascades.
You're exactly right. Done.

+
   /// Creates a new [PackageGraph] that will transform assets in all packages
   /// made available by [provider].
   PackageGraph(this.provider) {
     for (var package in provider.packages) {
       var cascade = new AssetCascade(this, package,
           provider.getTransformers(package));
       // The initial result for each cascade is "success" since the cascade
       // doesn't start building until some source in that graph is updated.
       _cascadeResults[package] = new BuildResult.success();
       _cascades[package] = cascade;
 
       cascade.results.listen((result) {
         _cascadeResults[cascade.package] = result;
         // If any cascade hasn't yet finished, the overall build isn't finished
         // either.
         if (_cascadeResults.values.any((result) => result == null)) return;
 
         // Include all build errors for all cascades. If no cascades have
         // errors, the result will automatically be considered a success.
-        _resultsController.add(new BuildResult(unionAll(
-            _cascadeResults.values.map((result) => result.errors))));
-      }, onError: _resultsController.addError);
+        var errors = unionAll(
+            _cascadeResults.values.map((result) => result.errors));
+
+        // Remember any errors for when [getAllAssets()] is called.
+        if (errors.length > 1) {
+          _lastError = new AggregateException(errors);
+        } else  if (errors.length == 1) {
+          _lastError = errors.first;
+        } else {
+          // The build completed successfully.
+          _lastError = null;
+        }
+
+        _resultsController.add(new BuildResult(errors));
+      }, onError: (error) {
+        _lastError = error;

[nweiz, 2013/08/20 19:59:26]

This is definitely not right. The error that's caught here almost certainly
won't be a BarbackException.

[Bob Nystrom, 2013/08/20 21:29:20]

Removed.

I'm not sure what the best thing to do is here. In the case where you're calling
buildAllAssets(), you probably *aren't* listening to the streams. That means a
programmatic error will get dropped on the floor.

I think I'd prefer to pipe that through the resulting future if that occurs
after you've called buildAllAssets(), even though it isn't a BarbackException.
What do you think?

[nweiz, 2013/08/20 22:29:03]

I think it's reasonable for [getAllAssets] to throw a non-BarbackException; the
documentation can explain the semantic difference between the two.

I think the best thing to do is to resurrect _lastError, but use it only for
programmatic errors. If there's been a programmatic error at any point,
[getAllAssets] should throw it, because it means that the package graph is in an
inconsistent state.

[Bob Nystrom, 2013/08/21 18:10:23]

Done.

+        _resultsController.addError(error);
+      });
     }
 
     _errors = mergeStreams(_cascades.values.map((cascade) => cascade.errors));
   }
 
   /// 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.
   Future<AssetNode> getAssetNode(AssetId id) {
     var cascade = _cascades[id.package];
     if (cascade != null) return cascade.getAssetNode(id);
     return new Future.value(null);
   }
 
+  /// Gets all output assets.
+  ///
+  /// If a build is currently in progress, waits until it completes. The
+  /// returned future will complete with an error if the build is not
+  /// successful.
+  Future<AssetSet> getAllAssets() {
+    if (_cascadeResults.values.any((result) => result == null)) {

[nweiz, 2013/08/20 19:59:26]

_cascadeResults.values.contains(null)

[Bob Nystrom, 2013/08/20 21:29:20]

Done.

+      // A build is still ongoing, so wait for it to complete and try again.
+      return results.first.then((_) => getAllAssets());
+    }
+
+    // If the build completed with an error, complete the future with it.
+    if (_lastError != null) return new Future.error(_lastError);
+
+    // 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));
+  }
+
   /// 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];
       if (cascade == null) throw new ArgumentError("Unknown package $package.");
       _cascadeResults[package] = null;
       cascade.updateSources(ids);
     });
   }
 
   /// Removes [removed] from the graph's known set of source assets.
   void removeSources(Iterable<AssetId> sources) {
     groupBy(sources, (id) => id.package).forEach((package, ids) {
       var cascade = _cascades[package];
       if (cascade == null) throw new ArgumentError("Unknown package $package.");
       _cascadeResults[package] = null;
       cascade.removeSources(ids);
     });
   }
 }