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

pkg/mdv/test/template_element_test.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.
 
 library template_element_test;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:html';
 import 'dart:math' as math;
@@ skipping 45 matching lines @@
     root.innerHtml = s;
     testDiv.append(div);
 
     for (var node in root.queryAll('*')) {
       if (node.isTemplate) TemplateElement.decorate(node);
     }
 
     return root;
   }
 
-  recursivelySetTemplateModel(element, model) {
-    for (var node in element.queryAll('*')) {
-      if (node.isTemplate) node.model = model;
-    }
-  }
-
-  dispatchEvent(type, target) {
-    target.dispatchEvent(new Event(type, cancelable: false));
-  }
-
   var expando = new Expando('observeTest');
   void addExpandos(node) {
     while (node != null) {
       expando[node] = node.text;
       node = node.nextNode;
     }
   }
 
   void checkExpandos(node) {
     expect(node, isNotNull);
@@ skipping 1488 matching lines @@
   // https://github.com/toolkitchen/mdv/issues/8
   observeTest('UnbindingInNestedBind', () {
     var div = createTestHtml(
       '<template bind="{{outer}}" if="{{outer}}" syntax="testHelper">'
         '<template bind="{{inner}}" if="{{inner}}">'
           '{{ age }}'
         '</template>'
       '</template>');
 
     var syntax = new UnbindingInNestedBindSyntax();
-    TemplateElement.syntax['testHelper'] = syntax;
-    try {
-      var model = toSymbolMap({
-        'outer': {
-          'inner': {
-            'age': 42
-          }
+    var model = toSymbolMap({
+      'outer': {
+        'inner': {
+          'age': 42
         }
-      });
+      }
+    });
 
-      recursivelySetTemplateModel(div, model);
+    recursivelySetTemplateModel(div, model, syntax);
 
-      deliverChanges(model);
-      expect(syntax.count, 1);
+    deliverChanges(model);
+    expect(syntax.count, 1);
 
-      var inner = model[sym('outer')][sym('inner')];
-      model[sym('outer')] = null;
+    var inner = model[sym('outer')][sym('inner')];
+    model[sym('outer')] = null;
 
-      deliverChanges(model);
-      expect(syntax.count, 1);
+    deliverChanges(model);
+    expect(syntax.count, 1);
 
-      model[sym('outer')] = toSymbols({'inner': {'age': 2}});
-      syntax.expectedAge = 2;
+    model[sym('outer')] = toSymbols({'inner': {'age': 2}});
+    syntax.expectedAge = 2;
 
-      deliverChanges(model);
-      expect(syntax.count, 2);
-    } finally {
-      TemplateElement.syntax.remove('testHelper');
-    }
+    deliverChanges(model);
+    expect(syntax.count, 2);
   });
 
   // https://github.com/toolkitchen/mdv/issues/8
   observeTest('DontCreateInstancesForAbandonedIterators', () {
     var div = createTestHtml(
       '<template bind="{{}} {{}}">'
         '<template bind="{{}}">Foo'
         '</template>'
       '</template>');
     recursivelySetTemplateModel(div, null);
     performMicrotaskCheckpoint();
   });
 
   observeTest('CreateInstance', () {
-    TemplateElement.syntax['Test'] = new TestBindingSyntax();
-    try {
-      var div = createTestHtml(
-        '<template bind="{{a}}">'
-          '<template bind="{{b}}">'
-            '{{ foo }}:{{ replaceme }}'
-          '</template>'
-        '</template>');
-      var outer = div.nodes.first;
-      var model = toSymbolMap({'b': {'foo': 'bar'}});
+    var div = createTestHtml(
+      '<template bind="{{a}}">'
+        '<template bind="{{b}}">'
+          '{{ foo }}:{{ replaceme }}'
+        '</template>'
+      '</template>');
+    var outer = div.nodes.first;
+    var model = toSymbolMap({'b': {'foo': 'bar'}});
 
-      var host = new DivElement();
-      var instance = outer.createInstance(model, 'Test');
-      expect(outer.content.nodes.first, instance.nodes.first.ref);
-      expect(instance.firstChild.attributes['syntax'], 'Test');
+    var host = new DivElement();
+    var instance = outer.createInstance(model, new TestBindingSyntax());
+    expect(outer.content.nodes.first, instance.nodes.first.ref);
 
-      host.append(instance);
-      performMicrotaskCheckpoint();
-      expect(host.firstChild.nextNode.text, 'bar:replaced');
-    } finally {
-      TemplateElement.syntax.remove('Test');
-    }
+    host.append(instance);
+    performMicrotaskCheckpoint();
+    expect(host.firstChild.nextNode.text, 'bar:replaced');
   });
 
   observeTest('Bootstrap', () {
     var div = new DivElement();
     div.innerHtml =
       '<template>'
         '<div></div>'
         '<template>'
           'Hello'
         '</template>'
@@ skipping 34 matching lines @@
     expect(called, false);
 
     recursivelySetTemplateModel(div, null);
     performMicrotaskCheckpoint();
     expect(called, true);
 
     sub.cancel();
   });
 }
 
-class TestBindingSyntax extends CustomBindingSyntax {
+class TestBindingSyntax extends BindingDelegate {
   getBinding(model, String path, name, node) {
     if (path.trim() == 'replaceme') return new ObservableBox('replaced');
     return null;
   }
 }
 
-class UnbindingInNestedBindSyntax extends CustomBindingSyntax {
+class UnbindingInNestedBindSyntax extends BindingDelegate {
   int expectedAge = 42;
   int count = 0;
 
   getBinding(model, path, name, node) {
     if (name != 'text' || path != 'age')
       return;
 
     expect(model[sym('age')], expectedAge);
     count++;
   }
@@ skipping 39 matching lines @@
       k = k is String ? sym(k) : _deepToSymbol(k);
       result[k] = _deepToSymbol(v);
     });
     return result;
   }
   if (value is Iterable) {
     return value.map(_deepToSymbol).toList();
   }
   return value;
 }