Expand barback's notion of dirtiness to understand declaredness.

pkg/barback/lib/src/transform_node.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.transform_node;
 
 import 'dart:async';
 
 import 'asset.dart';
 import 'asset_id.dart';
 import 'asset_node.dart';
 import 'declaring_transform.dart';
 import 'declaring_transformer.dart';
 import 'errors.dart';
 import 'lazy_transformer.dart';
 import 'log.dart';
+import 'node_status.dart';
 import 'node_streams.dart';
 import 'phase.dart';
 import 'transform.dart';
 import 'transformer.dart';
 import 'utils.dart';
 
 /// Describes a transform on a set of assets and its relationship to the build
 /// dependency graph.
 ///
 /// Keeps track of whether it's dirty and needs to be run and which assets it
@@ skipping 10 matching lines @@
 
   /// A string describing the location of [this] in the transformer graph.
   final String _location;
 
   /// The subscription to [primary]'s [AssetNode.onStateChange] stream.
   StreamSubscription _primarySubscription;
 
   /// The subscription to [phase]'s [Phase.onAsset] stream.
   StreamSubscription<AssetNode> _phaseSubscription;
 
-  /// Whether [this] is dirty and still has more processing to do.
-  bool get isDirty => _state != _State.NOT_PRIMARY &&
-      _state != _State.APPLIED && _state != _State.DECLARED;
+  /// How far along [this] is in processing its assets.
+  NodeStatus get status {
+    if (_state == _State.NOT_PRIMARY || _state == _State.APPLIED ||
+        _state == _State.DECLARED) {
+      return NodeStatus.IDLE;
+    }
+
+    if (transformer is DeclaringTransformer && _state != _State.DECLARING) {
+      return NodeStatus.MATERIALIZING;
+    } else {
+      return NodeStatus.RUNNING;
+    }
+  }
 
   /// Whether this transform is deferred.
   ///
   /// A transform is deferred if either its transformer is lazy or if its
   /// transformer is declaring and its primary input comes from a deferred
   /// transformer.
   final bool deferred;
 
   /// Whether this transform has been forced since it last finished applying.
   ///
@@ skipping 16 matching lines @@
   /// consumed or overwritten.
   ///
   /// This needs an intervening controller to ensure that the output can be
   /// marked dirty when determining whether [this] will consume or overwrite it,
   /// and be marked removed if it does. [_passThroughController] will be null
   /// if the asset is not being passed through.
   AssetNodeController _passThroughController;
 
   /// The asset node for this transform.
   final _streams = new NodeStreams();
-  Stream get onDone => _streams.onDone;
+  Stream<NodeStatus> get onStatusChange => _streams.onStatusChange;
   Stream<AssetNode> get onAsset => _streams.onAsset;
   Stream<LogEntry> get onLog => _streams.onLog;
 
   /// The current state of [this].
   var _state = _State.DECLARING;
 
   /// Whether [this] has been marked as removed.
   bool get _isRemoved => _streams.onAssetController.isClosed;
 
   /// Whether the most recent run of this transform has declared that it
@@ skipping 87 matching lines @@
 
     // If [transformer] is declaring but not lazy and [primary] is available, we
     // do want to start running [apply] even if [force] hasn't been called,
     // since [transformer] should run eagerly if possible.
     var canRunDeclaringEagerly =
         transformer is! LazyTransformer && primary.state.isAvailable;
     if (!_forced && !canRunDeclaringEagerly) {
       // [forced] should only ever be false for a deferred transform.
       assert(deferred);
 
-      // If we've finished applying, transition to DECLARED, indicating that we
-      // know what outputs [apply] will emit but we're waiting to emit them
-      // concretely until [force] is called. If we're still applying, we'll
-      // transition to DECLARED once we finish.
+      // If we've finished applying, transition to MATERIALIZING, indicating
+      // that we know what outputs [apply] will emit but we're waiting to emit
+      // them concretely until [force] is called. If we're still applying, we'll
+      // transition to MATERIALIZING once we finish.
       if (_state == _State.APPLIED) _state = _State.DECLARED;
       for (var controller in _outputControllers.values) {
         controller.setLazy(force);
       }
+      _emitDeclaredOutputs();
       return;
     }
 
     if (_passThroughController != null) _passThroughController.setDirty();
     for (var controller in _outputControllers.values) {
       controller.setDirty();
     }
 
-    if (_state == _State.APPLIED || _state == _State.DECLARED) {
+    if (_state == _State.APPLIED) {
+      if (_declaredOutputs != null) _emitDeclaredOutputs();
+      _apply();
+    } else if (_state == _State.DECLARED) {
       _apply();
     } else {
       _state = _State.NEEDS_APPLY;
     }
   }
 
   /// Runs [transformer.isPrimary] and adjusts [this]'s state according to the
   /// result.
   ///
   /// This will also run [_declareOutputs] and/or [_apply] as appropriate.
@@ skipping 10 matching lines @@
     }).then((isPrimary) {
       if (_isRemoved) return null;
       if (isPrimary) {
         if (!deferred) primary.force();
         return _declareOutputs().then((_) {
           if (_isRemoved) return;
           if (_forced) {
             _apply();
           } else {
             _state = _State.DECLARED;
-            _streams.onDoneController.add(null);
+            _streams.changeStatus(NodeStatus.IDLE);
           }
         });
       }
 
       _emitPassThrough();
       _state = _State.NOT_PRIMARY;
-      _streams.onDoneController.add(null);
+      _streams.changeStatus(NodeStatus.IDLE);
     });
   }
 
   /// Runs [transform.declareOutputs] and emits the resulting assets as dirty
   /// assets.
   Future _declareOutputs() {
     if (transformer is! DeclaringTransformer) return new Future.value();
 
     var controller = new DeclaringTransformController(this);
     return syncFuture(() {
       return (transformer as DeclaringTransformer)
           .declareOutputs(controller.transform);
     }).then((_) {
       if (_isRemoved) return;
       if (controller.loggedError) return;
 
       _consumePrimary = controller.consumePrimary;
       _declaredOutputs = controller.outputIds;
       var invalidIds = _declaredOutputs
           .where((id) => id.package != phase.cascade.package).toSet();
       for (var id in invalidIds) {
         _declaredOutputs.remove(id);
         // TODO(nweiz): report this as a warning rather than a failing error.
         phase.cascade.reportError(new InvalidOutputException(info, id));
       }
 
       if (!_declaredOutputs.contains(primary.id)) _emitPassThrough();
-
-      for (var id in _declaredOutputs) {
-        var controller = _forced
-            ? new AssetNodeController(id, this)
-            : new AssetNodeController.lazy(id, force, this);
-        _outputControllers[id] = controller;
-        _streams.onAssetController.add(controller.node);
-      }
+      _emitDeclaredOutputs();
     }).catchError((error, stackTrace) {
       if (_isRemoved) return;
       phase.cascade.reportError(_wrapException(error, stackTrace));
     });
   }
 
+  /// Emits a dirty asset node for all outputs that were declared by the
+  /// transformer.
+  ///
+  /// This won't emit any outputs for which there already exist output
+  /// controllers. It should only be called for transforms that have declared
+  /// their outputs.
+  void _emitDeclaredOutputs() {
+    assert(_declaredOutputs != null);
+    for (var id in _declaredOutputs) {
+      if (_outputControllers.containsKey(id)) continue;
+      var controller = _forced
+          ? new AssetNodeController(id, this)
+          : new AssetNodeController.lazy(id, force, this);
+      _outputControllers[id] = controller;
+      _streams.onAssetController.add(controller.node);
+    }
+  }
+
   /// Applies this transform.
   void _apply() {
     assert(!_isRemoved);
 
     // Clear input subscriptions here as well as in [_process] because [_apply]
     // may be restarted independently if only a secondary input changes.
     _clearInputSubscriptions();
     _state = _State.APPLYING;
+    _streams.changeStatus(status);
     _runApply().then((hadError) {
       if (_isRemoved) return;
 
       if (_state == _State.DECLARED) return;
 
       if (_state == _State.NEEDS_APPLY) {
         _apply();
         return;
       }
 
       if (deferred) _forced = false;
 
       assert(_state == _State.APPLYING);
       if (hadError) {
         _clearOutputs();
         // If the transformer threw an error, we don't want to emit the
         // pass-through asset in case it will be overwritten by the transformer.
         // However, if the transformer declared that it wouldn't overwrite or
         // consume the pass-through asset, we can safely emit it.
         if (_declaredOutputs != null && !_consumePrimary &&
             !_declaredOutputs.contains(primary.id)) {
           _emitPassThrough();
         } else {
           _dontEmitPassThrough();
         }
       }
 
       _state = _State.APPLIED;
-      _streams.onDoneController.add(null);
+      _streams.changeStatus(NodeStatus.IDLE);
     });
   }
 
   /// Gets the asset for an input [id].
   ///
   /// If an input with [id] cannot be found, throws an [AssetNotFoundException].
   Future<Asset> getInput(AssetId id) {
     return phase.previous.getOutput(id).then((node) {
       // Throw if the input isn't found. This ensures the transformer's apply
       // is exited. We'll then catch this and report it through the proper
@@ skipping 18 matching lines @@
     var transformController = new TransformController(this);
     _streams.onLogPool.add(transformController.onLog);
 
     return primary.whenAvailable((_) {
       if (_isRemoved) return null;
       _state = _State.APPLYING;
       return syncFuture(() => transformer.apply(transformController.transform));
     }).then((_) {
       if (deferred && !_forced && !primary.state.isAvailable) {
         _state = _State.DECLARED;
-        _streams.onDoneController.add(null);
+        _streams.changeStatus(NodeStatus.IDLE);
         return false;
       }
 
       if (_isRemoved) return false;
       if (_state == _State.NEEDS_APPLY) return false;
       if (_state == _State.DECLARING) return false;
       if (transformController.loggedError) return true;
       _handleApplyResults(transformController);
       return false;
     }).catchError((error, stackTrace) {
@@ skipping 162 matching lines @@
   ///
   /// This will never transition to another state.
   static final NOT_PRIMARY = const _State._("not primary");
 
   final String name;
 
   const _State._(this.name);
 
   String toString() => name;
 }