Rename several classes in barback.

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.dart';
-import 'asset_graph.dart';
+import 'asset_cascade.dart';
 import 'asset_id.dart';
 import 'asset_node.dart';
 import 'asset_set.dart';
 import 'errors.dart';
 import 'transform_node.dart';
 import 'transformer.dart';
 
-/// One phase in the ordered series of transformations in an [AssetGraph].
+/// One phase in the ordered series of transformations in an [AssetCascade].
 ///
 /// Each phase can access outputs from previous phases and can in turn pass
 /// outputs to later phases. Phases are processed strictly serially. All
 /// transforms in a phase will be complete before moving on to the next phase.
 /// Within a single phase, all transforms will be run in parallel.
 ///
 /// 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 graph that owns this phase.
-  final AssetGraph graph;
+  /// 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.
@@ skipping 14 matching lines @@
   ///
   /// When we process, we'll check these to see if we can hang new transforms
   /// off them.
   final _newInputs = new Set<AssetNode>();
 
   /// The phase after this one.
   ///
   /// Outputs from this phase will be passed to it.
   final Phase _next;
 
-  Phase(this.graph, this._index, this._transformers, this._next);
+  Phase(this.cascade, this._index, this._transformers, this._next);
 
   /// Updates the phase's inputs with [updated] and removes [removed].
   ///
   /// This marks any affected [transforms] as dirty or discards them if their
   /// inputs are removed.
   void updateInputs(AssetSet updated, Set<AssetId> removed) {
     // Remove any nodes that are no longer being output. Handle removals first
     // in case there are assets that were removed by one transform but updated
     // by another. In that case, the update should win.
     for (var id in removed) {
@@ skipping 92 matching lines @@
         // Track any assets no longer output by this transform. We don't
         // handle the case where *another* transform generates the asset
         // no longer generated by this one. updateInputs() handles that.
         removed.addAll(outputs.removed);
       }
 
       // Report any collisions in deterministic order.
       collisions = collisions.toList();
       collisions.sort((a, b) => a.toString().compareTo(b.toString()));
       for (var collision in collisions) {
-        graph.reportError(new AssetCollisionException(collision));
+        cascade.reportError(new AssetCollisionException(collision));
         // TODO(rnystrom): Define what happens after a collision occurs.
       }
 
       // Pass the outputs to the next phase.
       _next.updateInputs(updated, removed);
     });
   }
 }