Improve barback/pub logging.

pkg/barback/lib/src/asset_cascade.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.asset_cascade;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'asset.dart';
 import 'asset_id.dart';
 import 'asset_node.dart';
 import 'asset_set.dart';
+import 'barback_logger.dart';
 import 'build_result.dart';
 import 'cancelable_future.dart';
 import 'errors.dart';
 import 'package_graph.dart';
 import 'phase.dart';
 import 'stream_pool.dart';
 import 'transformer.dart';
 import 'utils.dart';
 
 /// The asset cascade for an individual package.
@@ skipping 53 matching lines @@
   ///
   /// This may emit events when the cascade was already dirty. Events are
   /// emitted synchronously to ensure that the dirty state is thoroughly
   /// propagated as soon as any assets are changed.
   Stream get onDirty => _onDirtyPool.stream;
   final _onDirtyPool = new StreamPool.broadcast();
 
   /// A controller whose stream feeds into [_onDirtyPool].
   final _onDirtyController = new StreamController.broadcast(sync: true);
 
+  /// A stream that emits an event whenever any transforms in this cascade log

[nweiz, 2013/10/16 19:41:27]

"log" -> "logs"

[Bob Nystrom, 2013/10/28 23:45:56]

Done.

+  /// an entry.
+  Stream<LogEntry> get onLog => _onLogPool.stream;
+  final _onLogPool = new StreamPool<LogEntry>.broadcast();
+
   /// The errors that have occurred since the current build started.
   ///
   /// This will be empty if no build is occurring.
   Queue<BarbackException> _accumulatedErrors;
 
+  /// The number of errors that have been logged since the current build
+  /// started.
+  int _numLogErrors;
+
   /// A future that completes when the currently running build process finishes.
   ///
   /// If no build it in progress, is `null`.
   Future _processDone;
 
   /// Whether any source assets have been updated or removed since processing
   /// last began.
   var _newChanges = false;
 
   /// Returns all currently-available output assets from this cascade.
   AssetSet get availableOutputs =>
     new AssetSet.from(_phases.last.availableOutputs.map((node) => node.asset));
 
   /// Creates a new [AssetCascade].
   ///
   /// It loads source assets within [package] using [provider].
   AssetCascade(this.graph, this.package) {
     _onDirtyPool.add(_onDirtyController.stream);
     _addPhase(new Phase(this, []));
+
+    // Keep track of logged errors so we can know that the build failed.
+    onLog.listen((entry) {
+      if (entry.level == LogLevel.ERROR) _numLogErrors++;
+    });
   }
 
   /// Gets the asset 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) {
@@ skipping 94 matching lines @@
   }
 
   void reportError(BarbackException error) {
     _accumulatedErrors.add(error);
     _errorsController.add(error);
   }
 
   /// Add [phase] to the end of [_phases] and watch its [onDirty] stream.
   void _addPhase(Phase phase) {
     _onDirtyPool.add(phase.onDirty);
+    _onLogPool.add(phase.onLog);
     phase.onDirty.listen((_) {
       _newChanges = true;
       _waitForProcess();
     });
     _phases.add(phase);
   }
 
   /// Starts the build process asynchronously if there is work to be done.
   ///
   /// Returns a future that completes with the background processing is done.
   /// If there is no work to do, returns a future that completes immediately.
   /// All errors that occur during processing will be caught (and routed to the
   /// [results] stream) before they get to the returned future, so it is safe
   /// to discard it.
   Future _waitForProcess() {
     if (_processDone != null) return _processDone;
 
     _accumulatedErrors = new Queue();
+    _numLogErrors = 0;
     return _processDone = _process().then((_) {
       // Report the build completion.
       // TODO(rnystrom): Put some useful data in here.
-      _resultsController.add(new BuildResult(_accumulatedErrors));
+      _resultsController.add(
+          new BuildResult(_accumulatedErrors, _numLogErrors));
     }).catchError((error) {
       // If we get here, it's an unexpected error. Runtime errors like missing
       // assets should be handled earlier. Errors from transformers or other
       // external code that barback calls into should be caught at that API
       // boundary.
       //
       // On the off chance we get here, pipe the error to the results stream
       // as an error. That will let applications handle it without it appearing
       // in the same path as "normal" errors that get reported.
       _resultsController.addError(error);
@@ skipping 23 matching lines @@
 
         // Otherwise, everything is done.
         return;
       }
 
       // Process that phase and then loop onto the next.
       return future.then((_) => _process());
     });
   }
 }