Custom Syntax's are now enabled via template.bindingDelegate =

pkg/mdv/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;
 
 // This code is a port of Model-Driven-Views:
 // https://github.com/polymer-project/mdv
 // The code mostly comes from src/template_element.js
 
 // 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
 bool _toBoolean(value) => null != value && false != value;
 
-Node _createDeepCloneAndDecorateTemplates(Node node, String syntax) {
+Node _createDeepCloneAndDecorateTemplates(Node node, BindingDelegate delegate) {
   var clone = node.clone(false); // Shallow clone.
   if (clone is Element && clone.isTemplate) {
     TemplateElement.decorate(clone, node);
-    if (syntax != null) {
-      clone.attributes.putIfAbsent('syntax', () => syntax);
+    if (delegate != null) {
+      _mdv(clone)._bindingDelegate = delegate;
     }
   }
 
   for (var c = node.firstChild; c != null; c = c.nextNode) {
-    clone.append(_createDeepCloneAndDecorateTemplates(c, syntax));
+    clone.append(_createDeepCloneAndDecorateTemplates(c, delegate));
   }
   return clone;
 }
 
-void _addBindings(Node node, model, [CustomBindingSyntax delegate]) {
+void _addBindings(Node node, model, [BindingDelegate delegate]) {
   if (node is Element) {
     _addAttributeBindings(node, model, delegate);
   } else if (node is Text) {
     _parseAndBind(node, 'text', node.text, model, delegate);
   }
 
   for (var c = node.firstChild; c != null; c = c.nextNode) {
     _addBindings(c, model, delegate);
   }
 }
 
 void _addAttributeBindings(Element element, model, delegate) {
   element.attributes.forEach((name, value) {
     if (value == '' && (name == 'bind' || name == 'repeat')) {
       value = '{{}}';
     }
     _parseAndBind(element, name, value, model, delegate);
   });
 }
 
 void _parseAndBind(Node node, String name, String text, model,
-    CustomBindingSyntax delegate) {
+    BindingDelegate delegate) {
 
   var tokens = _parseMustacheTokens(text);
   if (tokens.length == 0 || (tokens.length == 1 && tokens[0].isText)) {
     return;
   }
 
   // If this is a custom element, give the .xtag a change to bind.
   node = _nodeOrCustom(node);
 
   if (tokens.length == 1 && tokens[0].isBinding) {
@@ skipping 24 matching lines @@
       }
     }
 
     return newValue.toString();
   };
 
   node.bind(name, replacementBinding, 'value');
 }
 
 void _bindOrDelegate(node, name, model, String path,
-    CustomBindingSyntax delegate) {
+    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);
@@ skipping 152 matching lines @@
     var parent = _templateElement.parentNode;
     while (terminator != previousTerminator) {
       var node = previousTerminator.nextNode;
       if (node == terminator) terminator = previousTerminator;
       node.remove();
       instanceNodes.add(node);
     }
     return instanceNodes;
   }
 
-  getInstanceModel(model, String syntax) {
-    var delegate = TemplateElement.syntax[syntax];
+  getInstanceModel(model, BindingDelegate delegate) {
     if (delegate != null) {
       return delegate.getInstanceModel(_templateElement, model);
     }
     return model;
   }
 
-  List<Node> getInstanceNodes(model, String syntax, IdentityMap instanceCache) {
+  List<Node> getInstanceNodes(model, BindingDelegate delegate,
+      IdentityMap instanceCache) {
+
     var instanceNodes = instanceCache.remove(model);
     if (instanceNodes != null) return instanceNodes;
 
-    var fragment = _templateElement.createInstance(model, syntax);
+    var fragment = _templateElement.createInstance(model, delegate);
     instanceNodes = fragment.nodes.toList();
     fragment.nodes.clear();
     return instanceNodes;
   }
 
   void _handleChanges(Iterable<ChangeRecord> splices) {
     if (closed) return;
 
     splices = splices.where((s) => s is ListChangeRecord);
 
     var template = _templateElement;
-    var syntax = template.attributes['syntax'];
+    var delegate = template.bindingDelegate;
 
     if (template.parentNode == null || template.document.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;
     }
 
     // TODO(jmesserly): IdentityMap matches JS semantics, but it's O(N) right
     // now. See http://dartbug.com/4161.
     var instanceCache = new IdentityMap();
     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;
         instanceCache[model] = instanceNodes;
       }
 
       removeDelta -= splice.addedCount;
     }
 
     for (var splice in splices) {
       for (var addIndex = splice.index;
           addIndex < splice.index + splice.addedCount;
           addIndex++) {
 
-        var model = getInstanceModel(iteratedValue[addIndex], syntax);
+        var model = getInstanceModel(iteratedValue[addIndex], delegate);
 
-        var instanceNodes = getInstanceNodes(model, syntax, instanceCache);
+        var instanceNodes = getInstanceNodes(model, delegate, instanceCache);
         insertInstanceAt(addIndex, instanceNodes);
       }
     }
 
     for (var instanceNodes in instanceCache.values) {
       instanceNodes.forEach(_unbindAllRecursively);
     }
   }
 
   void unobserve() {
@@ skipping 22 matching lines @@
         nodeExt._templateIterator = null;
       }
     }
 
     _nodeOrCustom(node).unbindAll();
     for (var c = node.firstChild; c != null; c = c.nextNode) {
       _unbindAllRecursively(c);
     }
   }
 }