Remove PhaseInput and add TransformerSorter to barback.

pkg/barback/lib/src/transform_node.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.transform_node;
 
 import 'dart:async';
 
 import 'asset.dart';
 import 'asset_id.dart';
@@ skipping 29 matching lines @@
   final String _location;
 
   /// The subscription to [primary]'s [AssetNode.onStateChange] stream.
   StreamSubscription _primarySubscription;
 
   /// The subscription to [phase]'s [Phase.onAsset] stream.
   StreamSubscription<AssetNode> _phaseSubscription;
 
   /// How far along [this] is in processing its assets.
   NodeStatus get status {
-    if (_state == _State.NOT_PRIMARY || _state == _State.APPLIED ||
-        _state == _State.DECLARED) {
+    if (_state == _State.APPLIED || _state == _State.DECLARED) {
       return NodeStatus.IDLE;
     }
 
     if (_declaring && _state != _State.DECLARING) {
       return NodeStatus.MATERIALIZING;
     } else {
       return NodeStatus.RUNNING;
     }
   }
 
@@ skipping 61 matching lines @@
   ///
   /// This is only non-null if [transformer] is a [DeclaringTransformer] and its
   /// [declareOutputs] has been run successfully.
   Set<AssetId> _declaredOutputs;
 
   TransformNode(this.phase, Transformer transformer, AssetNode primary,
       this._location)
       : transformer = transformer,
         primary = primary {
     _forced = transformer is! DeclaringTransformer;
+    if (_forced) primary.force();
 
     _primarySubscription = primary.onStateChange.listen((state) {
       if (state.isRemoved) {
         remove();
       } else {
         if (_forced) primary.force();
         _dirty();
       }
     });
 
     _phaseSubscription = phase.previous.onAsset.listen((node) {
       if (!_missingInputs.contains(node.id)) return;
       if (_forced) node.force();
       _dirty();
     });
 
-    _isPrimary();
+    _declareOutputs().then((_) {
+      if (_forced || _canRunDeclaringEagerly) {
+        _apply();
+      } else {
+        _state = _State.DECLARED;
+        _streams.changeStatus(NodeStatus.IDLE);
+      }
+    });
   }
 
   /// The [TransformInfo] describing this node.
   ///
   /// [TransformInfo] is the publicly-visible representation of a transform
   /// node.
   TransformInfo get info => new TransformInfo(transformer, primary.id);
 
   /// Marks this transform as removed.
   ///
@@ skipping 19 matching lines @@
     if (_forced || _state == _State.APPLIED) return;
     primary.force();
     _forced = true;
     if (_state == _State.DECLARED) _dirty();
   }
 
   /// Marks this transform as dirty.
   ///
   /// This causes all of the transform's outputs to be marked as dirty as well.
   void _dirty() {
-    if (_state == _State.NOT_PRIMARY) {
-      _emitPassThrough();
-      return;
-    }
-
-    // If we're in the process of running [isPrimary] or [declareOutputs], we
-    // already know that [apply] needs to be run so there's nothing we need to
-    // mark as dirty.
+    // If we're in the process of running [declareOutputs], we already know that
+    // [apply] needs to be run so there's nothing we need to mark as dirty.
     if (_state == _State.DECLARING) return;
 
     if (!_forced && !_canRunDeclaringEagerly) {
       // [forced] should only ever be false for a declaring transformer.
       assert(_declaring);
 
       // If we've finished applying, transition to MATERIALIZING, indicating
       // that we know what outputs [apply] will emit but we're waiting to emit
       // them concretely until [force] is called. If we're still applying, we'll
       // transition to MATERIALIZING once we finish.
@@ skipping 13 matching lines @@
     if (_state == _State.APPLIED) {
       if (_declaredOutputs != null) _emitDeclaredOutputs();
       _apply();
     } else if (_state == _State.DECLARED) {
       _apply();
     } else {
       _state = _State.NEEDS_APPLY;
     }
   }
 
-  /// Runs [transformer.isPrimary] and adjusts [this]'s state according to the
-  /// result.
-  ///
-  /// This will also run [_declareOutputs] and/or [_apply] as appropriate.
-  void _isPrimary() {
-    syncFuture(() => transformer.isPrimary(primary.id))
-        .catchError((error, stackTrace) {
-      if (_isRemoved) return false;
-
-      // Catch all transformer errors and pipe them to the results stream. This
-      // is so a broken transformer doesn't take down the whole graph.
-      phase.cascade.reportError(_wrapException(error, stackTrace));
-
-      return false;
-    }).then((isPrimary) {
-      if (_isRemoved) return null;
-      if (isPrimary) {
-        if (_forced) primary.force();
-        return _declareOutputs().then((_) {
-          if (_isRemoved) return;
-          if (_forced || _canRunDeclaringEagerly) {
-            _apply();
-          } else {
-            _state = _State.DECLARED;
-            _streams.changeStatus(NodeStatus.IDLE);
-          }
-        });
-      }
-
-      _emitPassThrough();
-      _state = _State.NOT_PRIMARY;
-      _streams.changeStatus(NodeStatus.IDLE);
-    });
-  }
-
   /// Runs [transform.declareOutputs] and emits the resulting assets as dirty
   /// assets.
   Future _declareOutputs() {
     if (transformer is! DeclaringTransformer) return new Future.value();
 
     var controller = new DeclaringTransformController(this);
     return syncFuture(() {
       return (transformer as DeclaringTransformer)
           .declareOutputs(controller.transform);
     }).then((_) {
@@ skipping 235 matching lines @@
         new LogEntry(info, primary.id, LogLevel.WARNING, message, null));
   }
 
   String toString() =>
       "transform node in $_location for $transformer on $primary ($_state, "
       "$status, ${_forced ? '' : 'un'}forced)";
 }
 
 /// The enum of states that [TransformNode] can be in.
 class _State {
-  /// The transform is running [Transformer.isPrimary] followed by
-  /// [DeclaringTransformer.declareOutputs] (for a [DeclaringTransformer]).
+  /// The transform is running [DeclaringTransformer.declareOutputs].
   ///
   /// This is the initial state of the transformer, and it will only occur once
-  /// since [Transformer.isPrimary] and [DeclaringTransformer.declareOutputs]
-  /// are independent of the contents of the primary input. Once the two methods
-  /// finish running, this will transition to [NOT_PRIMARY] if the input isn't
-  /// primary, [DECLARED] if the transform is deferred, and [APPLYING]
-  /// otherwise.
-  static final DECLARING = const _State._("computing isPrimary");
+  /// since [DeclaringTransformer.declareOutputs] is independent of the contents
+  /// of the primary input. Once the method finishes running, this will
+  /// transition to [APPLYING] if the transform is non-lazy and the input is
+  /// available, and [DECLARED] otherwise.
+  ///
+  /// Non-declaring transformers will transition out of this state and into
+  /// [APPLYING] immediately.
+  static final DECLARING = const _State._("declaring outputs");
 
   /// The transform is deferred and has run
   /// [DeclaringTransformer.declareOutputs] but hasn't yet been forced.
   ///
   /// This will transition to [APPLYING] when one of the outputs has been
   /// forced.
   static final DECLARED = const _State._("declared");
 
   /// The transform is running [Transformer.apply].
   ///
@@ skipping 13 matching lines @@
   /// emitted an error.
   ///
   /// If the transformer is deferred, the [TransformNode] can also be in this
   /// state when [Transformer.declareOutputs] has been run but
   /// [Transformer.apply] has not.
   ///
   /// If an input changes, this will transition to [DECLARED] if the transform
   /// is deferred and [APPLYING] otherwise.
   static final APPLIED = const _State._("applied");
 
-  /// The transform has finished running [Transformer.isPrimary], which returned
-  /// `false`.
-  ///
-  /// This will never transition to another state.
-  static final NOT_PRIMARY = const _State._("not primary");
-
   final String name;
 
   const _State._(this.name);
 
   String toString() => name;
 }