port Node.bind to bd0a0591920da9091b326627a46a104a92c7efe7

pkg/template_binding/lib/src/template.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 template_binding;
 
 /** Extensions to [Element]s that behave as templates. */
 class TemplateBindExtension extends _ElementExtension {
   var _model;
   BindingDelegate _bindingDelegate;
   _TemplateIterator _templateIterator;
   bool _scheduled = false;
 
   Element _templateInstanceRef;
 
   // Note: only used if `this is! TemplateElement`
   DocumentFragment _content;
   bool _templateIsDecorated;
 
   TemplateBindExtension._(Element node) : super(node);
 
   Element get _node => super._node;
 
-  NodeBinding createBinding(String name, model, String path) {
+  NodeBinding bind(String name, model, [String path]) {
     switch (name) {
       case 'bind':
       case 'repeat':
       case 'if':
+        _self.unbind(name);
         if (_templateIterator == null) {
           _templateIterator = new _TemplateIterator(_node);
         }
-        // TODO(jmesserly): why do we do this here and nowhere else?
-        if (path == null) path = '';
-        return new _TemplateBinding(this, name, model, path);
+        return bindings[name] = new _TemplateBinding(this, name, model, path);
       default:
-        return super.createBinding(name, model, path);
+        return super.bind(name, model, path);
     }
   }
 
   /**
    * Creates an instance of the template, using the provided model and optional
    * binding delegate.
    */
   DocumentFragment createInstance([model, BindingDelegate delegate]) {
     var instance = _createDeepCloneAndDecorateTemplates(
         templateBind(ref).content, delegate);
@@ skipping 34 matching lines @@
     _addBindings(_node, _model, _bindingDelegate);
   }
 
   /** Gets the template this node refers to. */
   Element get ref {
     _decorate();
 
     Element result = null;
     var refId = _node.attributes['ref'];
     if (refId != null) {
-      var treeScope = _node;
-      while (treeScope.parentNode != null) {
-        treeScope = treeScope.parentNode;
-      }
-
-      // Note: JS code tests that getElementById is present. We can't do that
-      // easily, so instead check for the types known to implement it.
-      if (treeScope is Document ||
-          treeScope is ShadowRoot ||
-          treeScope is SvgSvgElement) {
-
+      var treeScope = _getTreeScope(_node);
+      if (treeScope != null) {
         result = treeScope.getElementById(refId);
       }
     }
 
     if (result == null) {
       result = _templateInstanceRef;
       if (result == null) return _node;
     }
 
     var nextRef = templateBind(result).ref;
@@ skipping 190 matching lines @@
   }
 }
 
 class _TemplateBinding extends NodeBinding {
   TemplateBindExtension _ext;
 
   // TODO(jmesserly): MDV uses TemplateIterator as the node, see:
   // https://github.com/Polymer/mdv/issues/127
   _TemplateBinding(ext, name, model, path)
       : _ext = ext, super(ext._node, name, model, path) {
-    _ext._templateIterator.inputs.bind(property, model, path);
+    _ext._templateIterator.inputs.bind(property, model, this.path);
   }
 
   // These are no-ops because we don't use the underlying PathObserver.
   void _observePath() {}
-  void boundValueChanged(newValue) {}
+  void valueChanged(newValue) {}
 
   void close() {
     if (closed) return;
     var templateIterator = _ext._templateIterator;
     if (templateIterator != null) templateIterator.inputs.unbind(property);
     super.close();
   }
 }
+
+_getTreeScope(Node node) {
+  while (node.parentNode != null) {
+    node = node.parentNode;
+  }
+
+  // Note: JS code tests that getElementById is present. We can't do that
+  // easily, so instead check for the types known to implement it.
+  if (node is Document || node is ShadowRoot || node is SvgSvgElement) {
+    return node;
+  }
+  return null;
+}