Add support for transformer clusters to barback.

pkg/barback/lib/src/asset_cascade.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.asset_cascade;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'asset.dart';
@@ skipping 81 matching lines @@
   /// A future that completes when the currently running build process finishes.
   ///
   /// If no build it in progress, is `null`.
   Future _processDone;
 
   /// Whether any source assets have been updated or removed since processing
   /// last began.
   var _newChanges = false;
 
   /// Returns all currently-available output assets from this cascade.
-  AssetSet get availableOutputs => _phases.last.availableOutputs;
+  AssetSet get availableOutputs =>
+    new AssetSet.from(_phases.last.availableOutputs.map((node) => node.asset));
 
   /// Creates a new [AssetCascade].
   ///
   /// It loads source assets within [package] using [provider].
   AssetCascade(this.graph, this.package) {
     _onDirtyPool.add(_onDirtyController.stream);
     _addPhase(new Phase(this, []));
   }
 
   /// Gets the asset identified by [id].
@@ skipping 69 matching lines @@
     removed.forEach((id) {
       // If the source was being loaded, cancel that load.
       if (_loadingSources.containsKey(id)) _loadingSources.remove(id).cancel();
 
       var controller = _sourceControllerMap.remove(id);
       // Don't choke if an id is double-removed for some reason.
       if (controller != null) controller.setRemoved();
     });
   }
 
-  /// Sets this cascade's transformer phases to [transformers].
-  void updateTransformers(Iterable<Iterable<Transformer>> transformers) {
-    transformers = transformers.toList();
+  /// Sets this cascade's operator phases to [operators].
+  void updateOperators(Iterable<Iterable<Operator>> operators) {
+    operators = operators.toList();
 
-    for (var i = 0; i < transformers.length; i++) {
+    for (var i = 0; i < operators.length; i++) {
       if (_phases.length > i) {
-        _phases[i].updateTransformers(transformers[i]);
+        _phases[i].updateOperators(operators[i]);
         continue;
       }
 
-      _addPhase(_phases.last.addPhase(transformers[i]));
+      _addPhase(_phases.last.addPhase(operators[i]));
     }
 
-    if (transformers.length == 0) {
-      _phases.last.updateTransformers([]);
-    } else if (transformers.length < _phases.length) {
-      _phases[transformers.length - 1].removeFollowing();
-      _phases.removeRange(transformers.length, _phases.length);
+    if (operators.length == 0) {
+      _phases.last.updateOperators([]);
+    } else if (operators.length < _phases.length) {
+      _phases[operators.length - 1].removeFollowing();
+      _phases.removeRange(operators.length, _phases.length);
     }
   }
 
   void reportError(BarbackException error) {
     _accumulatedErrors.add(error);
     _errorsController.add(error);
   }
 
   /// Add [phase] to the end of [_phases] and watch its [onDirty] stream.
   void _addPhase(Phase phase) {
@@ skipping 56 matching lines @@
 
         // Otherwise, everything is done.
         return;
       }
 
       // Process that phase and then loop onto the next.
       return future.then((_) => _process());
     });
   }
 }