Support passing barback assets through phases in which they're unused.

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 38 matching lines @@
   final _inputs = new Map<AssetId, AssetNode>();
 
   /// The transforms currently applicable to assets in [inputs], indexed by
   /// the ids of their primary inputs.
   ///
   /// These are the transforms that have been "wired up": they represent a
   /// repeatable transformation of a single concrete set of inputs. "dart2js"
   /// is a transformer. "dart2js on web/main.dart" is a transform.
   final _transforms = new Map<AssetId, Set<TransformNode>>();
 
+  /// Controllers for assets that aren't consumed by transforms in this phase.
+  ///
+  /// These assets are passed to the next phase unmodified. They need
+  /// intervening controllers to ensure that the outputs can be marked dirty
+  /// when determining whether transforms apply, and removed if they do.
+  final _passThroughControllers = new Map<AssetId, AssetNodeController>();
+
   /// Futures that will complete once the transformers that can consume a given
   /// asset are determined.
   ///
   /// Whenever an asset is added or modified, we need to asynchronously
   /// determine which transformers can use it as their primary input. We can't
   /// start processing until we know which transformers to run, and this allows
   /// us to wait until we do.
   var _adjustTransformersFutures = new Map<AssetId, Future>();
 
   /// New asset nodes that were added while [_adjustTransformers] was still
   /// being run on an old version of that asset.
   var _pendingNewInputs = new Map<AssetId, AssetNode>();
 
   /// A map of output ids to the asset node outputs for those ids and the
   /// transforms that produced those asset nodes.
   ///
   /// Usually there's only one node for a given output id. However, it's
-  /// possible for multiple transformers in this phase to output an asset with
-  /// the same id. In that case, the chronologically first output emitted is
-  /// passed forward. We keep track of the other nodes so that if that output is
-  /// removed, we know which asset to replace it with.
+  /// possible for multiple transformers to output an asset with the same id. In
+  /// that case, the chronologically first output emitted is passed forward. We
+  /// keep track of the other nodes so that if that output is removed, we know
+  /// which asset to replace it with.
   final _outputs = new Map<AssetId, Queue<AssetNode>>();
 
   /// A stream that emits an event whenever this phase becomes dirty and needs
   /// to be run.
   ///
   /// This may emit events when the phase was already dirty or while processing
   /// transforms. Events are emitted synchronously to ensure that the dirty
   /// state is thoroughly propagated as soon as any assets are changed.
   Stream get onDirty => _onDirtyPool.stream;
   final _onDirtyPool = new StreamPool.broadcast();
@@ skipping 66 matching lines @@
       // ignore it here but don't start processing the new input. That way
       // when [process] is called, the error will be piped through its
       // return value.
     }).catchError((e) {
       // If our code above has a programmatic error, ensure it will be piped
       // through [process] by putting it into [_adjustTransformersFutures].
       _adjustTransformersFutures[node.id] = new Future.error(e);
     });
   }
 
-  /// Returns the input for this phase with the given [id], but only if that
-  /// input is known not to be consumed as a transformer's primary input.
-  ///
-  /// If the input is unavailable, or if the phase hasn't determined whether or
-  /// not any transformers will consume it as a primary input, null will be
-  /// returned instead. This means that the return value is guaranteed to always
-  /// be [AssetState.AVAILABLE].
-  AssetNode getUnconsumedInput(AssetId id) {
-    if (!_inputs.containsKey(id)) return null;
-
-    // If the asset has transforms, it's not unconsumed.
-    if (!_transforms[id].isEmpty) return null;
-
-    // If we're working on figuring out if the asset has transforms, we can't
-    // prove that it's unconsumed.
-    if (_adjustTransformersFutures.containsKey(id)) return null;
-
-    // The asset should be available. If it were removed, it wouldn't be in
-    // _inputs, and if it were dirty, it'd be in _adjustTransformersFutures.
-    assert(_inputs[id].state.isAvailable);
-    return _inputs[id];
-  }
-
   /// Gets the asset node for an input [id].
   ///
   /// If an input with that ID cannot be found, returns null.
   Future<AssetNode> getInput(AssetId id) {
     return newFuture(() {
-      // TODO(rnystrom): Need to handle passthrough where an asset from a
-      // previous phase can be found.
       if (id.package == cascade.package) return _inputs[id];
       return cascade.graph.getAssetNode(id);
     });
   }
 
   /// 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) {
       var oldTransformers = _transforms[node.id]
           .map((transform) => transform.transformer).toSet();
 
       return _removeStaleTransforms(asset)
           .then((_) => _addFreshTransforms(node, 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);
+          var passThrough = _passThroughControllers.remove(node.id);
+          if (passThrough != null) passThrough.setRemoved();
         } else {
           _adjustTransformers(node);
         }
       }).catchError((e) {
         _adjustTransformersFutures[node.id] = new Future.error(e);
       });
     }).catchError((error) {
       if (error is! AssetNotFoundException || error.id != node.id) throw error;
 
       // If the asset is removed, [tryUntilStable] will throw an
@@ skipping 45 matching lines @@
       // results.
       return transformer.isPrimary(node.asset).then((isPrimary) {
         if (!isPrimary) return;
         var transform = new TransformNode(this, transformer, node);
         _transforms[node.id].add(transform);
         _onDirtyPool.add(transform.onDirty);
       });
     }));
   }
 
+  /// Adjust whether [node] is passed through the phase unmodified, based on
+  /// whether it's consumed by other transforms in this phase.
+  ///
+  /// If [node] was already passed-through, this will update the passed-through
+  /// value.
+  void _adjustPassThrough(AssetNode node) {
+    assert(node.state.isAvailable);
+
+    if (_transforms[node.id].isEmpty) {
+      var controller = _passThroughControllers[node.id];
+      if (controller != null) {
+        controller.setAvailable(node.asset);
+      } else {
+        _passThroughControllers[node.id] =
+            new AssetNodeController.available(node.asset, node.transform);
+      }
+    } else {
+      var controller = _passThroughControllers.remove(node.id);
+      if (controller != null) controller.setRemoved();
+    }
+  }
+
   /// 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() {
     if (_adjustTransformersFutures.isEmpty) return new Future.value();
     return Future.wait(_adjustTransformersFutures.values)
         .then((_) => _waitForInputs());
   }
 
   /// Applies all currently wired up and dirty transforms.
   Future _processTransforms() {
+    if (_next == null) return;
+
+    var newPassThroughs = _passThroughControllers.values
+        .map((controller) => controller.node)
+        .where((output) {
+      return !_outputs.containsKey(output.id) ||
+        !_outputs[output.id].contains(output);
+    }).toSet();
+
     // Convert this to a list so we can safely modify _transforms while
     // iterating over it.
     var dirtyTransforms =
         flatten(_transforms.values.map((transforms) => transforms.toList()))
         .where((transform) => transform.isDirty).toList();
-    if (dirtyTransforms.isEmpty) return null;
 
-    var collisions = new Set<AssetId>();
+    if (dirtyTransforms.isEmpty && newPassThroughs.isEmpty) return null;
+
+    var collisions = _passAssetsThrough(newPassThroughs);
     return Future.wait(dirtyTransforms.map((transform) {
       return transform.apply().then((outputs) {
         for (var output in outputs) {
           if (_outputs.containsKey(output.id)) {
             _outputs[output.id].add(output);
             collisions.add(output.id);
           } else {
             _outputs[output.id] = new Queue<AssetNode>.from([output]);
             _next.addInput(output);
           }
@@ skipping 10 matching lines @@
         // while another transform was running.
         if (_outputs[collision].length <= 1) continue;
         cascade.reportError(new AssetCollisionException(
             _outputs[collision].where((asset) => asset.transform != null)
                 .map((asset) => asset.transform.info),
             collision));
       }
     });
   }
 
+  /// Pass all new assets that aren't consumed by transforms through to the next
+  /// phase.
+  ///
+  /// Returns a set of asset ids that have collisions between new passed-through
+  /// assets and pre-existing transform outputs.
+  Set<AssetId> _passAssetsThrough(Set<AssetId> newPassThroughs) {
+    var collisions = new Set<AssetId>();
+    for (var output in newPassThroughs) {
+      if (_outputs.containsKey(output.id)) {
+        // There shouldn't be another pass-through asset with the same id.
+        assert(!_outputs[output.id].any((asset) => asset.transform == null));
+
+        _outputs[output.id].add(output);
+        collisions.add(output.id);
+      } else {
+        _outputs[output.id] = new Queue<AssetNode>.from([output]);
+        _next.addInput(output);
+      }
+
+      _handleOutputRemoval(output);
+    }
+    return collisions;
+  }
+
   /// Properly resolve collisions when [output] is removed.
   void _handleOutputRemoval(AssetNode output) {
     output.whenRemoved.then((_) {
       var assets = _outputs[output.id];
       if (assets.length == 1) {
         assert(assets.single == output);
         _outputs.remove(output.id);
         return;
       }
 
@@ skipping 16 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)));
       }
     });
   }
 }