Support cross-package transforms 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_cascade.dart';
@@ skipping 27 matching lines @@
 
   /// 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.
   ///
   /// For the first phase, these will be the source assets. For all other
   /// phases, they will be the outputs from the previous phase.
-  final inputs = new Map<AssetId, AssetNode>();
+  final _inputs = new Map<AssetId, AssetNode>();
 
   /// The transforms currently applicable to assets in [inputs], indexed by
   /// the ids of their primary inputs.
   ///
   /// These are the transforms that have been "wired up": they represent a
   /// repeatable transformation of a single concrete set of inputs. "dart2js"
   /// is a transformer. "dart2js on web/main.dart" is a transform.
   final _transforms = new Map<AssetId, Set<TransformNode>>();
 
   /// Futures that will complete once the transformers that can consume a given
@@ skipping 50 matching lines @@
   ///
   /// 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) {
     // We remove [node.id] from [inputs] as soon as the node is removed rather
     // than at the same time [node.id] is removed from [_transforms] so we don't
     // have to wait on [_adjustTransformers]. It's important that [inputs] is
     // always up-to-date so that the [AssetCascade] can look there for available
     // assets.
-    inputs[node.id] = node;
-    node.whenRemoved.then((_) => inputs.remove(node.id));
+    _inputs[node.id] = node;
+    node.whenRemoved.then((_) => _inputs.remove(node.id));
 
     if (!_adjustTransformersFutures.containsKey(node.id)) {
       _transforms[node.id] = new Set<TransformNode>();
       _adjustTransformers(node);
       return;
     }
 
     // If an input is added while the same input is still being processed,
     // that means that the asset was removed and recreated while
     // [_adjustTransformers] was being run on the old value. We have to wait
@@ skipping 28 matching lines @@
   }
 
   /// Returns the input for this phase with the given [id], but only if that
   /// input is known not to be consumed as a transformer's primary input.
   ///
   /// If the input is unavailable, or if the phase hasn't determined whether or
   /// not any transformers will consume it as a primary input, null will be
   /// returned instead. This means that the return value is guaranteed to always
   /// be [AssetState.AVAILABLE].
   AssetNode getUnconsumedInput(AssetId id) {
-    if (!inputs.containsKey(id)) return null;
+    if (!_inputs.containsKey(id)) return null;
 
     // If the asset has transforms, it's not unconsumed.
     if (!_transforms[id].isEmpty) return null;
 
     // If we're working on figuring out if the asset has transforms, we can't
     // prove that it's unconsumed.
     if (_adjustTransformersFutures.containsKey(id)) return null;
 
     // The asset should be available. If it were removed, it wouldn't be in
     // _inputs, and if it were dirty, it'd be in _adjustTransformersFutures.
-    assert(inputs[id].state.isAvailable);
-    return inputs[id];
+    assert(_inputs[id].state.isAvailable);
+    return _inputs[id];
+  }
+
+  /// Gets the asset node for an input [id].
+  ///
+  /// If an input with that ID cannot be found, throws an
+  /// [AssetNotFoundException].
+  Future<AssetNode> getInput(AssetId id) {
+    return newFuture(() {
+      // TODO(rnystrom): Need to handle passthrough where an asset from a
+      // previous phase can be found.
+      if (id.package == cascade.package) return _inputs[id];

[Bob Nystrom, 2013/08/07 22:00:08]

Can this ever return null? If not, why not? Maybe add an assert?

[nweiz, 2013/08/07 22:59:15]

It can. The doc comment is inaccurate. I'll fix it.

I'll also make [AssetCascade.getAssetNode] and [PackageGraph.getAssetNode] do
the same thing.

+      return cascade.graph.getAssetNode(id);
+    });
   }
 
   /// Asynchronously determines which transformers can consume [node] as a
   /// primary input and creates transforms for them.
   ///
   /// This ensures that if [node] is modified or removed during or after the
   /// time it takes to adjust its transformers, they're appropriately
   /// re-adjusted. Its progress can be tracked in [_adjustTransformersFutures].
   void _adjustTransformers(AssetNode node) {
     // Mark the phase as dirty. This may not actually end up creating any new
@@ skipping 124 matching lines @@
       // Report collisions in a deterministic order.
       collisions = collisions.toList();
       collisions.sort((a, b) => a.toString().compareTo(b.toString()));
       for (var collision in collisions) {
         cascade.reportError(new AssetCollisionException(collision));
         // TODO(rnystrom): Define what happens after a collision occurs.
       }
     });
   }
 }