Re-run a transform when a secondary input starts existing.

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';
@@ skipping 22 matching lines @@
 
   /// The node for the primary asset this transform depends on.
   final AssetNode primary;
 
   /// 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.isDone;
 
   /// Whether [transformer] is lazy and this transform has yet to be forced.
   bool _isLazy;
 
   /// The subscriptions to each input's [AssetNode.onStateChange] stream.
-  var _inputSubscriptions = new Map<AssetId, StreamSubscription>();
+  final _inputSubscriptions = new Map<AssetId, StreamSubscription>();
 
   /// The controllers for the asset nodes emitted by this node.
-  var _outputControllers = new Map<AssetId, AssetNodeController>();
+  final _outputControllers = new Map<AssetId, AssetNodeController>();
+
+  final _missingInputs = new Set<AssetId>();
 
   /// The controller that's used to pass [primary] through [this] if it's not
   /// 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;
 
@@ skipping 38 matching lines @@
       : transformer = transformer,
         _isLazy = transformer is LazyTransformer {
     _primarySubscription = primary.onStateChange.listen((state) {
       if (state.isRemoved) {
         remove();
       } else {
         _dirty(primaryChanged: true);
       }
     });
 
+    _phaseSubscription = phase.previous.onAsset.listen((node) {
+      if (_missingInputs.contains(node.id)) _dirty(primaryChanged: false);
+    });
+
     _process();
   }
 
   /// The [TransformInfo] describing this node.
   ///
   /// [TransformInfo] is the publicly-visible representation of a transform
   /// node.
   TransformInfo get info => new TransformInfo(transformer, primary.id);
 
   /// Marks this transform as removed.
   ///
   /// This causes all of the transform's outputs to be marked as removed as
   /// well. Normally this will be automatically done internally based on events
   /// from the primary input, but it's possible for a transform to no longer be
   /// valid even if its primary input still exists.
   void remove() {
     _onAssetController.close();
     _onDoneController.close();
     _primarySubscription.cancel();
+    _phaseSubscription.cancel();
     _clearInputSubscriptions();
     _clearOutputs();
     if (_passThroughController != null) {
       _passThroughController.setRemoved();
       _passThroughController = null;
     }
   }
 
   /// If [transformer] is lazy, ensures that its concrete outputs will be
   /// generated.
@@ skipping 108 matching lines @@
         _state = _TransformNodeState.APPLIED;
         _onDoneController.add(null);
       }
     });
   }
 
   /// 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.getInput(id).then((node) {
+    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
       // results stream.
-      if (node == null) throw new AssetNotFoundException(id);
+      if (node == null) {
+        _missingInputs.add(id);
+        throw new AssetNotFoundException(id);
+      }
 
       _inputSubscriptions.putIfAbsent(node.id, () {
         return node.onStateChange.listen((_) => _dirty(primaryChanged: false));
       });
 
       return node.asset;
     });
   }
 
   /// Applies the transform so that it produces concrete (as opposed to lazy)
@@ skipping 103 matching lines @@
           _onAssetController.add(controller.node);
         }
       }
 
       return false;
     });
   }
 
   /// Cancels all subscriptions to secondary input nodes.
   void _clearInputSubscriptions() {
+    _missingInputs.clear();
     for (var subscription in _inputSubscriptions.values) {
       subscription.cancel();
     }
     _inputSubscriptions.clear();
   }
 
   /// Removes all output assets.
   void _clearOutputs() {
     // Remove all the previously-emitted assets.
     for (var controller in _outputControllers.values) {
@@ skipping 95 matching lines @@
   ///
   /// Specifically, whether [this] is [APPLIED] or [NOT_PRIMARY].
   bool get isDone => isApplied || isNotPrimary;
 
   final String name;
 
   const _TransformNodeState._(this.name);
 
   String toString() => name;
 }