Add the ability to dynamically modify transforms to barback.

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 'dart:collection';
 
 import 'asset.dart';
@@ skipping 18 matching lines @@
 /// is running asynchronously) that source is modified. When the process queue
 /// goes to advance to phase 3, it will see that modification and start the
 /// waterfall from the beginning again.
 class Phase {
   /// The cascade that owns this phase.
   final AssetCascade cascade;
 
   /// The transformers that can access [inputs].
   ///
   /// Their outputs will be available to the next phase.
-  final List<Transformer> _transformers;
+  final Set<Transformer> _transformers;
 
   /// The inputs that are available for transforms in this phase to consume.
   ///
   /// For the first phase, these will be the source assets. For all other
   /// phases, they will be the outputs from the previous phase.
   final _inputs = new Map<AssetId, AssetNode>();
 
   /// The transforms currently applicable to assets in [inputs], indexed by
   /// the ids of their primary inputs.
   ///
@@ skipping 45 matching lines @@
   ///
   /// This is used whenever an input is added, changed, or removed. It's
   /// sometimes redundant with the events collected from [_transforms], but this
   /// stream is necessary for new and removed inputs, and the transform stream
   /// is necessary for modified secondary inputs.
   final _onDirtyController = new StreamController.broadcast(sync: true);
 
   /// The phase after this one.
   ///
   /// Outputs from this phase will be passed to it.
-  final Phase _next;
+  Phase get next => _next;
+  Phase _next;
 
   /// Returns all currently-available output assets for this phase.
   AssetSet get availableOutputs {
     return new AssetSet.from(_outputs.values
         .map((queue) => queue.first)
         .where((node) => node.state.isAvailable)
         .map((node) => node.asset));
   }
 
-  Phase(this.cascade, this._transformers, this._next) {
+  Phase(this.cascade, Iterable<Transformer> transformers)
+      : _transformers = transformers.toSet() {
     _onDirtyPool.add(_onDirtyController.stream);
   }
 
   /// Adds a new asset as an input for this phase.
   ///
   /// [node] doesn't have to be [AssetState.AVAILABLE]. Once it is, the phase
   /// will automatically begin determining which transforms can consume it as a
   /// primary input. The transforms themselves won't be applied until [process]
   /// is called, however.
   ///
@@ skipping 62 matching lines @@
   ///
   /// If an output with that ID cannot be found, returns null.
   Future<AssetNode> getOutput(AssetId id) {
     return newFuture(() {
       if (id.package != cascade.package) return cascade.graph.getAssetNode(id);
       if (!_outputs.containsKey(id)) return null;
       return _outputs[id].first;
     });
   }
 
+  /// Set this phase's transformers to [transformers].
+  void updateTransformers(Iterable<Transformer> transformers) {
+    _onDirtyController.add(null);
+
+    var newTransformers = transformers.toSet();
+    var oldTransformers = _transformers.toSet();
+    for (var removedTransformer in
+         oldTransformers.difference(newTransformers)) {
+      _transformers.remove(removedTransformer);
+
+      // Remove old transforms for which [removedTransformer] was a transformer.
+      for (var id in _inputs.keys) {
+        // If the transformers are being adjusted for [id], it will
+        // automatically pick up on [removedTransformer] being gone.
+        if (_adjustTransformersFutures.containsKey(id)) continue;
+
+        _transforms[id].removeWhere((transform) {
+          if (transform.transformer != removedTransformer) return false;
+          transform.remove();
+          return true;
+        });
+
+        if (!_transforms[id].isEmpty) continue;
+        _passThroughControllers.putIfAbsent(id, () {
+          return new AssetNodeController.available(
+              _inputs[id].asset, _inputs[id].transform);
+        });
+      }
+    }
+
+    var brandNewTransformers = newTransformers.difference(oldTransformers);
+    if (brandNewTransformers.isEmpty) return;
+    brandNewTransformers.forEach(_transformers.add);
+
+    // If there are any new transformers, start re-adjusting the transforms for
+    // all inputs so we pick up which inputs the new transformers apply to.
+    _inputs.forEach((id, node) {
+      if (_adjustTransformersFutures.containsKey(id)) return;
+      _adjustTransformers(node);
+    });
+  }
+
+  /// Add a new phase after this one with [transformers].
+  ///
+  /// This may only be called on a phase with no phase following it.
+  Phase addPhase(Iterable<Transformer> transformers) {
+    assert(_next == null);
+    _next = new Phase(cascade, transformers);
+    for (var output in _outputs.values.map((queue) => queue.first)) {

[Bob Nystrom, 2013/08/20 19:08:54]

The map here seems a bit gratuitous. How about just:

_next.addInput(queue.first);

[nweiz, 2013/08/20 21:39:17]

Done.

+      _next.addInput(output);
+    }
+    return _next;
+  }
+
   /// Asynchronously determines which transformers can consume [node] as a
   /// primary input and creates transforms for them.
   ///
   /// This ensures that if [node] is modified or removed during or after the
   /// time it takes to adjust its transformers, they're appropriately
   /// re-adjusted. Its progress can be tracked in [_adjustTransformersFutures].
   void _adjustTransformers(AssetNode node) {
     // Mark the phase as dirty. This may not actually end up creating any new
     // transforms, but we want adding or removing a source asset to consistently
     // kick off a build, even if that build does nothing.
     _onDirtyController.add(null);
 
     // If there's a pass-through for this node, mark it dirty while we figure
     // out whether we need to add any transforms for it.
     var controller = _passThroughControllers[node.id];
     if (controller != null) controller.setDirty();
 
     // Once the input is available, hook up transformers for it. If it changes
     // while that's happening, try again.
-    _adjustTransformersFutures[node.id] = node.tryUntilStable((asset) {
+    _adjustTransformersFutures[node.id] = _tryUntilStable(node,
+        (asset, transformers) {
       var oldTransformers = _transforms[node.id]
           .map((transform) => transform.transformer).toSet();
 
-      return _removeStaleTransforms(asset)
-          .then((_) => _addFreshTransforms(node, oldTransformers));
+      return _removeStaleTransforms(asset, transformers).then((_) =>
+          _addFreshTransforms(node, transformers, oldTransformers));
     }).then((_) {
       _adjustPassThrough(node);
 
       // Now all the transforms are set up correctly and the asset is available
       // for the time being. Set up handlers for when the asset changes in the
       // future.
       node.onStateChange.first.then((state) {
         if (state.isRemoved) {
           _onDirtyController.add(null);
           _transforms.remove(node.id);
@@ skipping 18 matching lines @@
       _adjustTransformersFutures.remove(node.id);
     });
 
     // Don't top-level errors coming from the input processing. Any errors will
     // eventually be piped through [process]'s returned Future.
     _adjustTransformersFutures[node.id].catchError((_) {});
   }
 
   // Remove any old transforms that used to have [asset] as a primary asset but
   // no longer apply to its new contents.
-  Future _removeStaleTransforms(Asset asset) {
+  Future _removeStaleTransforms(Asset asset, Set<Transformer> transformers) {
     return Future.wait(_transforms[asset.id].map((transform) {
-      // TODO(rnystrom): Catch all errors from isPrimary() and redirect to
-      // results.
-      return transform.transformer.isPrimary(asset).then((isPrimary) {
+      return newFuture(() {
+        if (!transformers.contains(transform.transformer)) return false;
+
+        // TODO(rnystrom): Catch all errors from isPrimary() and redirect to
+        // results.
+        return transform.transformer.isPrimary(asset);
+      }).then((isPrimary) {
         if (isPrimary) return;
         _transforms[asset.id].remove(transform);
         _onDirtyPool.remove(transform.onDirty);
         transform.remove();
       });
     }));
   }
 
   // Add new transforms for transformers that consider [node]'s asset to be a
   // primary input.
   //
-  // [oldTransformers] is the set of transformers that had [node] as a primary
-  // input prior to this. They don't need to be checked, since they were removed
-  // or preserved in [_removeStaleTransforms].
-  Future _addFreshTransforms(AssetNode node, Set<Transformer> oldTransformers) {
-    return Future.wait(_transformers.map((transformer) {
+  // [oldTransformers] is the set of transformers for which there were
+  // transforms that had [node] as a primary input prior to this. They don't
+  // need to be checked, since their transforms were removed or preserved in
+  // [_removeStaleTransforms].
+  Future _addFreshTransforms(AssetNode node, Set<Transformer> transformers,
+      Set<Transformer> oldTransformers) {
+    return Future.wait(transformers.map((transformer) {
       if (oldTransformers.contains(transformer)) return new Future.value();
 
       // If the asset is unavailable, the results of this [_adjustTransformers]
       // run will be discarded, so we can just short-circuit.
       if (node.asset == null) return new Future.value();
 
       // We can safely access [node.asset] here even though it might have
       // changed since (as above) if it has, [_adjustTransformers] will just be
       // re-run.
       // TODO(rnystrom): Catch all errors from isPrimary() and redirect to
@@ skipping 22 matching lines @@
       } else {
         _passThroughControllers[node.id] =
             new AssetNodeController.available(node.asset, node.transform);
       }
     } else {
       var controller = _passThroughControllers.remove(node.id);
       if (controller != null) controller.setRemoved();
     }
   }
 
+  /// Like [AssetNode.tryUntilStable], but also re-runs [callback] if this
+  /// phase's transformers are modified.
+  Future _tryUntilStable(AssetNode node,
+      Future callback(Asset asset, Set<Transformer> transformers)) {
+    var oldTransformers;
+    return node.tryUntilStable((asset) {
+      oldTransformers = _transformers.toSet();
+      return callback(asset, _transformers);
+    }).then((result) {
+      if (setEquals(oldTransformers, _transformers)) return result;
+      return _tryUntilStable(node, callback);
+    });
+  }
+
   /// Processes this phase.
   ///
   /// Returns a future that completes when processing is done. If there is
   /// nothing to process, returns `null`.
   Future process() {
     if (_adjustTransformersFutures.isEmpty) return _processTransforms();
     return _waitForInputs().then((_) => _processTransforms());
   }
 
   Future _waitForInputs() {
@@ skipping 92 matching lines @@
         // Pump the event queue to ensure that the removal of the input triggers
         // a new build to which we can attach the error.
         newFuture(() => cascade.reportError(new AssetCollisionException(
             assets.where((asset) => asset.transform != null)
                 .map((asset) => asset.transform.info),
             output.id)));
       }
     });
   }
 }