add enumerate to the default filter set

pkg/polymer_expressions/lib/polymer_expressions.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 polymer_expressions;
 
 import 'dart:async';
 import 'dart:html';
 
 import 'package:observe/observe.dart';
 
 import 'eval.dart';
 import 'expression.dart';
 import 'parser.dart';
+import 'src/globals.dart';
 
 // TODO(justin): Investigate XSS protection
 Object _classAttributeConverter(v) =>
     (v is Map) ? v.keys.where((k) => v[k] == true).join(' ') :
     (v is Iterable) ? v.join(' ') :
     v;
 
 Object _styleAttributeConverter(v) =>
     (v is Map) ? v.keys.map((k) => '$k: ${v[k]}').join(';') :
     (v is Iterable) ? v.join(';') :
     v;
 
 class PolymerExpressions extends BindingDelegate {
+  /** The default [globals] to use for Polymer expressions. */
+  static const Map DEFAULT_GLOBALS = const { 'enumerate': enumerate };
 
   final Map<String, Object> globals;
 
+  /**
+   * Creates a new binding delegate for Polymer expressions, with the provided
+   * variables used as [globals]. If no globals are supplied, a copy of the
+   * [DEFAULT_GLOBALS] will be used.
+   */
   PolymerExpressions({Map<String, Object> globals})
-      : globals = (globals == null) ? new Map<String, Object>() : globals;
+      : globals = (globals == null) ?
+          new Map<String, Object>.from(DEFAULT_GLOBALS) : globals;

[justinfagnani, 2013/09/17 21:45:05]

I think I'd rather see the default globals set in PolymerElement, but I'm fine
either way.

[Jennifer Messerly, 2013/10/08 00:55:01]

yeah, I was kinda wondering that too. So far we don't have any syntax knowledge
in the Polymer library other than saying "new PolymerExpressions", so that's why
I'm leaning this way.

Definitely something we should bring up tomorrow when chatting with them. It
feels like there isn't an easy way to add a filter to the scope. The JS approach
of making it global doesn't seem good.

maybe if we had something like:

import 'package:quiver/quiver.dart' show enumerate;

class FancyButton extends PolymerElement {
  get templateGlobals => { 'enumerate': enumerate };
}

... would that be lightweight enough, I wonder?

 
   _Binding getBinding(model, String path, name, node) {
     if (path == null) return null;
     var expr = new Parser(path).parse();
     if (model is! Scope) {
       model = new Scope(model: model, variables: globals);
     }
     if (node is Element && name == "class") {
       return new _Binding(expr, model, _classAttributeConverter);
     }
@@ skipping 55 matching lines @@
     }
   }
 
   getValueWorkaround(key) {
     if (key == _VALUE) return value;
   }
 
   setValueWorkaround(key, v) {
     if (key == _VALUE) value = v;
   }
-
 }