Support cross-package transforms in 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 'package:stack_trace/stack_trace.dart';
-
 import 'asset.dart';
 import 'asset_id.dart';
 import 'asset_node.dart';
+import 'build_result.dart';
 import 'cancelable_future.dart';
 import 'errors.dart';
 import 'change_batch.dart';
 import 'package_graph.dart';
 import 'phase.dart';
 import 'transformer.dart';
 import 'utils.dart';
 
 /// The asset cascade for an individual package.
 ///
 /// This keeps track of which [Transformer]s are applied to which assets, and
 /// re-runs those transformers when their dependencies change. The transformed
-/// assets are accessible via [getAssetById].
+/// asset nodes are accessible via [getAssetNode].
 ///
 /// A cascade consists of one or more [Phases], each of which has one or more
 /// [Transformer]s that run in parallel, potentially on the same inputs. The
 /// inputs of the first phase are the source assets for this cascade's package.
 /// The inputs of each successive phase are the outputs of the previous phase,
 /// as well as any assets that haven't yet been transformed.
 class AssetCascade {
   /// The name of the package whose assets are managed.
   final String package;
 
   /// The [PackageGraph] that tracks all [AssetCascade]s for all dependencies of
   /// the current app.
-  final PackageGraph _graph;
+  final PackageGraph graph;
 
   /// The controllers for the [AssetNode]s that provide information about this
   /// cascade's package's source assets.
   final _sourceControllerMap = new Map<AssetId, AssetNodeController>();
 
   /// Futures for source assets that are currently being loaded.
   ///
   /// These futures are cancelable so that if an asset is updated after a load
   /// has been kicked off, the previous load can be ignored in favor of a new
   /// one.
@@ skipping 31 matching lines @@
 
   /// Whether any source assets have been updated or removed since processing
   /// last began.
   var _newChanges = false;
 
   /// Creates a new [AssetCascade].
   ///
   /// It loads source assets within [package] using [provider] and then uses
   /// [transformerPhases] to generate output files from them.
   //TODO(rnystrom): Better way of specifying transformers and their ordering.
-  AssetCascade(this._graph, this.package,
+  AssetCascade(this.graph, this.package,
       Iterable<Iterable<Transformer>> transformerPhases) {
     // Flatten the phases to a list so we can traverse backwards to wire up
     // each phase to its next.
     var phases = transformerPhases.toList();
 
     // Each phase writes its outputs as inputs to the next phase after it.
     // Add a phase at the end for the final outputs of the last phase.
     phases.add([]);
 
     Phase nextPhase = null;
     for (var transformers in phases.reversed) {
       nextPhase = new Phase(this, _phases.length, transformers.toList(),
           nextPhase);
       nextPhase.onDirty.listen((_) {
         _newChanges = true;
         _waitForProcess();
       });
       _phases.insert(0, nextPhase);
     }
   }
 
   /// Gets the asset identified by [id].
   ///
-  /// If [id] is for a generated or transformed asset, this will wait until
-  /// it has been created and return it. If the asset cannot be found, throws
-  /// [AssetNotFoundException].
-  Future<Asset> getAssetById(AssetId id) {
+  /// If [id] is for a generated or transformed asset, this will wait until it
+  /// has been created and return it. If the asset cannot be found, returns
+  /// null.
+  Future<AssetNode> getAssetNode(AssetId id) {
     assert(id.package == package);
 
     // TODO(rnystrom): Waiting for the entire build to complete is unnecessary
     // in some cases. Should optimize:
     // * [id] may be generated before the compilation is finished. We should
     //   be able to quickly check whether there are any more in-place
     //   transformations that can be run on it. If not, we can return it early.
     // * If [id] has never been generated and all active transformers provide
     //   metadata about the file names of assets it can emit, we can prove that
     //   none of them can emit [id] and fail early.
     return newFuture(() {
       var node = _getAssetNode(id);
 
       // If the requested asset is available, we can just return it.
-      if (node != null) return node.asset;
+      if (node != null) return node;
 
       // If there's a build running, that build might generate the asset, so we
       // wait for it to complete and then try again.
       if (_processDone != null) {
-        return _processDone.then((_) => getAssetById(id));
+        return _processDone.then((_) => getAssetNode(id));
       }
 
       // If the asset hasn't been built and nothing is building now, the asset
-      // won't be generated, so we throw an error.
-      throw new AssetNotFoundException(id);
+      // won't be generated, so we return null.
+      return null;
     });
   }
 
   // Returns the post-transformation asset node for [id], if one is available.
   //
   // This will only return a node that has an asset available, and only if that
   // node is guaranteed not to be consumed by any transforms. If the phase is
   // still working to figure out if a node will be consumed by a transformer,
   // that node won't be returned.
   AssetNode _getAssetNode(AssetId id) {
@@ skipping 21 matching lines @@
       } else {
         _sourceControllerMap[id] = new AssetNodeController(id);
         _phases.first.addInput(_sourceControllerMap[id].node);
       }
 
       // If this source was already loading, cancel the old load, since it may
       // return out-of-date contents for the asset.
       if (_loadingSources.containsKey(id)) _loadingSources[id].cancel();
 
       _loadingSources[id] =
-          new CancelableFuture<Asset>(_graph.provider.getAsset(id));
+          new CancelableFuture<Asset>(graph.provider.getAsset(id));
       _loadingSources[id].whenComplete(() {
         _loadingSources.remove(id);
       }).then((asset) {
         var controller = _sourceControllerMap[id].setAvailable(asset);
       }).catchError((error) {
         reportError(error);
 
         // TODO(nweiz): propagate error information through asset nodes.
         _sourceControllerMap.remove(id).setRemoved();
       });
@@ skipping 68 matching lines @@
 
         // Otherwise, everything is done.
         return;
       }
 
       // Process that phase and then loop onto the next.
       return future.then((_) => _process());
     });
   }
 }
-
-/// An event indicating that the cascade has finished building all assets.
-///
-/// A build can end either in success or failure. If there were no errors during
-/// the build, it's considered to be a success; any errors render it a failure,
-/// although individual assets may still have built successfully.
-class BuildResult {
-  /// All errors that occurred during the build.
-  final List errors;
-
-  /// `true` if the build succeeded.
-  bool get succeeded => errors.isEmpty;
-
-  BuildResult(Iterable errors)
-      : errors = errors.toList();
-
-  /// Creates a build result indicating a successful build.
-  ///
-  /// This equivalent to a build result with no errors.
-  BuildResult.success()
-      : this([]);
-
-  String toString() {
-    if (succeeded) return "success";
-
-    return "errors:\n" + errors.map((error) {
-      var stackTrace = getAttachedStackTrace(error);
-      if (stackTrace != null) stackTrace = new Trace.from(stackTrace);
-
-      var msg = new StringBuffer();
-      msg.write(prefixLines(error.toString()));
-      if (stackTrace != null) {
-        msg.write("\n\n");
-        msg.write("Stack trace:\n");
-        msg.write(prefixLines(stackTrace.toString()));
-      }
-      return msg.toString();
-    }).join("\n\n");
-  }
-}