Improve barback/pub logging.

pkg/barback/lib/src/phase_input.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.phase_input;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'asset.dart';
 import 'asset_forwarder.dart';
 import 'asset_node.dart';
+import 'barback_logger.dart';
 import 'errors.dart';
 import 'phase.dart';
 import 'stream_pool.dart';
 import 'transform_node.dart';
 import 'transformer.dart';
 import 'utils.dart';
 
 /// A class for watching a single [AssetNode] and running any transforms that
 /// take that node as a primary input.
 class PhaseInput {
@@ skipping 48 matching lines @@
   /// This is used whenever the input is changed or removed. It's sometimes
   /// redundant with the events collected from [_transforms], but this stream is
   /// necessary for removed inputs, and the transform stream is necessary for
   /// modified secondary inputs.
   final _onDirtyController = new StreamController.broadcast(sync: true);
 
   /// Whether this input is dirty and needs [process] to be called.
   bool get isDirty => _adjustTransformersFuture != null ||
       _newPassThrough || _transforms.any((transform) => transform.isDirty);
 
+  /// A stream that emits an event whenever any transforms that use [input] as
+  /// their primary input log an entry.

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

"log" -> "logs"

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

This one's actually correct. :)

+  Stream<LogEntry> get onLog => _onLogPool.stream;
+  final _onLogPool = new StreamPool<LogEntry>.broadcast();
+
   PhaseInput(this._phase, AssetNode input, Iterable<Transformer> transformers)
       : _transformers = transformers.toSet(),
         _inputForwarder = new AssetForwarder(input) {
     _onDirtyPool.add(_onDirtyController.stream);
 
     input.onStateChange.listen((state) {
       if (state.isRemoved) {
         remove();
       } else if (_adjustTransformersFuture == null) {
         _adjustTransformers();
       }
     });
 
     _adjustTransformers();
   }
 
   /// Removes this input.
   ///
   /// This marks all outputs of the input as removed.
   void remove() {
     _onDirtyController.add(null);
     _onDirtyPool.close();
+    _onLogPool.close();
     _inputForwarder.close();
     if (_passThroughController != null) {
       _passThroughController.setRemoved();
       _passThroughController = null;
     }
   }
 
   /// Set this input's transformers to [transformers].
   void updateTransformers(Iterable<Transformer> newTransformers) {
     newTransformers = newTransformers.toSet();
@@ skipping 104 matching lines @@
       // We can safely access [input.asset] here even though it might have
       // changed since (as above) if it has, [_adjustTransformers] will just be
       // re-run.
       // TODO(rnystrom): Catch all errors from isPrimary() and redirect to
       // results.
       return transformer.isPrimary(input.asset).then((isPrimary) {
         if (!isPrimary) return;
         var transform = new TransformNode(_phase, transformer, input);
         _transforms.add(transform);
         _onDirtyPool.add(transform.onDirty);
+        _onLogPool.add(transform.onLog);
       });
     }));
   }
 
   /// Adjust whether [input] is passed through the phase unmodified, based on
   /// whether it's consumed by other transforms in this phase.
   ///
   /// If [input] was already passed-through, this will update the passed-through
   /// value.
   void _adjustPassThrough() {
@@ skipping 50 matching lines @@
       return new Future.value(
           new Set<AssetNode>.from([_passThroughController.node]));
     }
 
     return Future.wait(_transforms.map((transform) {
       if (!transform.isDirty) return new Future.value(new Set());
       return transform.apply();
     })).then((outputs) => unionAll(outputs));
   }
 }