feat(parser): add support for formatters

modules/change_detection/src/parser/ast.js

@@ -1,4 +1,5 @@
-import {FIELD, toBool, autoConvertAdd} from "facade/lang";
+import {FIELD, toBool, autoConvertAdd, isBlank, FunctionWrapper, BaseException} from "facade/lang";
+import {List, ListWrapper} from "facade/collection";
 
 export class AST {
   eval(context, formatters) {
@@ -50,6 +51,28 @@ export class FieldRead extends AST {
   }
 }
 
+export class Formatter extends AST {
+  constructor(exp:AST, name:string, args:List) {
+    this.exp = exp;
+    this.name = name;
+    this.args = args;
+    this.allArgs = ListWrapper.concat([exp], args);
+  }
+
+  eval(context, formatters) {
+    var formatter = formatters[this.name];
+    if (isBlank(formatter)) {
+      throw new BaseException(`No formatter '${this.name}' found!`);
+    }
+    var evaledArgs = evalList(context, this.allArgs, formatters);
+    return FunctionWrapper.apply(formatter, evaledArgs);
+  }
+
+  visit(visitor) {
+    visitor.visitFormatter(this);
+  }
+}
+
 export class LiteralPrimitive extends AST {
   @FIELD('final value')
   constructor(value) {
@@ -128,4 +151,15 @@ export class AstVisitor {
   visitBinary(ast:Binary) {}
   visitPrefixNot(ast:PrefixNot) {}
   visitLiteralPrimitive(ast:LiteralPrimitive) {}
+  visitFormatter(ast:Formatter) {}
 }
+
+var _evalListCache = [[],[0],[0,0],[0,0,0],[0,0,0,0],[0,0,0,0,0]];
+function evalList(context, exps:List, formatters){
+  var length = exps.length;
+  var result = _evalListCache[length];
+  for (var i = 0; i < length; i++) {
+    result[i] = exps[i].eval(context, formatters);
+  }
+  return result;
+}

modules/change_detection/src/parser/parser.js

@@ -1,9 +1,18 @@
 import {FIELD, int, isBlank} from 'facade/lang';
 import {ListWrapper, List} from 'facade/collection';
-import {Lexer, EOF, Token, $PERIOD, $COLON} from './lexer';
+import {Lexer, EOF, Token, $PERIOD, $COLON, $SEMICOLON} from './lexer';
 import {ClosureMap} from './closure_map';
-import {AST, ImplicitReceiver, FieldRead, LiteralPrimitive, Expression,
-   Binary, PrefixNot, Conditional} from './ast';
+import {
+  AST,
+  ImplicitReceiver,
+  FieldRead,
+  LiteralPrimitive,
+  Expression,
+  Binary,
+  PrefixNot,
+  Conditional,
+  Formatter
+  } from './ast';
 
 var _implicitReceiver = new ImplicitReceiver();
 
@@ -70,12 +79,35 @@ class _ParseAST {
 
   parseChain():AST {
     var exprs = [];
+    var isChain = false;
     while (this.index < this.tokens.length) {
-      ListWrapper.push(exprs, this.parseConditional());
+      var expr = this.parseFormatter();
+      ListWrapper.push(exprs, expr);
+
+      while (this.optionalCharacter($SEMICOLON)) {
+        isChain = true;
+      }
+
+      if (isChain && expr instanceof Formatter) {
+        this.error('Cannot have a formatter in a chain');
+      }
     }
     return ListWrapper.first(exprs);
   }
 
+  parseFormatter() {
+    var result = this.parseExpression();
+    while (this.optionalOperator("|")) {
+      var name = this.parseIdentifier();
+      var args = ListWrapper.create();
+      while (this.optionalCharacter($COLON)) {
+        ListWrapper.push(args, this.parseExpression());
+      }
+      result = new Formatter(result, name, args);
+    }
+    return result;
+  }
+
   parseExpression() {
     return this.parseConditional();
   }