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.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);
     _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;
+      var output = _outputs[id].output;
+      output.force();
+      return output;
     });
   }
 
   /// 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;
     }
   }
 
+  /// Force all [LazyTransformer]s' transforms in this phase to begin producing
+  /// concrete assets.
+  void forceAllTransforms() {
+    for (var group in _groups.values) {
+      group.forceAllTransforms();
+    }
+
+    for (var input in _inputs.values) {
+      input.forceAllTransforms();
+    }
+  }
+
   /// 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);
     }
   }
 }