Tracking changes between start and end

lib/src/core/context.dart

@@ -55,6 +55,21 @@ class ReactiveContext {
     }
   }
 
+  Derivation startTracking(Derivation derivation) {
+    final prevDerivation = _state.trackingDerivation;
+    _state.trackingDerivation = derivation;
+
+    resetDerivationState(derivation);
+    derivation.newObservables = Set();
+
+    return prevDerivation;
+  }
+
+  void endTracking(Derivation currentDerivation, Derivation prevDerivation) {
+    _state.trackingDerivation = prevDerivation;
+    bindDependencies(currentDerivation);
+  }
+
   T trackDerivation<T>(Derivation d, T Function() fn) {
     final prevDerivation = _state.trackingDerivation;
     _state.trackingDerivation = d;

lib/src/core/reaction.dart

@@ -2,6 +2,29 @@ import 'package:mobx/src/core/atom.dart';
 import 'package:mobx/src/core/context.dart';
 import 'package:mobx/src/core/derivation.dart';
 
+class TrackingReaction extends Reaction {
+  TrackingReaction(ReactiveContext context, Function() onInvalidate,
+      {String name})
+      : super(context, onInvalidate, name: name);
+
+  Derivation startTracking() {
+    _context.startBatch();
+    _isRunning = true;
+    return _context.startTracking(this);
+  }
+
+  void endTracking(Derivation previous) {
+    _context.endTracking(this, previous);
+    _isRunning = false;
+
+    if (_isDisposed) {
+      _context.clearObservables(this);
+    }
+
+    _context.endBatch();
+  }
+}
+
 class Reaction implements Derivation {
   Reaction(this._context, Function() onInvalidate, {this.name}) {
     _onInvalidate = onInvalidate;

lib/src/core/tracking.dart

@@ -0,0 +1,40 @@
+import 'package:meta/meta.dart';
+import 'package:mobx/src/core/context.dart';
+import 'package:mobx/src/core/derivation.dart';
+import 'package:mobx/src/core/reaction.dart';
+
+/// Tracks changes that happen between [Tracking.begin] and [Tracking.end].
+///
+/// This should only be used in situations where it is not possible to
+/// track changes inside a callback function.
+@experimental
+class Tracking {
+  Tracking.begin(ReactiveContext context, Function() onInvalidate,
+      {String name})
+      : assert(context != null),
+        assert(onInvalidate != null),
+        assert(name != ''),
+        _reaction = TrackingReaction(context, onInvalidate,
+            name: name ?? context.nameFor('Transaction')) {
+    _prevDerivation = _reaction.startTracking();
+  }
+
+  final TrackingReaction _reaction;
+  Derivation _prevDerivation;
+  bool _ended = false;
+
+  void end() {
+    if (_ended) {
+      return;
+    }
+
+    _ended = true;
+    _reaction.endTracking(_prevDerivation);
+    _prevDerivation = null;
+  }
+
+  void dispose() {
+    end();
+    _reaction.dispose();
+  }
+}

pubspec.yaml

@@ -7,6 +7,7 @@ homepage: https://github.com/mobxjs/mobx.dart
 
 environment:
   sdk: '>=2.1.0-dev <3.0.0'
+  meta: ^1.1.7
 
 dev_dependencies:
   test: ^1.5.1

test/all.dart

@@ -6,6 +6,7 @@ import 'listenable_test.dart' as listenable_test;
 import 'observable_test.dart' as observable_test;
 import 'observe_test.dart' as observe_test;
 import 'reaction_test.dart' as reaction_test;
+import 'tracking.dart' as tracking_test;
 import 'when_test.dart' as when_test;
 
 void main() {
@@ -18,4 +19,5 @@ void main() {
   observe_test.main();
   intercept_test.main();
   listenable_test.main();
+  tracking_test.main();
 }

test/tracking.dart

@@ -0,0 +1,57 @@
+import 'package:mobx/mobx.dart';
+import 'package:mobx/src/api/context.dart';
+import 'package:mobx/src/core/tracking.dart';
+import 'package:test/test.dart';
+
+void main() {
+  test('Tracking reacts to changes to reactive values between begin and end',
+      () {
+    final var1 = observable(0);
+    final var2 = observable(0);
+    var i = 0;
+
+    final tracking = Tracking.begin(currentContext, () {
+      i++;
+    });
+    final var3 = observable(0);
+    var1.value;
+    tracking.end();
+
+    // No changes, no calls to onInvalidate
+    expect(i, equals(0));
+
+    // Change outside tracking, no onInvalidate call
+    var2.value += 1;
+    expect(i, equals(0));
+
+    // Change outside tracking to an observable created inside tracking
+    // no onInvalidate call
+    var3.value += 1;
+    expect(i, equals(0));
+
+    // Changing a value that was read when tracking was active
+    // calls onInvalidate
+    var1.value += 1;
+    expect(i, equals(1));
+
+    // No calls to onInvalidate after first change
+    var1.value += 1;
+    expect(i, equals(1));
+  });
+
+  test("disposed Tracking doesn't call onInvalidate", () {
+    final var1 = observable(0);
+
+    var i = 0;
+    final tracking = Tracking.begin(currentContext, () {
+      i++;
+    });
+    var1.value;
+    tracking
+      ..end()
+      ..dispose();
+
+    var1.value += 1;
+    expect(i, equals(0));
+  });
+}