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

pkg/barback/lib/src/phase.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;
 
 import 'dart:async';
 
 import 'asset_cascade.dart';
 import 'asset_id.dart';
@@ skipping 81 matching lines @@
   /// emit assets.
   Stream<AssetNode> get onAsset => _onAssetController.stream;
   final _onAssetController =
       new StreamController<AssetNode>.broadcast(sync: true);
 
   /// Whether [this] is dirty and still has more processing to do.
   ///
   /// A phase is considered dirty if any of the previous phases in the same
   /// cascade are dirty, since those phases could emit an asset that this phase
   /// will then need to process.
-  bool get isDirty => (_previous != null && _previous.isDirty) ||
+  bool get isDirty => (previous != null && previous.isDirty) ||
       _inputs.values.any((input) => input.isDirty) ||
       _groups.values.any((group) => group.isDirty);
 
   /// A stream that emits an event whenever any transforms in this phase logs
   /// an entry.
   Stream<LogEntry> get onLog => _onLogPool.stream;
   final _onLogPool = new StreamPool<LogEntry>.broadcast();
 
   /// The previous phase in the cascade, or null if this is the first phase.
-  final Phase _previous;
+  final Phase previous;
 
-  /// The subscription to [_previous]'s [onDone] stream.
+  /// The subscription to [previous]'s [onDone] stream.
   StreamSubscription _previousOnDoneSubscription;
 
-  /// The subscription to [_previous]'s [onAsset] stream.
+  /// The subscription to [previous]'s [onAsset] stream.
   StreamSubscription<AssetNode> _previousOnAssetSubscription;
 
   /// A map of asset ids to completers for [getInput] requests.
   ///
   /// If an asset node is requested before it's available, we put a completer in
   /// this map to wait for the asset to be generated. If it's not generated, the
   /// completer should complete to `null`.
   final _pendingOutputRequests = new Map<AssetId, Completer<AssetNode>>();
 
   /// Returns all currently-available output assets for this phase.
   Set<AssetNode> get availableOutputs {
     return _outputs.values
         .map((output) => output.output)
         .where((node) => node.state.isAvailable)
         .toSet();
   }
 
   // TODO(nweiz): Rather than passing the cascade and the phase everywhere,
   // create an interface that just exposes [getInput]. Emit errors via
   // [AssetNode]s.
   Phase(AssetCascade cascade, String location)
       : this._(cascade, location, 0);
 
-  Phase._(this.cascade, this._location, this._index, [this._previous]) {
-    if (_previous != null) {
-      _previousOnAssetSubscription = _previous.onAsset.listen(addInput);
-      _previousOnDoneSubscription = _previous.onDone.listen((_) {
+  Phase._(this.cascade, this._location, this._index, [this.previous]) {
+    if (previous != null) {
+      _previousOnAssetSubscription = previous.onAsset.listen(addInput);
+      _previousOnDoneSubscription = previous.onDone.listen((_) {
         if (!isDirty) _onDoneController.add(null);
       });
     }
 
     onDone.listen((_) {
       // All the previous phases have finished building. If anyone's still
       // waiting for outputs, cut off the wait; we won't be generating them,
       // at least until a source asset changes.
       for (var completer in _pendingOutputRequests.values) {
         completer.complete(null);
@@ skipping 42 matching lines @@
       if (!isDirty) _onDoneController.add(null);
     });
 
     input.updateTransformers(_transformers);
 
     for (var group in _groups.values) {
       group.addInput(node);
     }
   }
 
-  // TODO(nweiz): If the input is available when this is called, it's
+  // TODO(nweiz): If the output is available when this is called, it's
   // theoretically possible for it to become unavailable between the call and
   // the return. If it does so, it won't trigger the rebuilding process. To
   // avoid this, we should have this and the methods it calls take explicit
   // callbacks, as in [AssetNode.whenAvailable].
-  /// Gets the asset node for an input [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 input cannot be found, returns null.
-  Future<AssetNode> getInput(AssetId id) {
-    return syncFuture(() {
-      if (id.package != cascade.package) return cascade.graph.getAssetNode(id);
-      if (_previous != null) return _previous.getOutput(id);
-      if (!_inputs.containsKey(id)) return null;
-
-      var input = _inputs[id].input;
-      return input.whenAvailable((_) => input).catchError((error) {
-        if (error is! AssetNotFoundException || error.id != id) throw error;
-        // Retry in case the input was replaced.
-        return getInput(id);
-      });
-    });
-  }
-
   /// Gets the asset node for an output [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 output cannot be found, returns null.
   Future<AssetNode> getOutput(AssetId id) {
     return syncFuture(() {
       if (id.package != cascade.package) return cascade.graph.getAssetNode(id);
@@ skipping 156 matching lines @@
     assert(asset.state.isDirty);
     asset.force();
     asset.whenStateChanges().then((state) {
       if (state.isRemoved) return getOutput(asset.id);
       return asset;
     }).then(request.complete).catchError(request.completeError);
   }
 
   String toString() => "phase $_location.$_index";
 }