port TemplateBinding to ed3266266e751b5ab1f75f8e0509d0d5f0ef35d8

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.
  */
+// TODO(jmesserly): consider specialized subclasses for:
+// * single token in path, e.g. "foo"
+// * specifically: "value"

[Siggi Cherem (dart-lang), 2013/10/29 21:00:07]

+1

[Jennifer Messerly, 2013/10/29 22:35:07]

Done.

 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;
 
+  // TODO(jmesserly): I'm not sure about these APIs. They do increase
+  // performance but at the cost of complexity and perhaps having too much
+  // functionality inside PathObserver.

[Siggi Cherem (dart-lang), 2013/10/29 21:00:07]

I think it's worth it. IIUC, if we have a compile-time pass that creates
functions to read values without mirrors, we can plug them here?

[Jennifer Messerly, 2013/10/29 22:35:07]

agree. removed the TODO. original it was getValue/setValue and valueCallback
which felt too much. but just getValue isn't so bad.

+  final Function _getValue;
+
   /**
    * Observes [path] on [object] for changes. This returns an object that can be
    * used to get the changes and get/set the value at this path.
    * See [PathObserver.bindSync] and [PathObserver.value].

[Siggi Cherem (dart-lang), 2013/10/29 21:00:07]

add short description for getValue?

[Jennifer Messerly, 2013/10/29 22:35:07]

Done.

    */
-  PathObserver(Object object, String path)
+  PathObserver(Object object, String path, {getValue(x)})
       : path = path,
+        _getValue = getValue,
         _isValid = _isPathValid(path),
         _segments = <Object>[] {
 
     if (_isValid) {
       for (var segment in path.trim().split('.')) {
         if (segment == '') continue;
         var index = int.parse(segment, radix: 10, onError: (_) => null);
         _segments.add(index != null ? index : new Symbol(segment));
       }
     }
 
     // Initialize arrays.
     // Note that the path itself can't change after it is initially
     // constructed, even though the objects along the path can change.
     _values = new List<Object>(_segments.length + 1);
+
+    if (_segments.isEmpty && getValue != null) object = getValue(object);

[Siggi Cherem (dart-lang), 2013/10/29 21:00:07]

reading this and the lines below it's a bit confusing. Might help to add a
typedef for the type of getValue to clarify a bit. For example, is the argument
the old value? 

[Jennifer Messerly, 2013/10/29 22:35:07]

tried to clarify in a comment. changed argument name to newValue

     _values[0] = object;
     _subs = new List<StreamSubscription>(_segments.length);
   }
 
   /** The object being observed. */
   get object => _values[0];
 
   /** Gets the last reported value at this path. */
   @reflectable get value {
     if (!_isValid) return null;
     if (!hasObservers) _updateValues();
     return _values.last;
   }
 
   /** Sets the value at this path. */
-  @reflectable void set value(Object value) {
+  @reflectable void set value(Object newValue) {
     int len = _segments.length;
 
     // TODO(jmesserly): throw if property cannot be set?
     // MDV seems tolerant of these errors.
     if (len == 0) return;
     if (!hasObservers) _updateValues();
 
-    if (_setObjectProperty(_values[len - 1], _segments[len - 1], value)) {
+    if (_setObjectProperty(_values[len - 1], _segments[len - 1], newValue)) {
       // Technically, this would get updated asynchronously via a change record.
       // However, it is nice if calling the getter will yield the same value
       // that was just set. So we use this opportunity to update our cache.
-      _values[len] = value;
+      _values[len] = newValue;
     }
   }
 
   /**
    * Invokes the [callback] immediately with the current [value], and every time
    * the value changes. This is useful for bindings, which want to be up-to-date
    * immediately and stay bound to the value of the path.
    */
   StreamSubscription bindSync(void callback(value)) {
     var result = changes.listen((records) { callback(value); });
@@ skipping 11 matching lines @@
     for (int i = 0; i < _subs.length; i++) {
       if (_subs[i] != null) {
         _subs[i].cancel();
         _subs[i] = null;
       }
     }
   }
 
   // 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]);
+    for (int i = 0, last = _segments.length - 1; i <= last; i++) {
+      var newValue = _getObjectProperty(_values[i], _segments[i]);
+      if (i == last && _getValue != null) newValue = _getValue(newValue);
+      _values[i + 1] = newValue;
     }
   }
 
   void _updateObservedValues([int start = 0]) {
     var oldValue, newValue;
-    for (int i = start; i < _segments.length; i++) {
+    for (int i = start, last = _segments.length - 1; i <= last; i++) {
       oldValue = _values[i + 1];
       newValue = _getObjectProperty(_values[i], _segments[i]);
+      if (i == last && _getValue != null) newValue = _getValue(newValue);
       if (identical(oldValue, newValue)) {
         _observePath(start, i);
         return;
       }
       _values[i + 1] = newValue;
     }
 
     _observePath(start);
     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.
+      // property, we could try and have one for the entire path. However we'd
+      // need to do a linear scan to find the index as soon as we got a change.
+      // Also we need to fix ListChangeRecord and MapChangeRecord to contain
+      // the target. Not sure if it's worth it.
       _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 (_changeRecordMatches(record, _segments[i])) {
             _updateObservedValues(i);
             return;
           }
         }
       });
     }
   }
 }
@@ skipping 24 matching lines @@
       return null;
     }
   }
 
   if (property is Symbol) {
     var mirror = reflect(object);
     var result = _tryGetField(mirror, property);
     if (result != null) return result.reflectee;
   }
 
+  // TODO(jmesserly): need to fix NoSuchMethodErrors from _tryGetField; right
+  // now it's painful to debug (and probably really slow) to use maps.
   if (object is Map) {
     if (property is Symbol) property = MirrorSystem.getName(property);
     return object[property];
   }
 
+  // TODO(jmesserly): log a binding that fails?
   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;
@@ skipping 81 matching lines @@
 
 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);
 }