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

pkg/template_binding/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;
+library template_binding.test.template_element_test;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:html';
 import 'dart:math' as math;
-import 'package:mdv/mdv.dart' as mdv;
 import 'package:observe/observe.dart';
+import 'package:template_binding/template_binding.dart';
 import 'package:unittest/html_config.dart';
 import 'package:unittest/unittest.dart';
-import 'mdv_test_utils.dart';
+import 'utils.dart';
 
 // Note: this file ported from
 // https://github.com/toolkitchen/mdv/blob/master/tests/template_element.js
 // TODO(jmesserly): submit a small cleanup patch to original. I fixed some
 // cases where "div" and "t" were unintentionally using the JS global scope;
 // look for "assertNodesAre".
 
 main() {
-  mdv.initialize();
   useHtmlConfiguration();
   group('Template Element', templateElementTests);
 }
 
 templateElementTests() {
-  var testDiv;
-
   setUp(() {
     document.body.append(testDiv = new DivElement());
   });
 
   tearDown(() {
     testDiv.remove();
     testDiv = null;
   });
 
-  createTestHtml(s) {
-    var div = new DivElement();
-    div.setInnerHtml(s, treeSanitizer: new NullTreeSanitizer());
-    testDiv.append(div);
-
-    for (var node in div.queryAll('*')) {
-      if (node.isTemplate) TemplateElement.decorate(node);
-    }
-
-    return div;
-  }
-
-  createShadowTestHtml(s) {
-    var div = new DivElement();
-    var root = div.createShadowRoot();
-    root.innerHtml = s;
-    testDiv.append(div);
-
-    for (var node in root.queryAll('*')) {
-      if (node.isTemplate) TemplateElement.decorate(node);
-    }
-
-    return root;
-  }
-
   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 500 matching lines @@
 
     expect(div.children.length, 4);
     expect(div.nodes.length, 4);
 
     expect(div.nodes[1].tagName, 'P');
     expect(div.nodes[3].tagName, 'P');
   });
 
   observeTest('DefaultStyles', () {
     var t = new Element.tag('template');
-    TemplateElement.decorate(t);
+    TemplateBindExtension.decorate(t);
 
     document.body.append(t);
     expect(t.getComputedStyle().display, 'none');
 
     t.remove();
   });
 
 
   observeTest('Bind', () {
     var div = createTestHtml('<template bind="{{}}">Hi {{ name }}</template>');
     var model = toObservable({'name': 'Leela'});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes[1].text, 'Hi Leela');
   });
 
   observeTest('BindImperative', () {
     var div = createTestHtml(
         '<template>'
           'Hi {{ name }}'
         '</template>');
     var t = div.nodes.first;
 
     var model = toObservable({'name': 'Leela'});
-    t.bind('bind', model, '');
+    nodeBind(t).bind('bind', model, '');
 
     deliverChanges(model);
     expect(div.nodes[1].text, 'Hi Leela');
   });
 
   observeTest('BindPlaceHolderHasNewLine', () {
     var div = createTestHtml('<template bind="{{}}">Hi {{\nname\n}}</template>');

[Siggi Cherem (dart-lang), 2013/10/23 01:41:11]

while you are here, consider wrapping at 80

[Jennifer Messerly, 2013/10/23 02:05:02]

Done.

     var model = toObservable({'name': 'Leela'});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(div.nodes[1].text, 'Hi Leela');
   });
 
   observeTest('BindWithRef', () {
     var id = 't${new math.Random().nextDouble()}';
     var div = createTestHtml(
         '<template id="$id">'
           'Hi {{ name }}'
         '</template>'
         '<template ref="$id" bind="{{}}"></template>');
 
     var t1 = div.nodes.first;
     var t2 = div.nodes[1];
 
-    expect(t2.ref, t1);
+    expect(templateBind(t2).ref, t1);
 
     var model = toObservable({'name': 'Fry'});
     recursivelySetTemplateModel(div, model);
 
     deliverChanges(model);
     expect(t2.nextNode.text, 'Hi Fry');
   });
 
   observeTest('BindChanged', () {
     var model = toObservable({
       'XX': {'name': 'Leela', 'title': 'Captain'},
       'XY': {'name': 'Fry', 'title': 'Delivery boy'},
       'XZ': {'name': 'Zoidberg', 'title': 'Doctor'}
     });
 
     var div = createTestHtml(
         '<template bind="{{ XX }}">Hi {{ name }}</template>');
 
     recursivelySetTemplateModel(div, model);
 
     var t = div.nodes.first;
     deliverChanges(model);
 
     expect(div.nodes.length, 2);
     expect(t.nextNode.text, 'Hi Leela');
 
-    t.bind('bind', model, 'XZ');
+    nodeBind(t).bind('bind', model, 'XZ');
     deliverChanges(model);
 
     expect(div.nodes.length, 2);
     expect(t.nextNode.text, 'Hi Zoidberg');
   });
 
   assertNodesAre(div, [arguments]) {
     var expectedLength = arguments.length;
     expect(div.nodes.length, expectedLength + 1);
 
@@ skipping 177 matching lines @@
 
   observeTest('Checked', () {
     var div = createTestHtml(
         '<template>'
           '<input type="checkbox" checked="{{a}}">'
         '</template>');
     var t = div.nodes.first;
     var m = toObservable({
       'a': true
     });
-    t.bind('bind', m, '');
+    nodeBind(t).bind('bind', m, '');
     deliverChanges(m);
 
     var instanceInput = t.nextNode;
     expect(instanceInput.checked, true);
 
     instanceInput.click();
     expect(instanceInput.checked, false);
 
     instanceInput.click();
     expect(instanceInput.checked, true);
@@ skipping 243 matching lines @@
     var select = div.nodes[0].nextNode;
     expect(select.nodes.length, 2);
 
     scheduleMicrotask(expectAsync0(() {
       scheduleMicrotask(expectAsync0(() {
         // TODO(jmesserly): this should be called sooner.
         expect(select.selectedIndex, 1);
       }));
     }));
     expect(select.nodes[0].tagName, 'TEMPLATE');
-    expect(select.nodes[0].ref.content.nodes[0].tagName, 'OPTGROUP');
+    expect(templateBind(select.nodes[0]).ref.content.nodes[0].tagName,
+        'OPTGROUP');
 
     var optgroup = select.nodes[1];
     expect(optgroup.nodes[0].tagName, 'TEMPLATE');
     expect(optgroup.nodes[1].tagName, 'OPTION');
     expect(optgroup.nodes[1].text, '0');
     expect(optgroup.nodes[2].tagName, 'OPTION');
     expect(optgroup.nodes[2].text, '1');
   });
 
   observeTest('NestedIterateTableMixedSemanticNative', () {
@@ skipping 283 matching lines @@
     var div = createTestHtml('<template repeat>{{ foo }}</template>');
 
     var m = toObservable([{ 'foo': 'bar' }, { 'foo': 'bat'}]);
     recursivelySetTemplateModel(div, m);
     performMicrotaskCheckpoint();
 
     var observer = new MutationObserver((records, _) {});
     observer.observe(div, childList: true);
 
     var template = div.firstChild;
-    template.bind('repeat', toObservable(m.toList()), '');
+    nodeBind(template).bind('repeat', toObservable(m.toList()), '');
     performMicrotaskCheckpoint();
     var records = observer.takeRecords();
     expect(records.length, 0);
   });
 
   observeTest('RecursiveRef', () {
     var div = createTestHtml(
         '<template bind>'
           '<template id=src>{{ foo }}</template>'
           '<template bind ref=src></template>'
@@ skipping 24 matching lines @@
         // Note: this will use the Map "length" property, not the "length" key.
         {'length': 42, 'c': 123}
       ]
     });
     recursivelySetTemplateModel(div, m);
     deliverChanges(m);
 
     expect(div.nodes.length, 2);
     expect(div.nodes[1].text, '3');
 
-    template.unbind('bind');
-    template.bind('repeat', m, 'a');
+    nodeBind(template)
+        ..unbind('bind')
+        ..bind('repeat', m, 'a');
     deliverChanges(m);
     expect(div.nodes.length, 4);
     expect(div.nodes[1].text, '0');
     expect(div.nodes[2].text, '1');
     expect(div.nodes[3].text, '2');
 
-    template.unbind('repeat');
-    template.bind('bind', m, 'a.1.b');
+    nodeBind(template).unbind('repeat');
+    nodeBind(template).bind('bind', m, 'a.1.b');
 
     deliverChanges(m);
     expect(div.nodes.length, 2);
     expect(div.nodes[1].text, '4');
   });
 
   observeTest('ChangeRefId', () {
     var div = createTestHtml(
         '<template id="a">a:{{ }}</template>'
         '<template id="b">b:{{ }}</template>'
@@ skipping 67 matching lines @@
       deliverChanges(model);
       expect(root.nodes[1].text, 'Hi Leela');
     }
   });
 
   observeTest('BindShadowDOM createInstance', () {
     if (ShadowRoot.supported) {
       var model = toObservable({'name': 'Leela'});
       var template = new Element.html('<template>Hi {{ name }}</template>');
       var root = createShadowTestHtml('');
-      root.nodes.add(template.createInstance(model));
+      root.nodes.add(templateBind(template).createInstance(model));
 
       performMicrotaskCheckpoint();
       expect(root.text, 'Hi Leela');
 
       model['name'] = 'Fry';
       performMicrotaskCheckpoint();
       expect(root.text, 'Hi Fry');
     }
   });
 
@@ skipping 54 matching lines @@
     performMicrotaskCheckpoint();
   });
 
   observeTest('CreateInstance', () {
     var div = createTestHtml(
       '<template bind="{{a}}">'
         '<template bind="{{b}}">'
           '{{ foo }}:{{ replaceme }}'
         '</template>'
       '</template>');
-    var outer = div.nodes.first;
+    var outer = templateBind(div.nodes.first);
     var model = toObservable({'b': {'foo': 'bar'}});
 
     var host = new DivElement();
     var instance = outer.createInstance(model, new TestBindingSyntax());
-    expect(outer.content.nodes.first, instance.nodes.first.ref);
+    expect(outer.content.nodes.first,
+        templateBind(instance.nodes.first).ref);
 
     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>'
       '</template>';
 
-    TemplateElement.bootstrap(div);
-    var template = div.nodes.first;
+    TemplateBindExtension.bootstrap(div);
+    var template = templateBind(div.nodes.first);
     expect(template.content.nodes.length, 2);
-    var template2 = template.content.nodes.first.nextNode;
+    var template2 = templateBind(template.content.nodes.first.nextNode);
     expect(template2.content.nodes.length, 1);
     expect(template2.content.nodes.first.text, 'Hello');
 
     template = new Element.tag('template');
     template.innerHtml =
       '<template>'
         '<div></div>'
         '<template>'
           'Hello'
         '</template>'
       '</template>';
 
-    TemplateElement.bootstrap(template);
+    TemplateBindExtension.bootstrap(template);
     template2 = template.content.nodes.first;
     expect(template2.content.nodes.length, 2);
     var template3 = template2.content.nodes.first.nextNode;
     expect(template3.content.nodes.length, 1);
     expect(template3.content.nodes.first.text, 'Hello');
   });
-
-  observeTest('instanceCreated hack', () {
-    var called = false;
-
-    callback(node) {
-      called = true;
-      expect(node.nodeType, Node.DOCUMENT_FRAGMENT_NODE);
-    }
-    mdv.instanceCreated.add(callback);
-
-    var div = createTestHtml('<template bind="{{}}">Foo</template>');
-    expect(called, false);
-
-    recursivelySetTemplateModel(div, null);
-    performMicrotaskCheckpoint();
-    expect(called, true);
-
-    mdv.instanceCreated.remove(callback);
-  });
 }
 
 class TestBindingSyntax extends BindingDelegate {
   getBinding(model, String path, name, node) {
     if (path.trim() == 'replaceme') return new ObservableBox('replaced');
     return null;
   }
 }
 
 class UnbindingInNestedBindSyntax extends BindingDelegate {
@@ skipping 45 matching lines @@
       k = k is String ? new Symbol(k) : _deepToSymbol(k);
       result[k] = _deepToSymbol(v);
     });
     return result;
   }
   if (value is Iterable) {
     return value.map(_deepToSymbol).toList();
   }
   return value;
 }
-
-/**
- * Sanitizer which does nothing.
- */
-class NullTreeSanitizer implements NodeTreeSanitizer {
-  void sanitizeTree(Node node) {}
-}