Expand barback's notion of dirtiness to understand declaredness.

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 'dart:collection';
 
 import 'asset_cascade.dart';
 import 'asset_id.dart';
 import 'asset_node.dart';
 import 'asset_set.dart';
 import 'build_result.dart';
 import 'errors.dart';
 import 'log.dart';
+import 'node_status.dart';
 import 'package_provider.dart';
 import 'transformer.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 {
   /// The provider that exposes asset and package information.
@@ skipping 21 matching lines @@
   ///
   /// 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 stream of [LogEntry] objects used to report transformer log entries.
   Stream<LogEntry> get log => _logController.stream;
   final _logController = new StreamController<LogEntry>.broadcast(sync: true);
 
-  /// Whether [this] is dirty and still has more processing to do.
-  bool get _isDirty => _cascades.values.any((cascade) => cascade.isDirty);
+  /// How far along [this] is in processing its assets.
+  NodeStatus get _status => NodeStatus.dirtiest(
+      _cascades.values.map((cascade) => cascade.status));
 
   /// Whether a [BuildResult] is scheduled to be emitted on [results] (see
   /// [_tryScheduleResult]).
   bool _resultScheduled = false;
 
   /// The most recent [BuildResult] emitted on [results].
   BuildResult _lastResult;
 
   // TODO(nweiz): This can have bogus errors if an error is created and resolved
   // in the space of one build.
@@ skipping 12 matching lines @@
   StackTrace _lastUnexpectedErrorTrace;
 
   /// Creates a new [PackageGraph] that will transform assets in all packages
   /// made available by [provider].
   PackageGraph(this.provider) {
     _inErrorZone(() {
       for (var package in provider.packages) {
         var cascade = new AssetCascade(this, package);
         _cascades[package] = cascade;
         cascade.onLog.listen(_onLog);
-        cascade.onDone.listen((_) => _tryScheduleResult());
+        cascade.onStatusChange.listen((status) {
+          if (status == NodeStatus.IDLE) _tryScheduleResult();
+        });
       }
 
       _errors = mergeStreams(_cascades.values.map((cascade) => cascade.errors),
           broadcast: true);
       _errors.listen(_accumulatedErrors.add);
     });
   }
 
   /// Gets the asset node identified by [id].
   ///
@@ skipping 16 matching lines @@
   /// returned future will complete with an error if the build is not
   /// successful.
   ///
   /// Any transforms using [LazyTransformer]s will be forced to generate
   /// concrete outputs, and those outputs will be returned.
   Future<AssetSet> getAllAssets() {
     for (var cascade in _cascades.values) {
       _inErrorZone(() => cascade.forceAllTransforms());
     }
 
-    if (_isDirty) {
+    if (_status != NodeStatus.IDLE) {
       // A build is still ongoing, so wait for it to complete and try again.
       return results.first.then((_) => getAllAssets());
     }
 
     // If an unexpected error occurred, complete with that.
     if (_lastUnexpectedError != null) {
       var error = _lastUnexpectedError;
       _lastUnexpectedError = null;
       return new Future.error(error, _lastUnexpectedErrorTrace);
     }
@@ skipping 75 matching lines @@
     }
   }
 
   /// If [this] is done processing, schedule a [BuildResult] to be emitted on
   /// [results].
   ///
   /// This schedules the result (as opposed to just emitting one directly on
   /// [BuildResult]) to ensure that calling multiple functions synchronously
   /// produces only a single [BuildResult].
   void _tryScheduleResult() {
-    if (_isDirty) return;
+    if (_status != NodeStatus.IDLE) return;
     if (_resultScheduled) return;
 
     _resultScheduled = true;
     newFuture(() {
       _resultScheduled = false;
-      if (_isDirty) return;
+      if (_status != NodeStatus.IDLE) return;
 
       _lastResult = new BuildResult(_accumulatedErrors);
       _accumulatedErrors.clear();
       _resultsController.add(_lastResult);
     });
   }
 
   /// Run [body] in an error-handling [Zone] and pipe any unexpected errors to
   /// the error channel of [results].
   ///
   /// [body] can return a value or a [Future] that will be piped to the returned
   /// [Future]. If it throws a [BarbackException], that exception will be piped
   /// to the returned [Future] as well. Any other exceptions will be piped to
   /// [results].
   Future _inErrorZone(body()) {
     var completer = new Completer.sync();
     runZoned(() {
       syncFuture(body).then(completer.complete).catchError((error, stackTrace) {
         if (error is! BarbackException) throw error;
         completer.completeError(error, stackTrace);
       });
     }, onError: (error, stackTrace) {
       _lastUnexpectedError = error;
       _lastUnexpectedErrorTrace = stackTrace;
       _resultsController.addError(error, stackTrace);
     });
     return completer.future;
   }
 }