Add support for custom elements to MDV

tools/dom/src/TemplateBindings.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 html;
 
 // This code is a port of Model-Driven-Views:
 // https://github.com/toolkitchen/mdv
 // The code mostly comes from src/template_element.js
 
@@ skipping 505 matching lines @@
         var value = values[i];
         if (value != null) {
           newValue.write(value);
         }
       }
     }
 
     return newValue.toString();
   };
 
-  node.bind(name, replacementBinding, 'value');
+  _nodeOrCustom(node).bind(name, replacementBinding, 'value');
 }
 
 void _bindOrDelegate(node, name, model, String path,
     CustomBindingSyntax syntax) {
 
   if (syntax != null) {
     var delegateBinding = syntax.getBinding(model, path, name, node);
     if (delegateBinding != null) {
       model = delegateBinding;
       path = 'value';
     }
   }
 
-  node.bind(name, model, path);
+  _nodeOrCustom(node).bind(name, model, path);
 }
 
+/**
+ * Gets the [node]'s custom [Element.xtag] if present, otherwise returns
+ * the node. This is used so nodes can override [Node.bind], [Node.unbind],
+ * and [Node.unbindAll] like
+ */
+// TODO(jmesserly): remove this when we can extend Element for real.
+_nodeOrCustom(node) => node is Element ? node.xtag : node;

[Siggi Cherem (dart-lang), 2013/05/13 16:42:13]

interesting, what about a custom element that extends from <template>? Seems
like 'bind' in the custom element takes priority, but I wonder if it should be
applied to both?

[Jennifer Messerly, 2013/05/13 19:42:41]

Not sure I understand...

What this does is try and simulate inheriting Element. It needs to be good
enough that we can implement binding to an element's fields. It's definitely not
perfect. You can show the leakiness by simply calling .bind yourself on the
underlying Element; that will skill the custom impl. That's why we need real
inheritance.

It's quite possible something doesn't work if you extend <template> element. I
haven't yet seen a compelling use case for extending template, so I'm inclined
not to put much effort into polyfilling it.

[Jennifer Messerly, 2013/05/13 19:43:45]

oops, "skill the custom impl" should be "skip the custom impl".

+
 class _BindingToken {
   final String value;
   final bool isBinding;
 
   _BindingToken(this.value, {this.isBinding: false});
 
   bool get isText => !isBinding;
 }
 
 List<_BindingToken> _parseMustacheTokens(String s) {
@@ skipping 39 matching lines @@
       fragment.$dom_firstChild, fragment.$dom_lastChild, model);
 
   var node = instanceRecord.firstNode;
   while (node != null) {
     node._templateInstance = instanceRecord;
     node = node.nextNode;
   }
 }
 
 void _removeAllBindingsRecursively(Node node) {
-  node.unbindAll();
+  _nodeOrCustom(node).unbindAll();
   for (var c = node.$dom_firstChild; c != null; c = c.nextNode) {
     _removeAllBindingsRecursively(c);
   }
 }
 
 void _removeTemplateChild(Node parent, Node child) {
   child._templateInstance = null;
   if (child is Element && child.isTemplate) {
     // Make sure we stop observing when we remove an element.
     var templateIterator = child._templateIterator;
@@ skipping 154 matching lines @@
     _sub.cancel();
     _sub = null;
   }
 
   void abandon() {
     unobserve();
     _valueBinding.cancel();
     inputs.dispose();
   }
 }