Add support for lazy transformers.

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 118 matching lines @@
   /// 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.
   ///
   /// 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.materialize();

[Bob Nystrom, 2014/01/30 19:33:44]

Why is this being materialized?

[nweiz, 2014/01/31 03:43:27]

The phase needs its inputs to be available if it's going to process them. A
future CL will make it so that lazy assets are piped through dry run
transformers correctly, which will make this materialization happen closer to
where it's specifically needed.

+
     // 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);
     _forwarders[node.id] = forwarder;
     forwarder.onForwarding.listen((asset) {
       _addOutput(asset);
 
       var exception = _outputs[asset.id].collisionException;
       if (exception != null) cascade.reportError(exception);
     });
@@ skipping 26 matching lines @@
     });
   }
 
   /// 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].output;
+      return _outputs[id].output..materialize();

[Bob Nystrom, 2014/01/30 19:33:44]

Nit, but I'm really not a fan of using a single cascade just to get back to the
original receiver.

[nweiz, 2014/01/31 03:43:27]

I think it's nicer than making a variable, but okay.

     });
   }
 
   /// Set this phase's transformers to [transformers].
   void updateTransformers(Iterable transformers) {
     _onDirtyController.add(null);
 
     var actualTransformers = transformers.where((op) => op is Transformer);
     _transformers.clear();
     _transformers.addAll(actualTransformers);
@@ skipping 16 matching lines @@
       for (var input in _inputs.values) {
         runner.addInput(input.input);
       }
     }
 
     for (var forwarder in _forwarders.values) {
       forwarder.numChannels = _groups.length + 1;
     }
   }
 
+  /// Materialize all [LazyTransformer]s' transforms in this group.
+  void materializeAllTransforms() {
+    for (var group in _groups.values) {
+      group.materializeAllTransforms();
+    }
+
+    for (var input in _inputs.values) {
+      input.materializeAllTransforms();
+    }
+  }
+
   /// 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 transformers) {
     assert(_next == null);
     _next = new Phase(cascade, transformers);
     for (var output in _outputs.values.toList()) {
       // Remove [output]'s listeners because now they should get the asset from
       // [_next], rather than this phase. Any transforms consuming [output] will
       // be re-run and will consume the output from the new final phase.
@@ skipping 74 matching lines @@
       _outputs[asset.id].add(asset);
     } else {
       _outputs[asset.id] = new PhaseOutput(this, asset);
       _outputs[asset.id].onAsset.listen((output) {
         if (_next != null) _next.addInput(output);
       }, onDone: () => _outputs.remove(asset.id));
       if (_next != null) _next.addInput(_outputs[asset.id].output);
     }
   }
 }