Remove the transformless phase from AssetCascade.

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 16 matching lines @@
 ///
 /// Building can be interrupted between phases. For example, a source is added
 /// which starts the background process. Sometime during, say, phase 2 (which
 /// 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;
 
-  /// This phase's position relative to the other phases. Zero-based.
-  final int _index;
-
   /// The transformers that can access [inputs].
   ///
   /// Their outputs will be available to the next phase.
   final List<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>();
@@ skipping 51 matching lines @@
   /// 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(this.cascade, this._index, this._transformers, this._next) {
+  Phase(this.cascade, this._transformers, this._next) {
     _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 51 matching lines @@
   /// 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(() {
       if (id.package == cascade.package) return _inputs[id];
       return cascade.graph.getAssetNode(id);
     });
   }
 
+  /// Gets the asset node for an output [id].
+  ///
+  /// 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;
+    });
+  }
+
+  /// 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));
+  }

[Bob Nystrom, 2013/08/19 20:46:36]

Nit, but I think we generally put getters above the constructor?

[nweiz, 2013/08/20 00:26:26]

Done.

+
   /// 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.
@@ skipping 123 matching lines @@
   }
 
   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 && newPassThroughs.isEmpty) return null;
 
-    var collisions = _passAssetsThrough(newPassThroughs);
+    var collisions = new Set<AssetId>();
+    for (var output in newPassThroughs) {
+      if (_addOutput(output)) collisions.add(output.id);
+    }
+
     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);
-          }
-
-          _handleOutputRemoval(output);
+          if (_addOutput(output)) collisions.add(output.id);
         }
       });
     })).then((_) {
       // Report collisions in a deterministic order.
       collisions = collisions.toList();
       collisions.sort((a, b) => a.compareTo(b));
       for (var collision in collisions) {
         // Ensure that there's still a collision. It's possible it was resolved
         // 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.
+  /// Add [output] as an output of this phase, forwarding it to the next phase
+  /// if necessary.
   ///
-  /// 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));
+  /// Returns whether or not [output] collides with another pre-existing output.
+  bool _addOutput(AssetNode output) {
+    _handleOutputRemoval(output);
 
-        _outputs[output.id].add(output);
-        collisions.add(output.id);
-      } else {
-        _outputs[output.id] = new Queue<AssetNode>.from([output]);
-        _next.addInput(output);
-      }
+    if (_outputs.containsKey(output.id)) {
+      _outputs[output.id].add(output);
+      return true;
+    }
 
-      _handleOutputRemoval(output);
-    }
-    return collisions;
+    _outputs[output.id] = new Queue<AssetNode>.from([output]);
+    if (_next != null) _next.addInput(output);
+    return false;
   }
 
   /// 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;
       }
 
       // If there was more than one asset, we're resolving a collision --
       // possibly partially.
       var wasFirst = assets.first == output;
       assets.remove(output);
 
       // If this was the first asset, we need to pass the next asset
       // (chronologically) to the next phase. Pump the event queue first to give
       // [_next] a chance to handle the removal of its input before getting a
       // new input.
-      if (wasFirst) {
+      if (wasFirst && _next != null) {
         newFuture(() => _next.addInput(assets.first));
       }
 
       // If there's still a collision, report it. This lets the user know
       // if they've successfully resolved the collision or not.
       if (assets.length > 1) {
         // 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)));
       }
     });
   }
 }