Move isPrimary computation from PhaseInput into TransformNode.

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 'asset_cascade.dart';
 import 'asset_id.dart';
@@ skipping 155 matching lines @@
   /// is called, however.
   ///
   /// This should only be used for brand-new assets or assets that have been
   /// removed and re-created. The phase will automatically handle updated assets
   /// using the [AssetNode.onStateChange] stream.
   void addInput(AssetNode node) {
     if (_inputs.containsKey(node.id)) _inputs[node.id].remove();
 
     node.force();
 
-    // Each group is one channel along which an asset may be forwarded. Then
-    // there's one additional channel for the non-grouped transformers.
-    var forwarder = new PhaseForwarder(_groups.length + 1);
+    // Each group is one channel along which an asset may be forwarded, as is
+    // each transformer.
+    var forwarder = new PhaseForwarder(
+        node, _transformers.length, _groups.length);
     _forwarders[node.id] = forwarder;
     forwarder.onAsset.listen(_handleOutputWithoutForwarder);
+    if (forwarder.output != null) {
+      _handleOutputWithoutForwarder(forwarder.output);
+    }
 
     _inputOrigins.add(node.origin);
-    var input = new PhaseInput(this, node, _transformers, "$_location.$_index");
+    var input = new PhaseInput(this, node, "$_location.$_index");
     _inputs[node.id] = input;
     input.input.whenRemoved(() {
       _inputOrigins.remove(node.origin);
       _inputs.remove(node.id);
       _forwarders.remove(node.id).remove();
       if (!isDirty) _onDoneController.add(null);
     });
     input.onAsset.listen(_handleOutput);
     _onLogPool.add(input.onLog);
     input.onDone.listen((_) {
       if (!isDirty) _onDoneController.add(null);
     });
 
+    input.updateTransformers(_transformers);
+
     for (var group in _groups.values) {
       group.addInput(node);
     }
   }
 
   // TODO(nweiz): If the input is available when this is called, it's
   // theoretically possible for it to become unavailable between the call and
   // the return. If it does so, it won't trigger the rebuilding process. To
   // avoid this, we should have this and the methods it calls take explicit
   // callbacks, as in [AssetNode.whenAvailable].
@@ skipping 31 matching lines @@
       if (id.package != cascade.package) return cascade.graph.getAssetNode(id);
       if (_outputs.containsKey(id)) {
         var output = _outputs[id].output;
         // If the requested output is available, we can just return it.
         if (output.state.isAvailable) return output;
 
         // If the requested output 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.
         output.force();
-        return output.whenAvailable((_) => output).catchError((error) {
+        return output.whenAvailable((_) {
+          return output;
+        }).catchError((error) {
           if (error is! AssetNotFoundException) throw error;
           return getOutput(id);
         });
       }
 
       // If neither this phase nor the previous phases are dirty, the requested
       // output won't be generated and we can safely return null.
       if (!isDirty) return null;
 
       // Otherwise, store a completer for the asset node. If it's generated in
@@ skipping 27 matching lines @@
       _onLogPool.add(runner.onLog);
       runner.onDone.listen((_) {
         if (!isDirty) _onDoneController.add(null);
       });
       for (var input in _inputs.values) {
         runner.addInput(input.input);
       }
     }
 
     for (var forwarder in _forwarders.values) {
-      forwarder.numChannels = _groups.length + 1;
+      forwarder.updateTransformers(_transformers.length, _groups.length);
     }
   }
 
   /// Force all [LazyTransformer]s' transforms in this phase to begin producing
   /// concrete assets.
   void forceAllTransforms() {
     for (var group in _groups.values) {
       group.forceAllTransforms();
     }
 
@@ skipping 97 matching lines @@
     assert(asset.state.isDirty);
     asset.force();
     asset.whenStateChanges().then((state) {
       if (state.isRemoved) return getOutput(asset.id);
       return asset;
     }).then(request.complete).catchError(request.completeError);
   }
 
   String toString() => "phase $_location.$_index";
 }