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

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 'asset.dart';
 import 'asset_id.dart';
@@ skipping 30 matching lines @@
   /// cascade's package's source assets.
   final _sourceControllerMap = new Map<AssetId, AssetNodeController>();
 
   /// Futures for source assets that are currently being loaded.
   ///
   /// These futures are cancelable so that if an asset is updated after a load
   /// has been kicked off, the previous load can be ignored in favor of a new
   /// one.
   final _loadingSources = new Map<AssetId, CancelableFuture<Asset>>();
 
+  /// The list of phases in this cascade.
+  ///
+  /// This will always contain at least one phase, and the first phase will
+  /// never have any transformers. This ensures that every transformer can
+  /// request inputs from a previous phase.
   final _phases = <Phase>[];
 
+  /// The subscription to the [Phase.onDone] stream of the last [Phase] in
+  /// [_phases].
+  StreamSubscription _phaseOnDoneSubscription;
+
   /// A stream that emits any errors from the cascade or the transformers.
   ///
   /// This emits errors as they're detected. If an error occurs in one part of
   /// the cascade, unrelated parts will continue building.
   Stream<BarbackException> get errors => _errorsController.stream;
   final _errorsController =
       new StreamController<BarbackException>.broadcast(sync: true);
 
   /// A stream that emits an event whenever any transforms in this cascade logs
   /// an entry.
@@ skipping 99 matching lines @@
     });
   }
 
   /// Sets this cascade's transformer phases to [transformers].
   ///
   /// Elements of the inner iterable of [transformers] must be either
   /// [Transformer]s or [TransformerGroup]s.
   void updateTransformers(Iterable<Iterable> transformersIterable) {
     var transformers = transformersIterable.toList();
 
-    for (var i = 0; i < transformers.length; i++) {
+    // Always preserve a single phase with no transformers at the beginning of
+    // the cascade so that [TransfomNode]s in the first populated phase will

[Bob Nystrom, 2014/03/15 01:03:55]

Transfom -> Transform

+    // have something to request assets from.
+    for (var i = 1; i <= transformers.length; i++) {

[Bob Nystrom, 2014/03/15 01:03:55]

I think it would be clearer to keep i ranging from 0...transformers.length and
then use _phases[i + 1].

       if (_phases.length > i) {
-        _phases[i].updateTransformers(transformers[i]);
+        _phases[i].updateTransformers(transformers[i - 1]);
         continue;
       }
 
       var phase = _phases.last.addPhase();
       _addPhase(phase);
-      phase.updateTransformers(transformers[i]);
+      phase.updateTransformers(transformers[i - 1]);
     }
 
-    if (transformers.length == 0) {
-      _phases.last.updateTransformers([]);
-    } else {
-      for (var i = transformers.length; i < _phases.length; i++) {
-        _phases[i].remove();
-      }
-      _phases.removeRange(transformers.length, _phases.length);
+    for (var i = transformers.length + 1; i < _phases.length; i++) {
+      _phases[i].remove();
     }
+    _phases.removeRange(transformers.length + 1, _phases.length);
+
+    _phaseOnDoneSubscription.cancel();
+    _phaseOnDoneSubscription = _phases.last.onDone
+        .listen(_onDoneController.add);
   }
 
   /// Force all [LazyTransformer]s' transforms in this cascade to begin
   /// producing concrete assets.
   void forceAllTransforms() {
     for (var phase in _phases) {
       phase.forceAllTransforms();
     }
   }
 
   void reportError(BarbackException error) {
     _errorsController.add(error);
   }
 
   /// Add [phase] to the end of [_phases] and watch its streams.
   void _addPhase(Phase phase) {
     _onLogPool.add(phase.onLog);
-    phase.onDone.listen((_) {
-      if (!isDirty) _onDoneController.add(null);
-    });
+    if (_phaseOnDoneSubscription != null) _phaseOnDoneSubscription.cancel();
+    _phaseOnDoneSubscription = phase.onDone.listen(_onDoneController.add);
 
     _phases.add(phase);
   }
 
   String toString() => "cascade for $package";
 }