Refactor of PolymerExpressions. Adds "as" expressions.

pkg/polymer_expressions/test/bindings_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 bindings_test;
 
 import 'dart:async';
 import 'dart:html';
 
 import 'package:observe/observe.dart';
 import 'package:observe/mirrors_used.dart'; // make test smaller.
 import 'package:observe/src/dirty_check.dart' show dirtyCheckZone;
 import 'package:polymer_expressions/polymer_expressions.dart';
-import 'package:template_binding/template_binding.dart' show templateBind;
+import 'package:smoke/mirrors.dart' as smoke;
+import 'package:template_binding/template_binding.dart' show
+    TemplateBindExtension, templateBind;
 import 'package:unittest/html_config.dart';
+
 import 'package:unittest/unittest.dart';
 
 var testDiv;
 
 main() => dirtyCheckZone().run(() {
   useHtmlConfiguration();
 
   group('bindings', () {
     var stop = null;
     setUp(() {
@@ skipping 11 matching lines @@
           .prepareBinding('x', null, null)(model, null, false);
       expect(binding.value, isNull);
       model.x = "hi";
       return new Future(() {
         expect(binding.value, 'hi');
       });
     });
 
     test('should update text content when data changes', () {
       var model = new NotifyModel('abcde');
-      var template = templateBind(new Element.html(
-          '<template><span>{{x}}</span></template>'));
+      var tag = new Element.html(
+      '<template><span>{{x}}</span></template>');
+      TemplateBindExtension.bootstrap(tag);
+      var template = templateBind(tag);
       testDiv.append(template.createInstance(model, new PolymerExpressions()));
 
       var el;
       return new Future(() {
         el = testDiv.query("span");
         expect(el.text, 'abcde');
         expect(model.x, 'abcde');
         model.x = '___';
       }).then(_nextMicrotask).then((_) {
         expect(model.x, '___');
         expect(el.text, '___');
       });
     });
 
     test('should log eval exceptions', () {
       var model = new NotifyModel('abcde');
       var completer = new Completer();
       runZoned(() {
-        var template = templateBind(new Element.html(
-            '<template><span>{{foo}}</span></template>'));
+        var tag = new Element.html(
+        '<template><span>{{foo}}</span></template>');
+        TemplateBindExtension.bootstrap(tag);
+        var template = templateBind(tag);
         testDiv.append(template.createInstance(model,
             new PolymerExpressions()));
 
         return _nextMicrotask(null);
       }, onError: (e) {
         expect('$e', startsWith("Error evaluating expression 'foo':"));
         completer.complete(true);
       });
       return completer.future;
     });
 
     test('detects changes to ObservableList', () {
       var list = new ObservableList.from([1, 2, 3]);
-      var template = templateBind(new Element.html(
-          '<template>{{x[1]}}</template>'));
+
+      var tag = new Element.html('<template>{{x[1]}}</template>');
+      TemplateBindExtension.bootstrap(tag);
+      var template = templateBind(tag);
+
       var model = new NotifyModel(list);
       testDiv.append(template.createInstance(model, new PolymerExpressions()));
 
       return new Future(() {
         expect(testDiv.text, '2');
         list[1] = 10;
       }).then(_nextMicrotask).then((_) {
         expect(testDiv.text, '10');
         list[1] = 11;
       }).then(_nextMicrotask).then((_) {
         expect(testDiv.text, '11');
         list[0] = 9;
       }).then(_nextMicrotask).then((_) {
         expect(testDiv.text, '11');
         list.removeAt(0);
       }).then(_nextMicrotask).then((_) {
         expect(testDiv.text, '3');
         list.add(90);
         list.removeAt(0);
       }).then(_nextMicrotask).then((_) {
         expect(testDiv.text, '90');
       });
     });
 
     test('detects changes to ObservableMap keys/values', () {
       var map = new ObservableMap.from({'a': 1, 'b': 2});
-      var template = templateBind(new Element.html('<template>'
+
+      var tag = new Element.html('<template>'
           '<template repeat="{{k in x.keys}}">{{k}}:{{x[k]}},</template>'
-          '</template>'));
+          '</template>');
+      TemplateBindExtension.bootstrap(tag);
+      var template = templateBind(tag);
+
       var model = new NotifyModel(map);
       testDiv.append(template.createInstance(model, new PolymerExpressions()));
 
       return new Future(() {
         expect(testDiv.text, 'a:1,b:2,');
         map.remove('b');
         map['c'] = 3;
       }).then(_nextMicrotask).then((_) {
         expect(testDiv.text, 'a:1,c:3,');
         map['a'] = 4;
@@ skipping 24 matching lines @@
       _initialSelectTest('{{i in y}}', '{{i}}', true);
       _updateSelectTest('{{i in y}}', '{{i}}', true);
     });
   });
 });
 
 
 _cursorPositionTest(bool usePolymer) {
   test('should preserve the cursor position', () {
     var model = new NotifyModel('abcde');
-    var template = templateBind(new Element.html(
-        '<template><input id="i1" value={{x}}></template>'));
+
+    var tag = new Element.html(
+        '<template><input id="i1" value={{x}}></template>');
+    TemplateBindExtension.bootstrap(tag);
+    var template = templateBind(tag);
+
     var delegate = usePolymer ? new PolymerExpressions() : null;
     testDiv.append(template.createInstance(model, delegate));
 
     var el;
     return new Future(() {
       el = testDiv.query("#i1");
       var subscription = el.onInput.listen(expectAsync((_) {}, count: 1));
       el.focus();
 
       expect(el.value, 'abcde');
@@ skipping 35 matching lines @@
       // ... or later.
       expect(el.selectionStart, 4);
       expect(el.selectionEnd, 4);
     });
   });
 }
 
 _initialSelectTest(String repeatExp, String valueExp, bool usePolymer) {
   test('initial select value is set correctly', () {
     var list = const ['a', 'b'];
-    var template = templateBind(new Element.html('<template>'
+
+    var tag = new Element.html('<template>'
         '<select value="{{x}}">'
         '<option template repeat="$repeatExp" value="$valueExp">item $valueExp'
         '</option></select></template>',
-        treeSanitizer: _nullTreeSanitizer));
+        treeSanitizer: _nullTreeSanitizer);
+    TemplateBindExtension.bootstrap(tag);
+    var template = templateBind(tag);
+
     var model = new NotifyModel('b', list);
     var delegate = usePolymer ? new PolymerExpressions() : null;
     testDiv.append(template.createInstance(model, delegate));
 
     expect(testDiv.querySelector('select').value, 'b');
     return new Future(() {
       expect(model.x, 'b');
       expect(testDiv.querySelector('select').value, 'b');
     });
   });
 }
 
 _updateSelectTest(String repeatExp, String valueExp, bool usePolymer) {
   test('updates to select value propagate correctly', () {
     var list = const ['a', 'b'];
-    var template = templateBind(new Element.html('<template>'
+
+    var tag = new Element.html('<template>'
         '<select value="{{x}}">'
         '<option template repeat="$repeatExp" value="$valueExp">item $valueExp'
         '</option></select></template>',
-        treeSanitizer: _nullTreeSanitizer));
+        treeSanitizer: _nullTreeSanitizer);
+    TemplateBindExtension.bootstrap(tag);
+    var template = templateBind(tag);
+
     var model = new NotifyModel('a', list);
     var delegate = usePolymer ? new PolymerExpressions() : null;
     testDiv.append(template.createInstance(model, delegate));
 
     expect(testDiv.querySelector('select').value, 'a');
     return new Future(() {
       expect(testDiv.querySelector('select').value, 'a');
       model.x = 'b';
     }).then(_nextMicrotask).then((_) {
       expect(testDiv.querySelector('select').value, 'b');
@@ skipping 18 matching lines @@
   get y => _y;
   set y(value) {
     _y = notifyPropertyChange(#y, _y, value);
   }
 }
 
 class _NullTreeSanitizer implements NodeTreeSanitizer {
   void sanitizeTree(Node node) {}
 }
 final _nullTreeSanitizer = new _NullTreeSanitizer();