Rename mdv -> template_binding, remove experiemntal apis from dart:html

pkg/template_binding/lib/src/template_iterator.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 mdv;
+part of template_binding;
 
-// This code is a port of Model-Driven-Views:
-// https://github.com/polymer-project/mdv
-// The code mostly comes from src/template_element.js
+// This code is a port of what was formerly known as Model-Driven-Views, now
+// located at:
+//     https://github.com/polymer/TemplateBinding
+//     https://github.com/polymer/NodeBind
 
 // TODO(jmesserly): not sure what kind of boolean conversion rules to
 // apply for template data-binding. HTML attributes are true if they're
 // present. However Dart only treats "true" as true. Since this is HTML we'll
 // use something closer to the HTML rules: null (missing) and false are false,
-// everything else is true. See: https://github.com/polymer-project/mdv/issues/59
+// everything else is true.
+// See: https://github.com/polymer/TemplateBinding/issues/59
 bool _toBoolean(value) => null != value && false != value;
 
 Node _createDeepCloneAndDecorateTemplates(Node node, BindingDelegate delegate) {
   var clone = node.clone(false); // Shallow clone.
-  if (clone is Element && clone.isTemplate) {
-    TemplateElement.decorate(clone, node);
+  if (isSemanticTemplate(clone)) {
+    TemplateBindExtension.decorate(clone, node);
     if (delegate != null) {
-      _mdv(clone)._bindingDelegate = delegate;
+      templateBindFallback(clone)._bindingDelegate = delegate;
     }
   }
 
   for (var c = node.firstChild; c != null; c = c.nextNode) {
     clone.append(_createDeepCloneAndDecorateTemplates(c, delegate));
   }
   return clone;
 }
 
 void _addBindings(Node node, model, [BindingDelegate delegate]) {
@@ skipping 11 matching lines @@
 
   for (var c = node.firstChild; c != null; c = c.nextNode) {
     _addBindings(c, model, delegate);
   }
 }
 
 List _parseAttributeBindings(Element element) {
   var bindings = null;
   var ifFound = false;
   var bindFound = false;
-  var isTemplateNode = element.isTemplate;
+  var isTemplateNode = isSemanticTemplate(element);
 
   element.attributes.forEach((name, value) {
     if (isTemplateNode) {
       if (name == 'if') {
         ifFound = true;
       } else if (name == 'bind' || name == 'repeat') {
         bindFound = true;
         if (value == '') value = '{{}}';
       }
     }
@@ skipping 18 matching lines @@
     BindingDelegate delegate) {
 
   for (var i = 0; i < bindings.length; i += 2) {
     _setupBinding(node, bindings[i], bindings[i + 1], model, delegate);
   }
 }
 
 void _setupBinding(Node node, String name, List tokens, model,
     BindingDelegate delegate) {
 
-  // If this is a custom element, give the .xtag a change to bind.
-  node = _nodeOrCustom(node);
-
   if (_isSimpleBinding(tokens)) {
     _bindOrDelegate(node, name, model, tokens[1], delegate);
     return;
   }
 
   // TODO(jmesserly): MDV caches the closure on the tokens, but I'm not sure
   // why they do that instead of just caching the entire CompoundBinding object
   // and unbindAll then bind to the new model.
   var replacementBinding = new CompoundBinding()
       ..scheduled = true
@@ skipping 15 matching lines @@
   };
 
   for (var i = 1; i < tokens.length; i += 2) {
     // TODO(jmesserly): not sure if this index is correct. See my comment here:
     // https://github.com/Polymer/mdv/commit/f1af6fe683fd06eed2a7a7849f01c227db12cda3#L0L1035
     _bindOrDelegate(replacementBinding, i, model, tokens[i], delegate);
   }
 
   replacementBinding.resolve();
 
-  node.bind(name, replacementBinding, 'value');
+  nodeBind(node).bind(name, replacementBinding, 'value');
 }
 
 void _bindOrDelegate(node, name, model, String path,
     BindingDelegate delegate) {
 
   if (delegate != null) {
     var delegateBinding = delegate.getBinding(model, path, name, node);
     if (delegateBinding != null) {
       model = delegateBinding;
       path = 'value';
     }
   }
 
-  node.bind(name, model, path);
+  if (node is CompoundBinding) {
+    node.bind(name, model, path);
+  } else {
+    nodeBind(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 InputElement does.
- */
-// TODO(jmesserly): remove this when we can extend Element for real.
-_nodeOrCustom(node) => node is Element ? node.xtag : node;
-
 /** True if and only if [tokens] is of the form `['', path, '']`. */
 bool _isSimpleBinding(List<String> tokens) =>
     tokens.length == 3 && tokens[0].isEmpty && tokens[2].isEmpty;
 
 /**
  * Parses {{ mustache }} bindings.
  *
  * Returns null if there are no matches. Otherwise returns
  * [TEXT, (PATH, TEXT)+] if there is at least one mustache.
  */
@@ skipping 27 matching lines @@
 void _addTemplateInstanceRecord(fragment, model) {
   if (fragment.firstChild == null) {
     return;
   }
 
   var instanceRecord = new TemplateInstance(
       fragment.firstChild, fragment.lastChild, model);
 
   var node = instanceRecord.firstNode;
   while (node != null) {
-    _mdv(node)._templateInstance = instanceRecord;
+    nodeBindFallback(node)._templateInstance = instanceRecord;
     node = node.nextNode;
   }
 }
 
 
 class _TemplateIterator {
   final Element _templateElement;
   final List<Node> terminators = [];
   CompoundBinding inputs;
   List iteratedValue;
@@ skipping 34 matching lines @@
     }
 
     var splices = calculateSplices(
         iteratedValue != null ? iteratedValue : [],
         oldValue != null ? oldValue : []);
 
     if (splices.length > 0) _handleChanges(splices);
 
     if (inputs.length == 0) {
       close();
-      _mdv(_templateElement)._templateIterator = null;
+      templateBindFallback(_templateElement)._templateIterator = null;
     }
   }
 
   Node getTerminatorAt(int index) {
     if (index == -1) return _templateElement;
     var terminator = terminators[index];
-    if (terminator is Element && (terminator as Element).isTemplate &&
+    if (isSemanticTemplate(terminator) &&
         !identical(terminator, _templateElement)) {
-      var subIterator = _mdv(terminator)._templateIterator;
+      var subIterator = templateBindFallback(terminator)._templateIterator;
       if (subIterator != null) {
         return subIterator.getTerminatorAt(subIterator.terminators.length - 1);
       }
     }
 
     return terminator;
   }
 
   void insertInstanceAt(int index, DocumentFragment fragment,
         List<Node> instanceNodes) {
@@ skipping 39 matching lines @@
   }
 
   getInstanceModel(model, BindingDelegate delegate) {
     if (delegate != null) {
       return delegate.getInstanceModel(_templateElement, model);
     }
     return model;
   }
 
   DocumentFragment getInstanceFragment(model, BindingDelegate delegate) {
-    return _templateElement.createInstance(model, delegate);
+    return templateBind(_templateElement).createInstance(model, delegate);
   }
 
   void _handleChanges(Iterable<ChangeRecord> splices) {
     if (closed) return;
 
     splices = splices.where((s) => s is ListChangeRecord);
 
     var template = _templateElement;
-    var delegate = template.bindingDelegate;
+    var delegate = templateBind(template).bindingDelegate;
 
     if (template.parentNode == null || template.ownerDocument.window == null) {
       close();
       // TODO(jmesserly): MDV calls templateIteratorTable.delete(this) here,
       // but I think that's a no-op because only nodes are used as keys.
       // See https://github.com/Polymer/mdv/pull/114.
       return;
     }
 
     var instanceCache = new HashMap(equals: identical);
     var removeDelta = 0;
     for (var splice in splices) {
       for (int i = 0; i < splice.removedCount; i++) {
         var instanceNodes = extractInstanceAt(splice.index + removeDelta);
         if (instanceNodes.length == 0) continue;
-        var model = _mdv(instanceNodes.first)._templateInstance.model;
+        var model = nodeBindFallback(instanceNodes.first)
+            ._templateInstance.model;
         instanceCache[model] = instanceNodes;
       }
 
       removeDelta -= splice.addedCount;
     }
 
     for (var splice in splices) {
       for (var addIndex = splice.index;
           addIndex < splice.index + splice.addedCount;
           addIndex++) {
@@ skipping 24 matching lines @@
   void close() {
     if (closed) return;
 
     unobserve();
     inputs.close();
     terminators.clear();
     closed = true;
   }
 
   static void _unbindAllRecursively(Node node) {
-    var nodeExt = _mdv(node);
+    var nodeExt = nodeBindFallback(node);
     nodeExt._templateInstance = null;
-    if (node is Element && (node as Element).isTemplate) {
+    if (isSemanticTemplate(node)) {
       // Make sure we stop observing when we remove an element.
       var templateIterator = nodeExt._templateIterator;
       if (templateIterator != null) {
         templateIterator.close();
         nodeExt._templateIterator = null;
       }
     }
 
-    _nodeOrCustom(node).unbindAll();
+    nodeBind(node).unbindAll();
     for (var c = node.firstChild; c != null; c = c.nextNode) {
       _unbindAllRecursively(c);
     }
   }
 }