implement dirty checking for @observable objects

pkg/observe/lib/src/watcher.dart

Index: pkg/observe/lib/src/watcher.dart
diff --git a/pkg/observe/lib/src/watcher.dart b/pkg/observe/lib/src/watcher.dart
new file mode 100644
index 0000000000000000000000000000000000000000..63bd89a5ef166fe1307f75710b96002abba1aff3
--- /dev/null
+++ b/pkg/observe/lib/src/watcher.dart
@@ -0,0 +1,68 @@
+// 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.
+
+/**
+ * *Warning*: this library is **internal**, and APIs are subject to change.
+ *
+ * Tracks observable objects for dirty checking and testing purposes.
+ *
+ * It can collect all observed objects, which can be used to trigger predictable
+ * delivery of all pending changes in a test, including objects allocated
+ * internally to another library, such as those in `package:mdv`.
+ */
+library observe.src.watcher;
+
+import 'package:observe/observe.dart' show Observable;
+
+/** The number of active observables in the system. */
+int get allObservablesCount => _allObservablesCount;

[Siggi Cherem (dart-lang), 2013/07/22 21:47:22]

could we simply use _allObservables.length here or you have this to make sure
you don't show numbers in between while you are cycling through the
dirty-checks?

[Jennifer Messerly, 2013/07/22 21:55:11]

I think that's the idea, yeah. Keeps it consistently correct.

+
+int _allObservablesCount = 0;
+
+List<Observable> _allObservables = null;
+
+bool _delivering = false;
+
+void registerObservable(Observable obj) {
+  if (_allObservables == null) _allObservables = <Observable>[];
+  _allObservables.add(obj);
+  _allObservablesCount++;
+}
+
+/**
+ * Synchronously deliver all change records for known observables.
+ *
+ * This will execute [Observable.deliverChanges] on objects that inherit from
+ * [ObservableMixin].
+ */
+// Note: this is called performMicrotaskCheckpoint in change_summary.js.
+void dirtyCheckObservables() {
+  if (_delivering) return;
+  if (_allObservables == null) return;
+
+  _delivering = true;
+
+  int cycles = 0;
+  bool anyChanged = false;
+  do {
+    cycles++;
+    var toCheck = _allObservables;
+    _allObservables = <Observable>[];
+    anyChanged = false;
+
+    for (final observer in toCheck) {
+      if (observer.hasObservers) {
+        anyChanged = anyChanged || observer.deliverChanges();

[Siggi Cherem (dart-lang), 2013/07/22 21:47:22]

I thought you were going to deliverChanges regardless:

anyChanged = observer.deliverChanges() || anyChanged;

otherwise there is only 1 delivery per cycle?

[Jennifer Messerly, 2013/07/22 22:38:39]

gooooood catch! Totally messed that up when refactoring it.

+        _allObservables.add(observer);
+      }
+    }
+  } while (cycles < _MAX_DIRTY_CHECK_CYCLES && anyChanged);
+
+  // TODO(jmesserly): warn if limit is reached?

[Siggi Cherem (dart-lang), 2013/07/22 21:47:22]

+1, might be worth adding a simple print for now.

[Jennifer Messerly, 2013/07/22 21:55:11]

or logging? :)

[Siggi Cherem (dart-lang), 2013/07/22 21:57:25]

sure =)

[Jennifer Messerly, 2013/07/22 22:38:39]

added logging. also it prints object index and toString, which hopefully helps
when in debugging.

+
+  _allObservablesCount = _allObservables.length;
+  _delivering = false;
+}
+
+var _MAX_DIRTY_CHECK_CYCLES = 1000;