Update polymer to commit b7200854b2441a22ce89f6563963f36c50f5150d

pkg/polymer/lib/src/instance.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 polymer;
 
 /**
  * Use this annotation to publish a field as an attribute. For example:
  *
  *     class MyPlaybackElement extends PolymerElement {
  *       // This will be available as an HTML attribute, for example:
  *       //     <my-playback volume="11">
  *       @published double volume;
  *     }
  */
 // TODO(jmesserly): does @published imply @observable or vice versa?
 const published = const PublishedProperty();
 
 /** An annotation used to publish a field as an attribute. See [published]. */
 class PublishedProperty extends ObservableProperty {
   const PublishedProperty();
 }
 
 /**
  * The mixin class for Polymer elements. It provides convenience features on top
  * of the custom elements web standard.
  */
 abstract class Polymer implements Element, Observable, NodeBindExtension {
   // Fully ported from revision:
-  // https://github.com/Polymer/polymer/blob/00e2982c78fcd396adaebff3118e94029a2b9fb0
+  // https://github.com/Polymer/polymer/blob/b7200854b2441a22ce89f6563963f36c50f5150d
   //
   //   src/boot.js (static APIs on "Polymer" object)
   //   src/instance/attributes.js
   //   src/instance/base.js
   //   src/instance/events.js
   //   src/instance/mdv.js
   //   src/instance/properties.js
   //   src/instance/style.js
   //   src/instance/utils.js
 
@@ skipping 15 matching lines @@
   static void register(String name, [Type type]) {
     //console.log('registering [' + name + ']');
     if (type == null) type = PolymerElement;
 
     _typesByName[name] = type;
     // notify the registrar waiting for 'name', if any
     _notifyType(name);
   }
 
   /// The one syntax to rule them all.
-  static final BindingDelegate _polymerSyntax = new PolymerExpressions();
+  static final BindingDelegate _polymerSyntax =
+      new _PolymerExpressionsWithEventDelegate();
 
   static int _preparingElements = 0;
 
   static final Completer _ready = new Completer();
 
   /**
    * Future indicating that the Polymer library has been loaded and is ready
    * for use.
    */
   static Future get onReady => _ready.future;
 
   PolymerDeclaration _declaration;
 
   /** The most derived `<polymer-element>` declaration for this element. */
   PolymerDeclaration get declaration => _declaration;
 
   Map<String, StreamSubscription> _observers;
   bool _unbound; // lazy-initialized
   Job _unbindAllJob;
 
   StreamSubscription _propertyObserver;
 
   bool get _elementPrepared => _declaration != null;
 
   bool get applyAuthorStyles => false;
   bool get resetStyleInheritance => false;
   bool get alwaysPrepare => false;
   bool get preventDispose => false;
 
+  BindingDelegate syntax = _polymerSyntax;
+
   /**
    * Shadow roots created by [parseElement]. See [getShadowRoot].
    */
   final _shadowRoots = new HashMap<String, ShadowRoot>();
 
   /** Map of items in the shadow root(s) by their [Element.id]. */
   // TODO(jmesserly): various issues:
   // * wrap in UnmodifiableMapView?
   // * should we have an object that implements noSuchMethod?
   // * should the map have a key order (e.g. LinkedHash or SplayTree)?
@@ skipping 166 matching lines @@
     root.append(dom);
     // perform post-construction initialization tasks on shadow root
     shadowRootReady(root, template);
     // return the created shadow root
     return root;
   }
 
   void shadowRootReady(Node root, Element template) {
     // locate nodes with id and store references to them in this.$ hash
     marshalNodeReferences(root);
-    // add local events of interest...
-    addInstanceListeners(root, template);
     // TODO(jmesserly): port this
     // set up pointer gestures
     // PointerGestures.register(root);
   }
 
   /** Locate nodes with id and store references to them in [$] hash. */
   void marshalNodeReferences(Node root) {
     if (root == null) return;
     for (var n in (root as dynamic).queryAll('[id]')) {
       $[n.id] = n;
@@ skipping 119 matching lines @@
    *     templateBind(template).createInstance(this, polymerSyntax);
    *
    * Where polymerSyntax is a singleton `PolymerExpressions` instance from the
    * [polymer_expressions](https://pub.dartlang.org/packages/polymer_expressions)
    * package.
    *
    * You can override this method to change the instantiation behavior of the
    * template, for example to use a different data-binding syntax.
    */
   DocumentFragment instanceTemplate(Element template) =>
-      templateBind(template).createInstance(this, _polymerSyntax);
+      templateBind(template).createInstance(this, syntax);
 
   NodeBinding createBinding(String name, model, String path) =>
       nodeBindFallback(this).createBinding(name, model, path);
 
   NodeBinding bind(String name, model, String path) {
     // note: binding is a prepare signal. This allows us to be sure that any
     // property changes that occur as a result of binding will be observed.
     if (!_elementPrepared) prepareElement();
 
     var property = propertyForAttribute(name);
-    if (property != null) {
+    if (property == null) {
+      // Cannot call super.bind because template_binding is its own package
+      return nodeBindFallback(this).bind(name, model, path);
+    } else {
+      // clean out the closets
       unbind(name);
       // use n-way Polymer binding
       var observer = bindProperty(property.simpleName, model, path);
       // reflect bound property to attribute when binding
       // to ensure binding is not left on attribute if property
       // does not update due to not changing.
       // Dart note: we include this patch:
       // https://github.com/Polymer/polymer/pull/319
       reflectPropertyToAttribute(property.simpleName);
       return bindings[name] = observer;
-    } else {
-      // Cannot call super.bind because template_binding is its own package
-      return nodeBindFallback(this).bind(name, model, path);
     }
   }
 
   Map<String, NodeBinding> get bindings => nodeBindFallback(this).bindings;
 
   void unbind(String name) => nodeBindFallback(this).unbind(name);
 
   void asyncUnbindAll() {
     if (_unbound == true) return;
     _unbindLog.fine('[$localName] asyncUnbindAll');
@@ skipping 91 matching lines @@
       }
       if (observe == null) return;
 
       var method = observe[name];
       if (method != null) {
         // observes the value if it is an array
         observeArrayValue(name, pair.newValue, pair.oldValue);
         // TODO(jmesserly): the JS code tries to avoid calling the same method
         // twice, but I don't see how that is possible.
         // Dart note: JS also passes "arguments", so we pass all change records.
-        invokeMethod(method, [pair.oldValue, pair.newValue, changes]);
+        invokeMethod(this, method, [pair.oldValue, pair.newValue, changes]);
       }
     });
   }
 
   void observeArrayValue(Symbol name, Object value, Object old) {
     final observe = _declaration._observe;
     if (observe == null) return;
 
     // we only care if there are registered side-effects
     var callbackName = observe[name];
     if (callbackName == null) return;
 
     // if we are observing the previous value, stop
     if (old is ObservableList) {
       if (_observeLog.isLoggable(Level.FINE)) {
         _observeLog.fine('[$localName] observeArrayValue: unregister observer '
             '$name');
       }
 
       unregisterObserver('${MirrorSystem.getName(name)}__array');
     }
     // if the new value is an array, being observing it
     if (value is ObservableList) {
       if (_observeLog.isLoggable(Level.FINE)) {
         _observeLog.fine('[$localName] observeArrayValue: register observer '
             '$name');
       }
       var sub = (value as ObservableList).changes.listen((changes) {
-        invokeMethod(callbackName, [old]);
+        invokeMethod(this, callbackName, [old]);
       });
       registerObserver('${MirrorSystem.getName(name)}__array', sub);
     }
   }
 
   void unbindProperty(String name) => unregisterObserver(name);
 
   void unbindAllProperties() {
     if (_propertyObserver != null) {
       _propertyObserver.cancel();
       _propertyObserver = null;
     }
     unregisterObservers();
   }
 
   /** Bookkeeping observers for memory management. */
   void registerObserver(String name, StreamSubscription sub) {
     if (_observers == null) {
       _observers = new Map<String, StreamSubscription>();
     }
     _observers[name] = sub;
   }
 
   bool unregisterObserver(String name) {
     var sub = _observers.remove(name);
     if (sub == null) return false;
-    subl.cancel();

[Jennifer Messerly, 2013/10/25 22:00:41]

ouch! nice catch

[Siggi Cherem (dart-lang), 2013/10/26 00:02:35]

dart2js warning =)

+    sub.cancel();
     return true;
   }
 
   void unregisterObservers() {
     if (_observers == null) return;
     for (var sub in _observers.values) sub.cancel();
     _observers.clear();
     _observers = null;
   }
 
   /**
    * Bind a [property] in this object to a [path] in model. *Note* in Dart it
    * is necessary to also define the field:
    *
    *     var myProperty;
    *
-   *     created() {
-   *       super.created();
+   *     ready() {
+   *       super.ready();
    *       bindProperty(#myProperty, this, 'myModel.path.to.otherProp');
    *     }
    */
   // TODO(jmesserly): replace with something more localized, like:
   // @ComputedField('myModel.path.to.otherProp');
   NodeBinding bindProperty(Symbol name, Object model, String path) =>
       // apply Polymer two-way reference binding
       _bindProperties(this, name, model, path);
 
   /**
@@ skipping 27 matching lines @@
   void addHostListeners() {
     var events = _declaration._eventDelegates;
     if (events.isEmpty) return;
 
     if (_eventsLog.isLoggable(Level.FINE)) {
       _eventsLog.fine('[$localName] addHostListeners: $events');
     }
     addNodeListeners(this, events.keys, hostEventListener);
   }
 
-  /** Attach event listeners inside a shadow [root]. */
-  void addInstanceListeners(Node root, Element template) {
-    var templateDelegates = _declaration._templateDelegates;
-    if (templateDelegates == null) return;
-    var events = templateDelegates[template];
-    if (events == null) return;
-
-    if (_eventsLog.isLoggable(Level.FINE)) {
-      _eventsLog.fine('[$localName] addInstanceListeners: $events');
-    }
-    addNodeListeners(root, events, instanceEventListener);
-  }
-
   void addNodeListeners(Node node, Iterable<String> events,
       void listener(Event e)) {
 
     for (var name in events) {
       addNodeListener(node, name, listener);
     }
   }
 
   void addNodeListener(Node node, String event, void listener(Event e)) {
     node.on[event].listen(listener);
   }
 
   void hostEventListener(Event event) {
     // TODO(jmesserly): do we need this check? It was using cancelBubble, see:
     // https://github.com/Polymer/polymer/issues/292
     if (!event.bubbles) return;
 
     bool log = _eventsLog.isLoggable(Level.FINE);
     if (log) {
       _eventsLog.fine('>>> [$localName]: hostEventListener(${event.type})');
     }
 
     var h = findEventDelegate(event);
     if (h != null) {
       if (log) _eventsLog.fine('[$localName] found host handler name [$h]');
       var detail = event is CustomEvent ?
           (event as CustomEvent).detail : null;
       // TODO(jmesserly): cache the symbols?
-      dispatchMethod(new Symbol(h), [event, detail, this]);
+      dispatchMethod(this, h, [event, detail, this]);
     }
 
     if (log) {
       _eventsLog.fine('<<< [$localName]: hostEventListener(${event.type})');
     }
   }
 
   String findEventDelegate(Event event) =>
       _declaration._eventDelegates[_eventNameFromType(event.type)];
 
-  /** Call [methodName] method on [this] with [args], if the method exists. */
-  // TODO(jmesserly): I removed the [node] argument as it was unused. Reconcile.
-  void dispatchMethod(Symbol methodName, List args) {
+  /**
+   * Calls [methodOrCallback] with [args] if it is a closure, otherwise, treat
+   * it as a method name in [object], and invoke it.
+   */
+  void dispatchMethod(object, callbackOrMethod, List args) {
     bool log = _eventsLog.isLoggable(Level.FINE);
-    if (log) _eventsLog.fine('>>> [$localName]: dispatch $methodName');
+    if (log) _eventsLog.fine('>>> [$localName]: dispatch $callbackOrMethod');
 
-    invokeMethod(methodName, args);
+    if (callbackOrMethod is Function) {
+      Function.apply(callbackOrMethod, args);
+    } else if (callbackOrMethod is String) {
+      invokeMethod(object, new Symbol(callbackOrMethod), args);
+    } else {
+      _eventsLog.warning('invalid callback');
+    }
 
-    if (log) _eventsLog.info('<<< [$localName]: dispatch $methodName');
+    if (log) _eventsLog.info('<<< [$localName]: dispatch $callbackOrMethod');
   }
 
-  invokeMethod(Symbol methodName, List args) {
+  /** Call [methodName] method on [receiver] with [args]. */
+  static invokeMethod(receiver, Symbol methodName, List args) {

[Jennifer Messerly, 2013/10/25 22:00:41]

fyi -- this is an instance method in Polymer:

https://github.com/Polymer/polymer/blob/master/src/instance/properties.js#L96

consider making this private and re-exposing the instance method

[Siggi Cherem (dart-lang), 2013/10/26 00:02:35]

Done.

     // TODO(sigmund): consider making callbacks list all arguments
     // explicitly. Unless VM mirrors are optimized first, this will be expensive
     // once custom elements extend directly from Element (see issue 11108).
-    var self = reflect(this);
-    var method = self.type.methods[methodName];
+    var receiverMirror = reflect(receiver);
+    var method = receiverMirror.type.methods[methodName];
     if (method != null) {
       // This will either truncate the argument list or extend it with extra
       // null arguments, so it will match the signature.
       // TODO(sigmund): consider accepting optional arguments when we can tell
       // them appart from named arguments (see http://dartbug.com/11334)
       args.length = method.parameters.where((p) => !p.isOptional).length;
     }
-    return self.invoke(methodName, args).reflectee;
-  }
-
-  void instanceEventListener(Event event) {
-    _listenLocal(this, event);
-  }
-
-  // TODO(sjmiles): much of the below privatized only because of the vague
-  // notion this code is too fiddly and we need to revisit the core feature
-  void _listenLocal(Polymer host, Event event) {

[Jennifer Messerly, 2013/10/25 22:00:41]

yay! so much code gone :)

-    // TODO(jmesserly): do we need this check? It was using cancelBubble, see:
-    // https://github.com/Polymer/polymer/issues/292
-    if (!event.bubbles) return;
-
-    bool log = _eventsLog.isLoggable(Level.FINE);
-    if (log) _eventsLog.fine('>>> [$localName]: listenLocal [${event.type}]');
-
-    final eventOn = '$_EVENT_PREFIX${_eventNameFromType(event.type)}';
-    if (event.path == null) {
-      _listenLocalNoEventPath(host, event, eventOn);
-    } else {
-      _listenLocalEventPath(host, event, eventOn);
-    }
-
-    if (log) _eventsLog.fine('<<< [$localName]: listenLocal [${event.type}]');
-  }
-
-  static void _listenLocalEventPath(Polymer host, Event event, String eventOn) {
-    var c = null;
-    for (var target in event.path) {
-      // if we hit host, stop
-      if (identical(target, host)) return;
-
-      // find a controller for the target, unless we already found `host`
-      // as a controller
-      c = identical(c, host) ? c : _findController(target);
-
-      // if we have a controller, dispatch the event, and stop if the handler
-      // returns true
-      if (c != null && _handleEvent(c, target, event, eventOn)) {
-        return;
-      }
-    }
-  }
-
-  // TODO(sorvell): remove when ShadowDOM polyfill supports event path.
-  // Note that _findController will not return the expected controller when the
-  // event target is a distributed node.  This is because we cannot traverse
-  // from a composed node to a node in shadowRoot.
-  // This will be addressed via an event path api
-  // https://www.w3.org/Bugs/Public/show_bug.cgi?id=21066
-  static void _listenLocalNoEventPath(Polymer host, Event event,
-      String eventOn) {
-
-    if (_eventsLog.isLoggable(Level.FINE)) {
-      _eventsLog.fine('event.path() not supported for ${event.type}');
-    }
-
-    var target = event.target;
-    var c = null;
-    // if we hit dirt or host, stop
-    while (target != null && target != host) {
-      // find a controller for target `t`, unless we already found `host`
-      // as a controller
-      c = identical(c, host) ? c : _findController(target);
-
-      // if we have a controller, dispatch the event, return 'true' if
-      // handler returns true
-      if (c != null && _handleEvent(c, target, event, eventOn)) {
-        return;
-      }
-      target = target.parent;
-    }
-  }
-
-  // TODO(jmesserly): this won't find the correct host unless the ShadowRoot
-  // was created on a PolymerElement.
-  static Polymer _findController(Node node) {
-    while (node.parentNode != null) {
-      node = node.parentNode;
-    }
-    return _shadowHost[node];
-  }
-
-  static bool _handleEvent(Polymer ctrlr, Node node, Event event,
-      String eventOn) {
-
-    // Note: local events are listened only in the shadow root. This dynamic
-    // lookup is used to distinguish determine whether the target actually has a
-    // listener, and if so, to determine lazily what's the target method.
-    var name = node is Element ? (node as Element).attributes[eventOn] : null;
-    if (name != null && _handleIfNotHandled(node, event)) {
-      if (_eventsLog.isLoggable(Level.FINE)) {
-        _eventsLog.fine('[${ctrlr.localName}] found handler name [$name]');
-      }
-      var detail = event is CustomEvent ?
-          (event as CustomEvent).detail : null;
-
-      if (node != null) {
-        // TODO(jmesserly): cache symbols?
-        ctrlr.dispatchMethod(new Symbol(name), [event, detail, node]);
-      }
-    }
-
-    // TODO(jmesserly): do we need this? It was using cancelBubble, see:
-    // https://github.com/Polymer/polymer/issues/292
-    return !event.bubbles;
-  }
-
-  // TODO(jmesserly): I don't understand this bit. It seems to be a duplicate
-  // delivery prevention mechanism?
-  static bool _handleIfNotHandled(Node node, Event event) {
-    var list = _eventHandledTable[event];
-    if (list == null) _eventHandledTable[event] = list = new Set<Node>();
-    if (!list.contains(node)) {
-      list.add(node);
-      return true;
-    }
-    return false;
+    return receiverMirror.invoke(methodName, args).reflectee;
   }
 
   /**
    * Invokes a function asynchronously.
    * This will call `Platform.flush()` and then return a `new Timer`
    * with the provided [method] and [timeout].
    *
    * If you would prefer to run the callback using
    * [window.requestAnimationFrame], see the [async] method.
    */
@@ skipping 252 matching lines @@
 class PolymerElement extends HtmlElement with Polymer, Observable {
   PolymerElement.created() : super.created() {
     polymerCreated();
   }
 }
 
 class _PropertyValue {
   Object oldValue, newValue;
   _PropertyValue(this.oldValue);
 }
+
+// TODO(sorvell): we're patching the syntax while evaluating
+// event bindings. we'll move this to a better spot when that's done
+class _PolymerExpressionsWithEventDelegate extends PolymerExpressions {

[Jennifer Messerly, 2013/10/25 22:00:41]

I wonder if we should make this functionality available to third party syntaxes?
I know a few people have implemented their own syntax thingies :)

e.g. extract your getBinding into a public method that takes the original
getBinding. Then implement this class via:

class _PolymerExpressionsWithEventDelegate extends PolymerExpressions {
  getBinding(model, path, name, node) {
    return Polymer.getBindingWithEvents(model, path, name, node,
super.getBinding);
  }
}

[Siggi Cherem (dart-lang), 2013/10/26 00:02:35]

Good idea, done.

+  /**
+   * Bind events via attributes of the form `on-eventName`. This method hooks
+   * into the model syntax and does adds event listeners as needed. By default,
+   * binding paths are always method names on the root model, the custom element
+   * in which the node exists. Adding a '@' in the path directs the event
+   * binding to use the model path as the event listener.  In both cases, the
+   * actual listener is attached to a generic method which evaluates the bound
+   * path at event execution time.
+   */
+  // from src/instance/event.js#prepareBinding
+  // Dart note: template_binding doesn't have the notion of a delegateBinding
+  // function, so we implement this by overriding getBinding instead.
+  getBinding(model, String path, name, node) {
+    // if lhs an event prefix,
+    if (name is! String || !_hasEventPrefix(name)) {
+      return super.getBinding(model, path, name, node);
+    }
+
+    // provide an event-binding callback.
+    // return (model, name, node) {
+    if (_eventsLog.isLoggable(Level.FINE)) {
+      _eventsLog.fine('event: [${node.localName}].$name => '
+          '[${model.localName}].$path())');
+    }
+    var eventName = _removeEventPrefix(name);
+    // TODO(sigmund): polymer.js dropped event translations. reconcile?
+    var translated = _eventTranslations[eventName];
+    eventName = translated != null ? translated : eventName;
+    return node.on[eventName].listen((event) {
+      var ctrlr = _findController(node);
+      if (ctrlr is! Polymer) return;

[Jennifer Messerly, 2013/10/25 22:00:41]

fyi -- _findController should not return something that isn't a Polymer mixin

+      var obj = ctrlr;
+      var method = path;
+      if (path[0] == '@') {
+        obj = model;
+        // Dart note: using getBinding gets us the result of evaluating the
+        // original path (without the @) as a normal expression.
+        method = super.getBinding(model, path.substring(1), name, node).value;
+      }
+      var detail = event is CustomEvent ?
+          (event as CustomEvent).detail : null;
+      ctrlr.dispatchMethod(obj, method, [event, detail, node]);
+    });
+  }
+
+  // TODO(jmesserly): this won't find the correct host unless the ShadowRoot
+  // was created on a PolymerElement.
+  static Polymer _findController(Node node) {
+    while (node.parentNode != null) {
+      node = node.parentNode;
+    }
+    return _shadowHost[node];
+  }
+}