Run pub tests against older versions of barback.

third_party/pkg/barback-0.13.0/lib/src/asset_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.asset.asset_node;
+library barback.asset_node;
 
 import 'dart:async';
 
-import '../errors.dart';
-import '../graph/transform_node.dart';
-import '../utils.dart';
 import 'asset.dart';
 import 'asset_id.dart';
+import 'errors.dart';
+import 'transform_node.dart';
+import 'utils.dart';
 
 /// Describes the current state of an asset as part of a transformation graph.
 ///
 /// An asset node can be in one of three states (see [AssetState]). It provides
 /// an [onStateChange] stream that emits an event whenever it changes state.
 ///
 /// Asset nodes are controlled using [AssetNodeController]s.
 class AssetNode {
   /// The id of the asset that this node represents.
   final AssetId id;
@@ skipping 27 matching lines @@
   Asset _asset;
 
   /// The callback to be called to notify this asset node's creator that the
   /// concrete asset should be generated.
   ///
   /// This is null for non-lazy asset nodes (see [AssetNodeController.lazy]).
   /// Once this is called, it's set to null and [this] is no longer considered
   /// lazy.
   Function _lazyCallback;
 
-  /// Whether this node is lazy, meaning that [force] must be called to
-  /// guarantee that it will eventually become available.
-  bool get isLazy => _lazyCallback != null ||
-      (_origin != null && _origin.isLazy);
-
   /// A broadcast stream that emits an event whenever the node changes state.
   ///
   /// This stream is synchronous to ensure that when a source asset is modified
   /// or removed, the appropriate portion of the asset graph is dirtied before
   /// any [Barback.getAssetById] calls emit newly-incorrect values.
   Stream<AssetState> get onStateChange => _stateChangeController.stream;
 
   /// This is synchronous so that a source being updated will always be
   /// propagated through the build graph before anything that depends on it is
   /// requested.
@@ skipping 39 matching lines @@
   /// [callback] is called synchronously if this is already in such a state.
   ///
   /// The return value of [callback] is piped to the returned Future.
   Future _waitForState(bool test(AssetState state),
       callback(AssetState state)) {
     if (test(state)) return syncFuture(() => callback(state));
     return onStateChange.firstWhere(test).then((_) => callback(state));
   }
 
   AssetNode._(this.id, this._transform, this._origin)
-      : _state = AssetState.RUNNING;
+      : _state = AssetState.DIRTY;
 
   AssetNode._available(Asset asset, this._transform, this._origin)
       : id = asset.id,
         _asset = asset,
         _state = AssetState.AVAILABLE;
 
   AssetNode._lazy(this.id, this._transform, this._origin, this._lazyCallback)
-      : _state = AssetState.RUNNING;
+      : _state = AssetState.DIRTY;
 
   /// If [this] is lazy, force it to generate a concrete asset; otherwise, do
   /// nothing.
   ///
   /// See [AssetNodeController.lazy].
   void force() {
     if (_origin != null) {
       _origin.force();
     } else if (_lazyCallback != null) {
       _lazyCallback();
       _lazyCallback = null;
     }
   }
 
-  String toString() => "${isLazy ? 'lazy' : state} asset $id";
+  String toString() =>
+    "$state${_lazyCallback == null ? '' : ' lazy'} asset $id";
 }
 
 /// The controller for an [AssetNode].
 ///
 /// This controls which state the node is in.
 class AssetNodeController {
   final AssetNode node;
 
   /// Creates a controller for a dirty node.
   AssetNodeController(AssetId id, [TransformNode transform])
@@ skipping 26 matching lines @@
   /// If [node] is lazy, the returned node will also be lazy.
   AssetNodeController.from(AssetNode node)
       : node = new AssetNode._(node.id, node.transform, node.origin) {
     if (node.state.isAvailable) {
       setAvailable(node.asset);
     } else if (node.state.isRemoved) {
       setRemoved();
     }
   }
 
-  /// Marks the node as [AssetState.RUNNING].
+  /// Marks the node as [AssetState.DIRTY].
   void setDirty() {
     assert(node._state != AssetState.REMOVED);
+    node._state = AssetState.DIRTY;
     node._asset = null;
     node._lazyCallback = null;
-
-    // Don't re-emit a dirty event to avoid cases where we try to dispatch an
-    // event while handling another event (e.g. an output is marked lazy, which
-    // causes it to be forced, which causes it to be marked dirty).
-    if (node._state.isDirty) return;
-    node._state = AssetState.RUNNING;
-    node._stateChangeController.add(AssetState.RUNNING);
+    node._stateChangeController.add(AssetState.DIRTY);
   }
 
   /// Marks the node as [AssetState.REMOVED].
   ///
   /// Once a node is marked as removed, it can't be marked as any other state.
   /// If a new asset is created with the same id, it will get a new node.
   void setRemoved() {
     assert(node._state != AssetState.REMOVED);
     node._state = AssetState.REMOVED;
     node._asset = null;
     node._lazyCallback = null;
     node._stateChangeController.add(AssetState.REMOVED);
   }
 
   /// Marks the node as [AssetState.AVAILABLE] with the given concrete [asset].
   ///
   /// It's an error to mark an already-available node as available. It should be
   /// marked as dirty first.
   void setAvailable(Asset asset) {
     assert(asset.id == node.id);
     assert(node._state != AssetState.REMOVED);
     assert(node._state != AssetState.AVAILABLE);
     node._state = AssetState.AVAILABLE;
     node._asset = asset;
     node._lazyCallback = null;
     node._stateChangeController.add(AssetState.AVAILABLE);
   }
 
-  /// Marks the node as [AssetState.RUNNING] and lazy.
+  /// Marks the node as [AssetState.DIRTY] and lazy.
   ///
   /// Lazy nodes aren't expected to have their values generated until needed.
   /// Once it's necessary, [callback] will be called. [callback] is guaranteed
   /// to be called only once.
   ///
   /// See also [AssetNodeController.lazy].
   void setLazy(void callback()) {
     assert(node._state != AssetState.REMOVED);
-    node._state = AssetState.RUNNING;
+    node._state = AssetState.DIRTY;
     node._asset = null;
     node._lazyCallback = callback;
-    node._stateChangeController.add(AssetState.RUNNING);
+    node._stateChangeController.add(AssetState.DIRTY);
   }
 
   String toString() => "controller for $node";
 }
 
 // TODO(nweiz): add an error state.
 /// An enum of states that an [AssetNode] can be in.
 class AssetState {
   /// The node has a concrete asset loaded, available, and up-to-date. The asset
   /// is accessible via [AssetNode.asset]. An asset can only be marked available
-  /// again from the [AssetState.RUNNING] state.
+  /// again from the [AssetState.DIRTY] state.
   static final AVAILABLE = const AssetState._("available");
 
   /// The asset is no longer available, possibly for good. A removed asset will
   /// never enter another state.
   static final REMOVED = const AssetState._("removed");
 
   /// The asset will exist in the future (unless it's removed), but the concrete
   /// asset is not yet available.
-  static final RUNNING = const AssetState._("dirty");
+  static final DIRTY = const AssetState._("dirty");
 
   /// Whether this state is [AssetState.AVAILABLE].
   bool get isAvailable => this == AssetState.AVAILABLE;
 
   /// Whether this state is [AssetState.REMOVED].
   bool get isRemoved => this == AssetState.REMOVED;
 
-  /// Whether this state is [AssetState.RUNNING].
-  bool get isDirty => this == AssetState.RUNNING;
+  /// Whether this state is [AssetState.DIRTY].
+  bool get isDirty => this == AssetState.DIRTY;
 
   final String name;
 
   const AssetState._(this.name);
 
   String toString() => name;
 }