feat(dccd): add Support for ObservableList, ObservableMap & ChangeNotifier

vicb · vicb · commit 4e25f0b6f569 · 2014-07-24T08:29:08.000+02:00
Closes dart-archive#773 You should include the following lines in your pubspec.yaml dependency_overrides: analyzer: '>=0.15.6 <0.16.0' This is required because the observe package depends on analyzer: '>=0.15.6 <0.16.0' while all SDK packages have not yet been updated to depends on this version.
diff --git a/example/pubspec.yaml b/example/pubspec.yaml
@@ -9,3 +9,4 @@ dependencies:
 
 transformers:
 - angular
+
diff --git a/lib/change_detection/dirty_checking_change_detector.dart b/lib/change_detection/dirty_checking_change_detector.dart
@@ -2,6 +2,9 @@ library dirty_checking_change_detector;
 
 import 'dart:collection';
 import 'package:angular/change_detection/change_detection.dart';
+import 'dart:async';
+import 'package:observe/observe.dart' as obs;
+import 'package:smoke/smoke.dart' as smoke;
 
 /**
  * [DirtyCheckingChangeDetector] determines which object properties have changed
@@ -46,6 +49,9 @@ class DirtyCheckingChangeDetectorGroup<H> implements ChangeDetectorGroup<H> {
    */
   DirtyCheckingRecord _recordHead, _recordTail;
 
+  /// Registry of record with their notifiers
+  Map<DirtyCheckingRecord<H>, StreamSubscription> _observableRecords;
+
   /**
    * Same as [_tail] but includes child-group records as well.
    */
@@ -116,8 +122,7 @@ class DirtyCheckingChangeDetectorGroup<H> implements ChangeDetectorGroup<H> {
 
   WatchRecord<H> watch(Object object, String field, H handler) {
     assert(_root != null); // prove that we are not deleted connected;
-    return _recordAdd(new DirtyCheckingRecord(this, _fieldGetterFactory,
-                                              handler, field, object));
+    return _recordAdd(new DirtyCheckingRecord(this, _fieldGetterFactory, handler, field, object));
   }
 
   /**
@@ -146,6 +151,7 @@ class DirtyCheckingChangeDetectorGroup<H> implements ChangeDetectorGroup<H> {
     var root;
     assert((root = _root) != null);
     assert(root._assertRecordsOk());
+    _cancelChildObservables();
     DirtyCheckingRecord prevRecord = _recordHead._prevRecord;
     var childInclRecordTail = _childInclRecordTail;
     DirtyCheckingRecord nextRecord = childInclRecordTail._nextRecord;
@@ -191,6 +197,8 @@ class DirtyCheckingChangeDetectorGroup<H> implements ChangeDetectorGroup<H> {
   }
 
   void _recordRemove(DirtyCheckingRecord record) {
+    _cancelObservable(record);
+
     DirtyCheckingRecord previous = record._prevRecord;
     DirtyCheckingRecord next = record._nextRecord;
 
@@ -209,6 +217,35 @@ class DirtyCheckingChangeDetectorGroup<H> implements ChangeDetectorGroup<H> {
     }
   }
 
+  /// Register an observable object in this group.
+  void _registerObservable(DirtyCheckingRecord<H> record, StreamSubscription subscription) {
+    if (_observableRecords == null) _observableRecords = new HashMap.identity();
+    _observableRecords[record] = subscription;
+  }
+
+  /// Cancel an observable subscription in this group.
+  void _cancelObservable(DirtyCheckingRecord<H> record) {
+    if (_observableRecords == null) return;
+    var subscription = _observableRecords.remove(record);
+    if (subscription != null) subscription.cancel();
+  }
+
+  /// Cancel all observable subscriptions in this group.
+  void _cancelOwnObservables() {
+    if (_observableRecords != null) {
+      _observableRecords.values.forEach((s) => s.cancel());
+      _observableRecords = null;
+    }
+  }
+
+  /// Cancel all observable subscriptions in this group and descendant groups
+  void _cancelChildObservables() {
+    this._cancelOwnObservables();
+    for (var child = _childHead; child != null; child = child._next) {
+      child._cancelChildObservables();
+    }
+  }
+
   String toString() {
     var lines = [];
     if (_parent == null) {
@@ -306,6 +343,7 @@ class DirtyCheckingChangeDetector<H> extends DirtyCheckingChangeDetectorGroup<H>
   Iterator<Record<H>> collectChanges({EvalExceptionHandler exceptionHandler,
                                       AvgStopwatch stopwatch}) {
     if (stopwatch != null) stopwatch.start();
+
     DirtyCheckingRecord changeTail = _fakeHead;
     DirtyCheckingRecord current = _recordHead; // current index
 
@@ -375,18 +413,26 @@ class DirtyCheckingRecord<H> implements Record<H>, WatchRecord<H> {
       'NOOP',
       'IDENTITY',
       'GETTER',
-      'GETTER / CLOSURE'
+      'NOTIFIED GETTER',
+      'GETTER / CLOSURE',
+      'OBSERVABLE GETTER / CLOSURE',
       'MAP[]',
       'ITERABLE',
-      'MAP'];
+      'NOTIFIED LIST',
+      'MAP',
+      'NOTIFIED MAP'];
   static const int _MODE_MARKER_ = 0;
   static const int _MODE_NOOP_ = 1;
   static const int _MODE_IDENTITY_ = 2;
   static const int _MODE_GETTER_ = 3;
-  static const int _MODE_GETTER_OR_METHOD_CLOSURE_ = 4;
-  static const int _MODE_MAP_FIELD_ = 5;
-  static const int _MODE_ITERABLE_ = 6;
-  static const int _MODE_MAP_ = 7;
+  static const int _MODE_GETTER_NOTIFIED_ = 4;
+  static const int _MODE_GETTER_OR_METHOD_CLOSURE_ = 5;
+  static const int _MODE_GETTER_OBS_OR_METHOD_CLOSURE_ = 6;
+  static const int _MODE_MAP_FIELD_ = 7;
+  static const int _MODE_ITERABLE_ = 8;
+  static const int _MODE_LIST_NOTIFIED_ = 9;
+  static const int _MODE_MAP_ = 10;
+  static const int _MODE_MAP_NOTIFIED_ = 11;
 
   final DirtyCheckingChangeDetectorGroup _group;
   final FieldGetterFactory _fieldGetterFactory;
@@ -403,8 +449,7 @@ class DirtyCheckingRecord<H> implements Record<H>, WatchRecord<H> {
   var _object;
   FieldGetter _getter;
 
-  DirtyCheckingRecord(this._group, this._fieldGetterFactory, this.handler,
-                      this.field, _object) {
+  DirtyCheckingRecord(this._group, this._fieldGetterFactory, this.handler, this.field, _object) {
     object = _object;
   }
 
@@ -424,7 +469,10 @@ class DirtyCheckingRecord<H> implements Record<H>, WatchRecord<H> {
    * reflection. If [Map] then it sets up map accessor.
    */
   void set object(obj) {
+    _group._cancelObservable(this);
+
     _object = obj;
+
     if (obj == null) {
       _mode = _MODE_IDENTITY_;
       _getter = null;
@@ -434,30 +482,41 @@ class DirtyCheckingRecord<H> implements Record<H>, WatchRecord<H> {
     if (field == null) {
       _getter = null;
       if (obj is Map) {
-        if (_mode != _MODE_MAP_) {
-          _mode =  _MODE_MAP_;
+        if (currentValue is! _MapChangeRecord) {
           currentValue = new _MapChangeRecord();
-        }
-        if (currentValue.isDirty) {
-          // We're dirty because the mapping we tracked by reference mutated.
-          // In addition, our reference has now changed.  We should compare the
-          // previous reported value of that mapping with the one from the
-          // new reference.
+        } else if (currentValue.isDirty) {
+          // We're dirty because the mapping we tracked by reference mutated. In addition, our
+          // reference has now changed.  We should compare the previous reported value of that
+          // mapping with the one from the new reference.
           currentValue._revertToPreviousState();
         }
-
+        if (obj is obs.ChangeNotifier) {
+          _mode = _MODE_MAP_NOTIFIED_; // Run the dccd after the map is added
+          var subscription = (obj as obs.ChangeNotifier).changes.listen((_) {
+            _mode = _MODE_MAP_NOTIFIED_; // Run the dccd after the map is updated
+          });
+          _group._registerObservable(this, subscription);
+        } else {
+          _mode = _MODE_MAP_;
+        }
       } else if (obj is Iterable) {
-        if (_mode != _MODE_ITERABLE_) {
-          _mode = _MODE_ITERABLE_;
+        if (currentValue is! _CollectionChangeRecord) {
           currentValue = new _CollectionChangeRecord();
-        }
-        if (currentValue.isDirty) {
-          // We're dirty because the collection we tracked by reference mutated.
-          // In addition, our reference has now changed.  We should compare the
-          // previous reported value of that collection with the one from the
-          // new reference.
+        } else if (currentValue.isDirty) {
+          // We're dirty because the collection we tracked by reference mutated. In addition, our
+          // reference has now changed.  We should compare the previous reported value of that
+          // collection with the one from the new reference.
           currentValue._revertToPreviousState();
         }
+        if (obj is obs.ObservableList) {
+          _mode = _MODE_LIST_NOTIFIED_; // Run the dccd after the list is added
+          var subscription = (obj as obs.ObservableList).listChanges.listen((_) {
+            _mode = _MODE_LIST_NOTIFIED_; // Run the dccd after the list is updated
+          });
+          _group._registerObservable(this, subscription);
+        } else {
+          _mode = _MODE_ITERABLE_;
+        }
       } else {
         _mode = _MODE_IDENTITY_;
       }
@@ -469,7 +528,9 @@ class DirtyCheckingRecord<H> implements Record<H>, WatchRecord<H> {
       _mode =  _MODE_MAP_FIELD_;
       _getter = null;
     } else {
-      _mode = _MODE_GETTER_OR_METHOD_CLOSURE_;
+      _mode = obj is obs.ChangeNotifier ?
+          _MODE_GETTER_OBS_OR_METHOD_CLOSURE_ :
+          _MODE_GETTER_OR_METHOD_CLOSURE_;
       _getter = _fieldGetterFactory.getter(obj, field);
     }
   }
@@ -485,28 +546,55 @@ class DirtyCheckingRecord<H> implements Record<H>, WatchRecord<H> {
       case _MODE_GETTER_:
         current = _getter(object);
         break;
+      case _MODE_GETTER_NOTIFIED_:
+        _mode = _MODE_NOOP_; // no-op until next notification
+        current = _getter(object);
+        break;
       case _MODE_GETTER_OR_METHOD_CLOSURE_:
-        // NOTE: When Dart looks up a method "foo" on object "x", it returns a
-        // new closure for each lookup.  They compare equal via "==" but are no
-        // identical().  There's no point getting a new value each time and
-        // decide it's the same so we'll skip further checking after the first
-        // time.
+        // NOTE: When Dart looks up a method "foo" on object "x", it returns a new closure for each
+        // lookup.  They compare equal via "==" but are no identical(). There's no point getting a
+        // new value each time and decide it's the same so we'll skip further checking after the
+        // first time.
         current = _getter(object);
         if (current is Function && !identical(current, _getter(object))) {
           _mode = _MODE_NOOP_;
         } else {
           _mode = _MODE_GETTER_;
         }
         break;
+      case _MODE_GETTER_OBS_OR_METHOD_CLOSURE_:
+        current = _getter(object);
+        // no-op if closure (see _MODE_GETTER_OR_METHOD_CLOSURE_) or until the next notification
+        _mode = _MODE_NOOP_;
+        if (current is! Function || identical(current, _getter(object))) {
+          var subscription = (object as obs.ChangeNotifier).changes.listen((records) {
+            for (var rec in records) {
+              // todo(vicb) Change to String if dartbug.com/17863 eventually gets fixed
+              if (smoke.symbolToName(rec.name) == field) {
+                // Run the dccd after the observed `object.field` is updated
+                _mode = _MODE_GETTER_NOTIFIED_;
+                break;
+              }
+            }
+          });
+          _group._registerObservable(this, subscription);
+        }
+        break;
       case _MODE_MAP_FIELD_:
         current = object[field];
         break;
       case _MODE_IDENTITY_:
         current = object;
         _mode = _MODE_NOOP_;
         break;
+      case _MODE_MAP_NOTIFIED_:
+        _mode = _MODE_NOOP_; // no-op until next notification
+        return (currentValue as _MapChangeRecord)._check(object);
       case _MODE_MAP_:
         return (currentValue as _MapChangeRecord)._check(object);
+      case _MODE_LIST_NOTIFIED_:
+        _mode = _MODE_NOOP_; // no-op until next notification
+        return (currentValue as _CollectionChangeRecord)._check(object);
       case _MODE_ITERABLE_:
         return (currentValue as _CollectionChangeRecord)._check(object);
       default:
@@ -515,8 +603,7 @@ class DirtyCheckingRecord<H> implements Record<H>, WatchRecord<H> {
 
     var last = currentValue;
     if (!identical(last, current)) {
-      if (last is String && current is String &&
-          last == current) {
+      if (last is String && current is String && last == current) {
         // This is false change in strings we need to recover, and pretend it
         // is the same. We save the value so that next time identity will pass
         currentValue = current;
@@ -531,7 +618,6 @@ class DirtyCheckingRecord<H> implements Record<H>, WatchRecord<H> {
     return false;
   }
 
-
   void remove() {
     _group._recordRemove(this);
   }
@@ -540,8 +626,6 @@ class DirtyCheckingRecord<H> implements Record<H>, WatchRecord<H> {
       '${_mode < _MODE_NAMES.length ?  _MODE_NAMES[_mode] : '?'}[$field]{$hashCode}';
 }
 
-final Object _INITIAL_ = new Object();
-
 class _MapChangeRecord<K, V> implements MapChangeRecord<K, V> {
   final _records = new HashMap<dynamic, KeyValueRecord>();
   Map _map;
diff --git a/pubspec.yaml b/pubspec.yaml
@@ -22,6 +22,7 @@ dependencies:
   di: '>=2.0.0-alpha.10 <3.0.0'
   html5lib: '>=0.10.0 <0.11.0'
   intl: '>=0.8.7 <0.10.0'
+  observe: '>=0.10.0+1 <0.11.0'
   perf_api: '>=0.0.8 <0.1.0'
   route_hierarchical: '>=0.4.21 <0.5.0'
   web_components: '>=0.3.3 <0.4.0'
diff --git a/test/change_detection/dirty_checking_change_detector_spec.dart b/test/change_detection/dirty_checking_change_detector_spec.dart

Original file line number	Diff line number	Diff line change
`@@ -9,3 +9,4 @@ dependencies:`
`9`	`9`
`10`	`10`	`transformers:`
`11`	`11`	`- angular`
	`12`	`+`