Make Phase.getInput in barback play nicely with the push model.

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 'dart:collection';
 
 import 'asset.dart';
 import 'asset_id.dart';
 import 'asset_node.dart';
 import 'asset_set.dart';
 import 'log.dart';
 import 'cancelable_future.dart';
 import 'errors.dart';
 import 'package_graph.dart';
 import 'phase.dart';
@@ skipping 52 matching lines @@
   ///
   /// This is synchronous in order to guarantee that it will emit an event as
   /// soon as [isDirty] flips from `true` to `false`.
   Stream get onDone => _onDoneController.stream;
   final _onDoneController = new StreamController.broadcast(sync: true);
 
   /// Returns all currently-available output assets from this cascade.
   AssetSet get availableOutputs =>
     new AssetSet.from(_phases.last.availableOutputs.map((node) => node.asset));
 
-  /// A map of asset ids to completers for [getAssetNode] 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 _pendingAssetRequests = new Map<AssetId, Completer<AssetNode>>();
-
   /// Creates a new [AssetCascade].
   ///
   /// It loads source assets within [package] using [provider].
   AssetCascade(this.graph, this.package) {
     _addPhase(new Phase(this, package));
   }
 
   /// Gets the asset identified by [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 asset cannot be found, returns null.
   Future<AssetNode> getAssetNode(AssetId id) {
     assert(id.package == package);
 
+    var oldLastPhase = _phases.last;
     // TODO(rnystrom): Waiting for the entire build to complete is unnecessary
     // in some cases. Should optimize:
     // * [id] may be generated before the compilation is finished. We should
     //   be able to quickly check whether there are any more in-place
     //   transformations that can be run on it. If not, we can return it early.
     // * If [id] has never been generated and all active transformers provide
     //   metadata about the file names of assets it can emit, we can prove that
     //   none of them can emit [id] and fail early.
-    return _phases.last.getOutput(id).then((node) {
-      if (node != null) {
-        // If the requested asset is available, we can just return it.
-        if (node.state.isAvailable) return node;
-
-        // If the requested asset exists but isn't yet available, wait to see if
-        // it becomes available. If it's removed before becoming available, try
-        // again, since it could be generated again.
-        node.force();
-        return node.whenAvailable((_) => node).catchError((error) {
-          if (error is! AssetNotFoundException) throw error;
-          return getAssetNode(id);
-        });
-      }
-
-      // If the cascade isn't dirty, the phase won't generate the requested
-      // asset in the future.
-      if (!isDirty) return null;
-
-      // If the cascade is dirty, store a completer for the asset node. If it's
-      // generated in the future, we'll complete this completer.
-      var completer = _pendingAssetRequests.putIfAbsent(id,
-          () => new Completer.sync());
-      return completer.future;
+    return oldLastPhase.getOutput(id).then((node) {
+      // The last phase may have changed if [updateSources] was called after
+      // requesting the output. In that case, we want the output from the new
+      // last phase.
+      if (_phases.last == oldLastPhase) return node;
+      return getAssetNode(id);
     });
   }
 
   /// Adds [sources] to the graph's known set of source assets.
   ///
   /// Begins applying any transforms that can consume any of the sources. If a
   /// given source is already known, it is considered modified and all
   /// transforms that use it will be re-applied.
   void updateSources(Iterable<AssetId> sources) {
     for (var id in sources) {
@@ skipping 70 matching lines @@
     }
   }
 
   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.onAsset.listen(_providePendingAsset);
-
     phase.onDone.listen((_) {
-      if (isDirty) return;
-
-      // This cascade has finished building. If anyone's still waiting for
-      // assets, cut off the wait; we won't be generating them, at least until a
-      // source asset changes.
-      for (var completer in _pendingAssetRequests.values) {
-        completer.complete(null);
-      }
-      _pendingAssetRequests.clear();
-      _onDoneController.add(null);
+      if (!isDirty) _onDoneController.add(null);
     });
 
     _phases.add(phase);
   }
 
-  /// Provide an asset to a pending [getAssetNode] call.
-  void _providePendingAsset(AssetNode asset) {
-    // If anyone's waiting for this asset, provide it to them.
-    var request = _pendingAssetRequests.remove(asset.id);
-    if (request == null) return;
-
-    if (asset.state.isAvailable) {
-      request.complete(asset);
-      return;
-    }
-
-    // A lazy asset may be emitted while still dirty. If so, we wait until
-    // it's either available or removed before trying again to access it. We
-    // retry the entire [getAsset] process because the state of the graph may
-    // have changed dramatically by the time it's available.
-    assert(asset.state.isDirty);
-    asset.force();
-    asset.whenStateChanges()
-        .then((_) => getAssetNode(asset.id))
-        .then(request.complete)
-        .catchError(request.completeError);
-  }
-
   String toString() => "cascade for $package";
 }