package:observe fix various api issues

pkg/observe/lib/src/path_observer.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.
 
 part of observe;
 
 // This code is inspired by ChangeSummary:
 // https://github.com/rafaelw/ChangeSummary/blob/master/change_summary.js
 // ...which underlies MDV. Since we don't need the functionality of
 // ChangeSummary, we just implement what we need for data bindings.
 // This allows our implementation to be much simpler.
 
 /**
  * A data-bound path starting from a view-model or model object, for example
  * `foo.bar.baz`.
  *
  * When the [values] stream is being listened to, this will observe changes to
  * the object and any intermediate object along the path, and send [values]
  * accordingly. When all listeners are unregistered it will stop observing
  * the objects.
  *
  * This class is used to implement [Node.bind] and similar functionality.
  */
-class PathObserver extends ChangeNotifierBase {
+class PathObserver extends ChangeNotifier {
   /** The path string. */
   final String path;
 
   /** True if the path is valid, otherwise false. */
   final bool _isValid;
 
   final List<Object> _segments;
   List<Object> _values;
   List<StreamSubscription> _subs;
 
@@ skipping 77 matching lines @@
   }
 
   // TODO(jmesserly): should we be caching these values if not observing?
   void _updateValues() {
     for (int i = 0; i < _segments.length; i++) {
       _values[i + 1] = _getObjectProperty(_values[i], _segments[i]);
     }
   }
 
   void _updateObservedValues([int start = 0]) {
-    bool changed = false;
+    var oldValue, newValue;
     for (int i = start; i < _segments.length; i++) {
-      final newValue = _getObjectProperty(_values[i], _segments[i]);
-      if (identical(_values[i + 1], newValue)) {
+      oldValue = _values[i + 1];
+      newValue = _getObjectProperty(_values[i], _segments[i]);
+      if (identical(oldValue, newValue)) {
         _observePath(start, i);
         return;
       }
       _values[i + 1] = newValue;
-      changed = true;
     }
 
     _observePath(start);
-    if (changed) {
-      notifyChange(new PropertyChangeRecord(#value));
-    }
+    notifyPropertyChange(#value, oldValue, newValue);
   }
 
   void _observePath([int start = 0, int end]) {
     if (end == null) end = _segments.length;
 
     for (int i = start; i < end; i++) {
       if (_subs[i] != null) _subs[i].cancel();
       _observeIndex(i);
     }
   }
 
   void _observeIndex(int i) {
     final object = _values[i];
     if (object is Observable) {
       // TODO(jmesserly): rather than allocating a new closure for each
       // property, we could try and have one for the entire path. In that case,
       // we would lose information about which object changed (note: unless
       // PropertyChangeRecord is modified to includes the sender object), so
       // we would need to re-evaluate the entire path. Need to evaluate perf.
       _subs[i] = object.changes.listen((List<ChangeRecord> records) {
         if (!identical(_values[i], object)) {
           // Ignore this object if we're now tracking something else.
           return;
         }
 
         for (var record in records) {
-          if (record.changes(_segments[i])) {
+          if (_changeRecordMatches(record, _segments[i])) {
             _updateObservedValues(i);
             return;
           }
         }
       });
     }
   }
 }
 
+bool _changeRecordMatches(record, key) {
+  if (record is ListChangeRecord) {
+    return key is int && (record as ListChangeRecord).indexChanged(key);
+  }
+  if (record is PropertyChangeRecord) {
+    return (record as PropertyChangeRecord).name == key;
+  }
+  if (record is MapChangeRecord) {
+    if (key is Symbol) key = MirrorSystem.getName(key);
+    return (record as MapChangeRecord).key == key;
+  }
+  return false;
+}
+
 _getObjectProperty(object, property) {
   if (object == null) {
     return null;
   }
 
   if (object is List && property is int) {
     if (property >= 0 && property < object.length) {
       return object[property];
     } else {
       return null;
     }
   }
 
   if (property is Symbol) {
     var mirror = reflect(object);
-    try {
-      return mirror.getField(property).reflectee;
-    } catch (e) {}
+    var result = _tryGetField(mirror, property);
+    if (result != null) return result.reflectee;
   }
 
   if (object is Map) {
+    if (property is Symbol) property = MirrorSystem.getName(property);
     return object[property];
   }
 
   return null;
 }
 
 bool _setObjectProperty(object, property, value) {
   if (object is List && property is int) {
     if (property >= 0 && property < object.length) {
       object[property] = value;
       return true;
     } else {
       return false;
     }
   }
 
   if (property is Symbol) {
     var mirror = reflect(object);
-    try {
-      mirror.setField(property, value);
-      return true;
-    } catch (e) {}
+    if (_trySetField(mirror, property, value)) return true;
   }
 
   if (object is Map) {
+    if (property is Symbol) property = MirrorSystem.getName(property);
     object[property] = value;
     return true;
   }
 
   return false;
 }
 
+InstanceMirror _tryGetField(InstanceMirror mirror, Symbol name) {
+  try {
+    return mirror.getField(name);
+  } on NoSuchMethodError catch (e) {
+    if (_hasMember(mirror, name, (m) =>
+        m is VariableMirror || m is MethodMirror && m.isGetter)) {
+      // The field/getter is there but threw a NoSuchMethod exception.
+      // This is a legitimate error in the code so rethrow.
+      rethrow;
+    }
+    // The field isn't there. PathObserver does not treat this as an error.
+    return null;
+  }
+}
+
+bool _trySetField(InstanceMirror mirror, Symbol name, Object value) {
+  try {
+    mirror.setField(name, value);
+    return true;
+  } on NoSuchMethodError catch (e) {
+    if (_hasMember(mirror, name, (m) => m is VariableMirror) ||
+        _hasMember(mirror, _setterName(name))) {
+      // The field/setter is there but threw a NoSuchMethod exception.
+      // This is a legitimate error in the code so rethrow.
+      rethrow;
+    }
+    // The field isn't there. PathObserver does not treat this as an error.
+    return false;
+  }
+}
+
+// TODO(jmesserly): workaround for:
+// https://code.google.com/p/dart/issues/detail?id=10029
+Symbol _setterName(Symbol getter) =>
+    new Symbol('${MirrorSystem.getName(getter)}=');
+
+bool _hasMember(InstanceMirror mirror, Symbol name, [bool test(member)]) {
+  var type = mirror.type;
+  while (type != null) {
+    final member = type.members[name];
+    if (member != null && (test == null || test(member))) return true;
+
+    try {
+      type = type.superclass;
+    } on UnsupportedError catch (e) {
+      // TODO(jmesserly): dart2js throws this error when the type is not
+      // reflectable.
+      return false;
+    }
+  }
+  return false;
+}
 
 // From: https://github.com/rafaelw/ChangeSummary/blob/master/change_summary.js
 
 final _pathRegExp = () {
   const identStart = '[\$_a-zA-Z]';
   const identPart = '[\$_a-zA-Z0-9]';
   const ident = '$identStart+$identPart*';
   const elementIndex = '(?:[0-9]|[1-9]+[0-9]+)';
   const identOrElementIndex = '(?:$ident|$elementIndex)';
   const path = '(?:$identOrElementIndex)(?:\\.$identOrElementIndex)*';
   return new RegExp('^$path\$');
 }();
 
 final _spacesRegExp = new RegExp(r'\s');
 
 bool _isPathValid(String s) {
   s = s.replaceAll(_spacesRegExp, '');
 
   if (s == '') return true;
   if (s[0] == '.') return false;
   return _pathRegExp.hasMatch(s);
 }