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

pkg/mdv/test/binding_syntax_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 binding_syntax_test;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:html';
 import 'package:mdv/mdv.dart' as mdv;
@@ skipping 34 matching lines @@
     div.innerHtml = s;
     testDiv.append(div);
 
     for (var node in div.queryAll('*')) {
       if (node.isTemplate) TemplateElement.decorate(node);
     }
 
     return div;
   }
 
-  recursivelySetTemplateModel(element, model) {
-    for (var node in element.queryAll('*')) {
-      if (node.isTemplate) node.model = model;
-    }
-  }
-
   observeTest('Registration', () {
     var model = fooModel('bar');
 
     var testSyntax = new TestBindingSyntax();
-    TemplateElement.syntax['Test'] = testSyntax;
-    try {
-      var div = createTestHtml(
-          '<template bind syntax="Test">{{ foo }}' +
-          '<template bind>{{ foo }}</template></template>');
-      recursivelySetTemplateModel(div, model);
-      performMicrotaskCheckpoint();
-      expect(div.nodes.length, 4);
-      expect(div.nodes.last.text, 'bar');
-      expect(div.nodes[2].tagName, 'TEMPLATE');
-      expect(div.nodes[2].attributes['syntax'], 'Test');
+    var div = createTestHtml('<template bind>{{ foo }}'
+        '<template bind>{{ foo }}</template></template>');
+    recursivelySetTemplateModel(div, model, testSyntax);
+    performMicrotaskCheckpoint();
+    expect(div.nodes.length, 4);
+    expect(div.nodes.last.text, 'bar');
+    expect(div.nodes[2].tagName, 'TEMPLATE');
 
-      expect(testSyntax.log, [
-        [model, '', 'bind', 'TEMPLATE'],
-        [model, 'foo', 'text', null],
-        [model, '', 'bind', 'TEMPLATE'],
-        [model, 'foo', 'text', null],
-      ]);
-    } finally {
-      TemplateElement.syntax.remove('Test');
-    }
+    expect(testSyntax.log, [
+      [model, '', 'bind', 'TEMPLATE'],
+      [model, 'foo', 'text', null],
+      [model, '', 'bind', 'TEMPLATE'],
+      [model, 'foo', 'text', null],
+    ]);
   });
 
   observeTest('getInstanceModel', () {
     var model = toObservable([fooModel(1), fooModel(2), fooModel(3)]);
 
     var testSyntax = new TestModelSyntax();
     testSyntax.altModels.addAll([fooModel('a'), fooModel('b'), fooModel('c')]);
 
-    TemplateElement.syntax['Test'] = testSyntax;
-    try {
+    var div = createTestHtml('<template repeat>{{ foo }}</template>');
 
-      var div = createTestHtml(
-          '<template repeat syntax="Test">' +
-          '{{ foo }}</template>');
+    var template = div.nodes[0];
+    recursivelySetTemplateModel(div, model, testSyntax);
+    performMicrotaskCheckpoint();
 
-      var template = div.nodes[0];
-      recursivelySetTemplateModel(div, model);
-      performMicrotaskCheckpoint();
+    expect(div.nodes.length, 4);
+    expect(div.nodes[0].tagName, 'TEMPLATE');
+    expect(div.nodes[1].text, 'a');
+    expect(div.nodes[2].text, 'b');
+    expect(div.nodes[3].text, 'c');
 
-      expect(div.nodes.length, 4);
-      expect(div.nodes[0].tagName, 'TEMPLATE');
-      expect(div.nodes[1].text, 'a');
-      expect(div.nodes[2].text, 'b');
-      expect(div.nodes[3].text, 'c');
-
-      expect(testSyntax.log, [
-        [template, model[0]],
-        [template, model[1]],
-        [template, model[2]],
-      ]);
-
-    } finally {
-      TemplateElement.syntax.remove('Test');
-    }
+    expect(testSyntax.log, [
+      [template, model[0]],
+      [template, model[1]],
+      [template, model[2]],
+    ]);
   });
 
   observeTest('Basic', () {
     var model = fooModel(2, 4);
-
-    TemplateElement.syntax['2x'] = new TimesTwoSyntax();
-
     var div = createTestHtml(
         '<template bind syntax="2x">'
         '{{ foo }} + {{ 2x: bar }} + {{ 4x: bar }}</template>');
-    recursivelySetTemplateModel(div, model);
+    recursivelySetTemplateModel(div, model, new TimesTwoSyntax());
     performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, '2 + 8 + ');
 
     model.foo = 4;
     model.bar = 8;
     performMicrotaskCheckpoint();
     expect(div.nodes.last.text, '4 + 16 + ');
-
-    TemplateElement.syntax.remove('2x');
-  });
-
-  observeTest('Different Sub-Template Syntax', () {
-    var model = fooModel('bar');
-
-    TemplateElement.syntax['Test'] = new TestBindingSyntax();
-    TemplateElement.syntax['Test2'] = new TestBindingSyntax();
-
-    var div = createTestHtml(
-        '<template bind syntax="Test">{{ foo }}'
-        '<template bind syntax="Test2">{{ foo }}</template></template>');
-    recursivelySetTemplateModel(div, model);
-    performMicrotaskCheckpoint();
-    expect(div.nodes.length, 4);
-    expect(div.nodes.last.text, 'bar');
-    expect(div.nodes[2].tagName, 'TEMPLATE');
-    expect(div.nodes[2].attributes['syntax'], 'Test2');
-
-    var testLog = TemplateElement.syntax['Test'].log;
-    var test2Log = TemplateElement.syntax['Test2'].log;
-
-    expect(testLog, [
-      [model, '', 'bind', 'TEMPLATE'],
-      [model, 'foo', 'text', null],
-      [model, '', 'bind', 'TEMPLATE']
-    ]);
-
-    expect(test2Log, [[model, 'foo', 'text', null]]);
-
-    TemplateElement.syntax.remove('Test');
-    TemplateElement.syntax.remove('Test2');
   });
 }
 
 // TODO(jmesserly): mocks would be cleaner here.
 
-class TestBindingSyntax extends CustomBindingSyntax {
+class TestBindingSyntax extends BindingDelegate {
   var log = [];
 
   getBinding(model, String path, String name, Node node) {
     log.add([model, path, name, node is Element ? node.tagName : null]);
   }
 }
 
-class TestModelSyntax extends CustomBindingSyntax {
+class TestModelSyntax extends BindingDelegate {
   var log = [];
   var altModels = new ListQueue();
 
   getInstanceModel(template, model) {
     log.add([template, model]);
     return altModels.removeFirst();
   }
 }
 
 // Note: this isn't a very smart whitespace handler. A smarter one would only
 // trim indentation, not all whitespace.
 // See "trimOrCompact" in the web_ui Pub package.
-class WhitespaceRemover extends CustomBindingSyntax {
+class WhitespaceRemover extends BindingDelegate {
   int trimmed = 0;
   int removed = 0;
 
   DocumentFragment getInstanceFragment(Element template) {
     var instance = template.createInstance();
     var walker = new TreeWalker(instance, NodeFilter.SHOW_TEXT);
 
     var toRemove = [];
     while (walker.nextNode() != null) {
       var node = walker.currentNode;
       var text = node.text.replaceAll('\n', '').trim();
       if (text.length != node.text.length) {
         if (text.length == 0) {
           toRemove.add(node);
         } else {
           trimmed++;
           node.text = text;
         }
       }
     }
 
     for (var node in toRemove) node.remove();
     removed += toRemove.length;
 
     return instance;
   }
 }
 
-class TimesTwoSyntax extends CustomBindingSyntax {
+class TimesTwoSyntax extends BindingDelegate {
   getBinding(model, path, name, node) {
     path = path.trim();
     if (!path.startsWith('2x:')) return null;
 
     path = path.substring(3);
     return new CompoundBinding((values) => values['value'] * 2)
         ..bind('value', model, path);
   }
 }