style: rename Filter to Formatter

technohippy · mhevery · commit 3ee8740204d6 · 2014-04-30T07:11:40.000-07:00
Closes #983
diff --git a/lib/core/annotation_src.dart b/lib/core/annotation_src.dart
@@ -553,21 +553,21 @@ abstract class DetachAware {
  * Usage:
  *
  *     // Declaration
- *     @Formatter(name:'myFilter')
- *     class MyFilter {
- *       call(valueToFilter, optArg1, optArg2) {
+ *     @Formatter(name:'myFormatter')
+ *     class MyFormatter {
+ *       call(valueToFormat, optArg1, optArg2) {
  *          return ...;
  *       }
  *     }
  *
  *
  *     // Registration
  *     var module = ...;
- *     module.type(MyFilter);
+ *     module.type(MyFormatter);
  *
  *
  *     <!-- Usage -->
- *     <span>{{something | myFilter:arg1:arg2}}</span>
+ *     <span>{{something | myFormatter:arg1:arg2}}</span>
  */
 class Formatter {
   final String name;
diff --git a/lib/core/formatter.dart b/lib/core/formatter.dart
@@ -12,9 +12,9 @@ class FormatterMap extends AnnotationMap<Formatter> {
         super(injector, extractMetadata);
 
   call(String name) {
-    var filter = new Formatter(name: name);
-    var filterType = this[filter];
-    return _injector.get(filterType);
+    var formatter = new Formatter(name: name);
+    var formatterType = this[formatter];
+    return _injector.get(formatterType);
   }
 }
 
diff --git a/lib/core/module.dart b/lib/core/module.dart
@@ -61,7 +61,6 @@ export "package:angular/core_dom/module_internal.dart" show
 export "package:angular/core/module_internal.dart" show
     CacheStats,
     ExceptionHandler,
-    FilterMap,
     Interpolate,
     VmTurnZone,
     PrototypeMap,
diff --git a/lib/core/module_internal.dart b/lib/core/module_internal.dart
@@ -18,7 +18,7 @@ export 'package:angular/change_detection/watch_group.dart';
 import 'package:angular/change_detection/change_detection.dart';
 import 'package:angular/change_detection/dirty_checking_change_detector.dart';
 import 'package:angular/core/parser/utils.dart';
-import 'package:angular/core/parser/syntax.dart';
+import 'package:angular/core/parser/syntax.dart' as syntax;
 import 'package:angular/core/registry.dart';
 
 part "cache.dart";
diff --git a/lib/core/parser/dynamic_parser.dart b/lib/core/parser/dynamic_parser.dart
@@ -1,6 +1,6 @@
 library angular.core.parser.dynamic_parser;
 
-import 'package:angular/core/annotation_src.dart';
+import 'package:angular/core/annotation_src.dart' hide Formatter;
 import 'package:angular/core/module_internal.dart' show FormatterMap;
 
 import 'package:angular/core/parser/parser.dart';
@@ -72,11 +72,11 @@ class DynamicParserBackend extends ParserBackend {
 
   bool isAssignable(Expression expression) => expression.isAssignable;
 
-  Expression newFilter(expression, name, arguments) {
+  Expression newFormatter(expression, name, arguments) {
     List allArguments = new List(arguments.length + 1);
     allArguments[0] = expression;
     allArguments.setAll(1, arguments);
-    return new Filter(expression, name, arguments, allArguments);
+    return new Formatter(expression, name, arguments, allArguments);
   }
 
   Expression newChain(expressions) => new Chain(expressions);
diff --git a/lib/core/parser/dynamic_parser_impl.dart b/lib/core/parser/dynamic_parser_impl.dart
@@ -32,12 +32,12 @@ class DynamicParserImpl {
           next.isCharacter($RBRACKET)) {
         error('Unconsumed token $next');
       }
-      var expr = parseFilter();
+      var expr = parseFormatter();
       expressions.add(expr);
       while (optionalCharacter($SEMICOLON)) {
         isChain = true;
       }
-      if (isChain && expr is Filter) {
+      if (isChain && expr is Formatter) {
         error('Cannot have a formatter in a chain');
       }
       if (!isChain && index < tokens.length) {
@@ -49,7 +49,7 @@ class DynamicParserImpl {
         : backend.newChain(expressions);
   }
 
-  parseFilter() {
+  parseFormatter() {
     var result = parseExpression();
     while (optionalOperator('|')) {
       String name = expectIdentifierOrKeyword();
@@ -58,7 +58,7 @@ class DynamicParserImpl {
         // TODO(kasperl): Is this really supposed to be expressions?
         arguments.add(parseExpression());
       }
-      result = backend.newFilter(result, name, arguments);
+      result = backend.newFormatter(result, name, arguments);
     }
     return result;
   }
@@ -217,7 +217,7 @@ class DynamicParserImpl {
 
   parsePrimary() {
     if (optionalCharacter($LPAREN)) {
-      var result = parseFilter();
+      var result = parseFormatter();
       expectCharacter($RPAREN);
       return result;
     } else if (next.isKeywordNull || next.isKeywordUndefined) {
diff --git a/lib/core/parser/eval.dart b/lib/core/parser/eval.dart
@@ -19,9 +19,9 @@ class Chain extends syntax.Chain {
   }
 }
 
-class Filter extends syntax.Filter {
+class Formatter extends syntax.Formatter {
   final List<syntax.Expression> allArguments;
-  Filter(syntax.Expression expression, String name, List<syntax.Expression> arguments,
+  Formatter(syntax.Expression expression, String name, List<syntax.Expression> arguments,
          this.allArguments)
       : super(expression, name, arguments);
 
diff --git a/lib/core/parser/parser.dart b/lib/core/parser/parser.dart
@@ -23,7 +23,7 @@ abstract class ParserBackend<T> {
   bool isAssignable(T expression);
 
   T newChain(List expressions) => null;
-  T newFilter(T expression, String name, List arguments) => null;
+  T newFormatter(T expression, String name, List arguments) => null;
 
   T newAssign(T target, T value) => null;
   T newConditional(T condition, T yes, T no) => null;
diff --git a/lib/core/parser/syntax.dart b/lib/core/parser/syntax.dart
@@ -10,7 +10,7 @@ abstract class Visitor {
 
   visitExpression(Expression expression) => null;
   visitChain(Chain expression) => visitExpression(expression);
-  visitFilter(Filter expression) => visitExpression(expression);
+  visitFormatter(Formatter expression) => visitExpression(expression);
 
   visitAssign(Assign expression) => visitExpression(expression);
   visitConditional(Conditional expression) => visitExpression(expression);
@@ -73,12 +73,12 @@ class Chain extends Expression {
   accept(Visitor visitor) => visitor.visitChain(this);
 }
 
-class Filter extends Expression {
+class Formatter extends Expression {
   final Expression expression;
   final String name;
   final List<Expression> arguments;
-  Filter(this.expression, this.name, this.arguments);
-  accept(Visitor visitor) => visitor.visitFilter(this);
+  Formatter(this.expression, this.name, this.arguments);
+  accept(Visitor visitor) => visitor.visitFormatter(this);
 }
 
 class Assign extends Expression {
diff --git a/lib/core/parser/unparser.dart b/lib/core/parser/unparser.dart
@@ -41,13 +41,13 @@ class Unparser extends Visitor {
     }
   }
 
-  void visitFilter(Filter filter) {
+  void visitFormatter(Formatter formatter) {
     write('(');
-    visit(filter.expression);
-    write('|${filter.name}');
-    for (int i = 0; i < filter.arguments.length; i++) {
+    visit(formatter.expression);
+    write('|${formatter.name}');
+    for (int i = 0; i < formatter.arguments.length; i++) {
       write(' :');
-      visit(filter.arguments[i]);
+      visit(formatter.arguments[i]);
     }
     write(')');
   }
diff --git a/lib/core/scope.dart b/lib/core/scope.dart
@@ -1061,7 +1061,7 @@ class _AstParser {
   }
 }
 
-class ExpressionVisitor implements Visitor {
+class ExpressionVisitor implements syntax.Visitor {
   static final ContextReferenceAST scopeContextRef = new ContextReferenceAST();
   final ClosureMap _closureMap;
   AST contextRef = scopeContextRef;
@@ -1072,7 +1072,7 @@ class ExpressionVisitor implements Visitor {
   AST ast;
   FormatterMap formatters;
 
-  AST visit(Expression exp) {
+  AST visit(syntax.Expression exp) {
     exp.accept(this);
     assert(ast != null);
     try {
@@ -1082,68 +1082,68 @@ class ExpressionVisitor implements Visitor {
     }
   }
 
-  AST visitCollection(Expression exp) => new CollectionAST(visit(exp));
-  AST _mapToAst(Expression expression) => visit(expression);
+  AST visitCollection(syntax.Expression exp) => new CollectionAST(visit(exp));
+  AST _mapToAst(syntax.Expression expression) => visit(expression);
 
-  List<AST> _toAst(List<Expression> expressions) =>
+  List<AST> _toAst(List<syntax.Expression> expressions) =>
       expressions.map(_mapToAst).toList();
 
-  Map<Symbol, AST> _toAstMap(Map<String, Expression> expressions) {
+  Map<Symbol, AST> _toAstMap(Map<String, syntax.Expression> expressions) {
     if (expressions.isEmpty) return const {};
     Map<Symbol, AST> result = new Map<Symbol, AST>();
-    expressions.forEach((String name, Expression expression) {
+    expressions.forEach((String name, syntax.Expression expression) {
       result[_closureMap.lookupSymbol(name)] = _mapToAst(expression);
     });
     return result;
   }
 
-  void visitCallScope(CallScope exp) {
+  void visitCallScope(syntax.CallScope exp) {
     List<AST> positionals = _toAst(exp.arguments.positionals);
     Map<Symbol, AST> named = _toAstMap(exp.arguments.named);
     ast = new MethodAST(contextRef, exp.name, positionals, named);
   }
-  void visitCallMember(CallMember exp) {
+  void visitCallMember(syntax.CallMember exp) {
     List<AST> positionals = _toAst(exp.arguments.positionals);
     Map<Symbol, AST> named = _toAstMap(exp.arguments.named);
     ast = new MethodAST(visit(exp.object), exp.name, positionals, named);
   }
-  visitAccessScope(AccessScope exp) {
+  void visitAccessScope(syntax.AccessScope exp) {
     ast = new FieldReadAST(contextRef, exp.name);
   }
-  visitAccessMember(AccessMember exp) {
+  void visitAccessMember(syntax.AccessMember exp) {
     ast = new FieldReadAST(visit(exp.object), exp.name);
   }
-  visitBinary(Binary exp) {
+  void visitBinary(syntax.Binary exp) {
     ast = new PureFunctionAST(exp.operation,
                               _operationToFunction(exp.operation),
                               [visit(exp.left), visit(exp.right)]);
   }
-  void visitPrefix(Prefix exp) {
+  void visitPrefix(syntax.Prefix exp) {
     ast = new PureFunctionAST(exp.operation,
                               _operationToFunction(exp.operation),
                               [visit(exp.expression)]);
   }
-  void visitConditional(Conditional exp) {
+  void visitConditional(syntax.Conditional exp) {
     ast = new PureFunctionAST('?:', _operation_ternary,
                               [visit(exp.condition), visit(exp.yes),
                               visit(exp.no)]);
   }
-  void visitAccessKeyed(AccessKeyed exp) {
+  void visitAccessKeyed(syntax.AccessKeyed exp) {
     ast = new ClosureAST('[]', _operation_bracket,
                              [visit(exp.object), visit(exp.key)]);
   }
-  void visitLiteralPrimitive(LiteralPrimitive exp) {
+  void visitLiteralPrimitive(syntax.LiteralPrimitive exp) {
     ast = new ConstantAST(exp.value);
   }
-  void visitLiteralString(LiteralString exp) {
+  void visitLiteralString(syntax.LiteralString exp) {
     ast = new ConstantAST(exp.value);
   }
-  void visitLiteralArray(LiteralArray exp) {
+  void visitLiteralArray(syntax.LiteralArray exp) {
     List<AST> items = _toAst(exp.elements);
     ast = new PureFunctionAST('[${items.join(', ')}]', new ArrayFn(), items);
   }
 
-  void visitLiteralObject(LiteralObject exp) {
+  void visitLiteralObject(syntax.LiteralObject exp) {
     List<String> keys = exp.keys;
     List<AST> values = _toAst(exp.values);
     assert(keys.length == values.length);
@@ -1154,31 +1154,31 @@ class ExpressionVisitor implements Visitor {
     ast = new PureFunctionAST('{${kv.join(', ')}}', new MapFn(keys), values);
   }
 
-  void visitFilter(Filter exp) {
+  void visitFormatter(syntax.Formatter exp) {
     if (formatters == null) {
       throw new Exception("No formatters have been registered");
     }
-    Function filterFunction = formatters(exp.name);
+    Function formatterFunction = formatters(exp.name);
     List<AST> args = [visitCollection(exp.expression)];
     args.addAll(_toAst(exp.arguments).map((ast) => new CollectionAST(ast)));
     ast = new PureFunctionAST('|${exp.name}',
-        new _FilterWrapper(filterFunction, args.length), args);
+        new _FormatterWrapper(formatterFunction, args.length), args);
   }
 
   // TODO(misko): this is a corner case. Choosing not to implement for now.
-  void visitCallFunction(CallFunction exp) {
+  void visitCallFunction(syntax.CallFunction exp) {
     _notSupported("function's returing functions");
   }
-  void visitAssign(Assign exp) {
+  void visitAssign(syntax.Assign exp) {
     _notSupported('assignement');
   }
-  void visitLiteral(Literal exp) {
+  void visitLiteral(syntax.Literal exp) {
     _notSupported('literal');
   }
-  void visitExpression(Expression exp) {
+  void visitExpression(syntax.Expression exp) {
     _notSupported('?');
   }
-  void visitChain(Chain exp) {
+  void visitChain(syntax.Chain exp) {
     _notSupported(';');
   }
 
@@ -1249,11 +1249,11 @@ class MapFn extends FunctionApply {
   }
 }
 
-class _FilterWrapper extends FunctionApply {
-  final Function filterFn;
+class _FormatterWrapper extends FunctionApply {
+  final Function formatterFn;
   final List args;
   final List<Watch> argsWatches;
-  _FilterWrapper(this.filterFn, length):
+  _FormatterWrapper(this.formatterFn, length):
       args = new List(length),
       argsWatches = new List(length);
 
@@ -1271,7 +1271,7 @@ class _FilterWrapper extends FunctionApply {
        }
       }
     }
-    var value = Function.apply(filterFn, args);
+    var value = Function.apply(formatterFn, args);
     if (value is Iterable) {
       // Since formatters are pure we can guarantee that this well never change.
       // By wrapping in UnmodifiableListView we can hint to the dirty checker
diff --git a/lib/core_dom/common.dart b/lib/core_dom/common.dart
@@ -35,7 +35,7 @@ class DirectiveRef {
  * Creates a child injector that allows loading new directives, formatters and
  * services from the provided modules.
  */
-Injector forceNewDirectivesAndFilters(Injector injector, List<Module> modules) {
+Injector forceNewDirectivesAndFormatters(Injector injector, List<Module> modules) {
   modules.add(new Module()
       ..factory(Scope, (i) {
         var scope = i.parent.get(Scope);
diff --git a/lib/directive/ng_repeat.dart b/lib/directive/ng_repeat.dart
@@ -35,7 +35,7 @@ part of angular.directive;
  *   specified the ng-repeat associates elements by identity in the collection.
  *   It is an error to have more than one tracking function to resolve to the
  *   same key. (This would mean that two distinct objects are mapped to the same
- *   DOM element, which is not possible.)  Filters should be applied to the
+ *   DOM element, which is not possible.)  Formatters should be applied to the
  *   expression, before specifying a tracking expression.
  *
  *     For example: `item in items` is equivalent to `item in items track by
diff --git a/lib/routing/ng_view.dart b/lib/routing/ng_view.dart
@@ -116,7 +116,7 @@ class NgView implements DetachAware, RouteProvider {
 
     var viewInjector = modules == null ?
         _injector :
-        forceNewDirectivesAndFilters(_injector, modules);
+        forceNewDirectivesAndFormatters(_injector, modules);
 
     var newDirectives = viewInjector.get(DirectiveMap);
     var viewFuture = viewDef.templateHtml != null ?
diff --git a/test/core/parser/parser_spec.dart b/test/core/parser/parser_spec.dart
diff --git a/test/core/scope_spec.dart b/test/core/scope_spec.dart
diff --git a/test/core_dom/compiler_spec.dart b/test/core_dom/compiler_spec.dart
diff --git a/test/core_dom/mustache_spec.dart b/test/core_dom/mustache_spec.dart
diff --git a/test/core_dom/view_spec.dart b/test/core_dom/view_spec.dart
diff --git a/test/routing/routing_spec.dart b/test/routing/routing_spec.dart

Original file line number	Diff line number	Diff line change
`@@ -553,21 +553,21 @@ abstract class DetachAware {`
`553`	`553`	`* Usage:`
`554`	`554`	`*`
`555`	`555`	`* // Declaration`
`556`		`- * @Formatter(name:'myFilter')`
`557`		`- * class MyFilter {`
`558`		`- * call(valueToFilter, optArg1, optArg2) {`
	`556`	`+ * @Formatter(name:'myFormatter')`
	`557`	`+ * class MyFormatter {`
	`558`	`+ * call(valueToFormat, optArg1, optArg2) {`
`559`	`559`	`* return ...;`
`560`	`560`	`* }`
`561`	`561`	`* }`
`562`	`562`	`*`
`563`	`563`	`*`
`564`	`564`	`* // Registration`
`565`	`565`	`* var module = ...;`
`566`		`- * module.type(MyFilter);`
	`566`	`+ * module.type(MyFormatter);`
`567`	`567`	`*`
`568`	`568`	`*`
`569`	`569`	`* <!-- Usage -->`
`570`		`- * <span>{{something \| myFilter:arg1:arg2}}</span>`
	`570`	`+ * <span>{{something \| myFormatter:arg1:arg2}}</span>`
`571`	`571`	`*/`
`572`	`572`	`class Formatter {`
`573`	`573`	`final String name;`
Original file line number	Diff line number	Diff line change
`@@ -12,9 +12,9 @@ class FormatterMap extends AnnotationMap<Formatter> {`
`12`	`12`	`super(injector, extractMetadata);`
`13`	`13`
`14`	`14`	`call(String name) {`
`15`		`- var filter = new Formatter(name: name);`
`16`		`- var filterType = this[filter];`
`17`		`- return _injector.get(filterType);`
	`15`	`+ var formatter = new Formatter(name: name);`
	`16`	`+ var formatterType = this[formatter];`
	`17`	`+ return _injector.get(formatterType);`
`18`	`18`	`}`
`19`	`19`	`}`
`20`	`20`
Original file line number	Diff line number	Diff line change
`@@ -32,12 +32,12 @@ class DynamicParserImpl {`
`32`	`32`	`next.isCharacter($RBRACKET)) {`
`33`	`33`	`error('Unconsumed token $next');`
`34`	`34`	`}`
`35`		`- var expr = parseFilter();`
	`35`	`+ var expr = parseFormatter();`
`36`	`36`	`expressions.add(expr);`
`37`	`37`	`while (optionalCharacter($SEMICOLON)) {`
`38`	`38`	`isChain = true;`
`39`	`39`	`}`
`40`		`- if (isChain && expr is Filter) {`
	`40`	`+ if (isChain && expr is Formatter) {`
`41`	`41`	`error('Cannot have a formatter in a chain');`
`42`	`42`	`}`
`43`	`43`	`if (!isChain && index < tokens.length) {`
`@@ -49,7 +49,7 @@ class DynamicParserImpl {`
`49`	`49`	`: backend.newChain(expressions);`
`50`	`50`	`}`
`51`	`51`
`52`		`- parseFilter() {`
	`52`	`+ parseFormatter() {`
`53`	`53`	`var result = parseExpression();`
`54`	`54`	`while (optionalOperator('\|')) {`
`55`	`55`	`String name = expectIdentifierOrKeyword();`
`@@ -58,7 +58,7 @@ class DynamicParserImpl {`
`58`	`58`	`// TODO(kasperl): Is this really supposed to be expressions?`
`59`	`59`	`arguments.add(parseExpression());`
`60`	`60`	`}`
`61`		`- result = backend.newFilter(result, name, arguments);`
	`61`	`+ result = backend.newFormatter(result, name, arguments);`
`62`	`62`	`}`
`63`	`63`	`return result;`
`64`	`64`	`}`
`@@ -217,7 +217,7 @@ class DynamicParserImpl {`
`217`	`217`
`218`	`218`	`parsePrimary() {`
`219`	`219`	`if (optionalCharacter($LPAREN)) {`
`220`		`- var result = parseFilter();`
	`220`	`+ var result = parseFormatter();`
`221`	`221`	`expectCharacter($RPAREN);`
`222`	`222`	`return result;`
`223`	`223`	`} else if (next.isKeywordNull \|\| next.isKeywordUndefined) {`
Original file line number	Diff line number	Diff line change
`@@ -19,9 +19,9 @@ class Chain extends syntax.Chain {`
`19`	`19`	`}`
`20`	`20`	`}`
`21`	`21`
`22`		`-class Filter extends syntax.Filter {`
	`22`	`+class Formatter extends syntax.Formatter {`
`23`	`23`	`final List<syntax.Expression> allArguments;`
`24`		`- Filter(syntax.Expression expression, String name, List<syntax.Expression> arguments,`
	`24`	`+ Formatter(syntax.Expression expression, String name, List<syntax.Expression> arguments,`
`25`	`25`	`this.allArguments)`
`26`	`26`	`: super(expression, name, arguments);`
`27`	`27`
Original file line number	Diff line number	Diff line change
`@@ -41,13 +41,13 @@ class Unparser extends Visitor {`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`
`44`		`- void visitFilter(Filter filter) {`
	`44`	`+ void visitFormatter(Formatter formatter) {`
`45`	`45`	`write('(');`
`46`		`- visit(filter.expression);`
`47`		`- write('\|${filter.name}');`
`48`		`- for (int i = 0; i < filter.arguments.length; i++) {`
	`46`	`+ visit(formatter.expression);`
	`47`	`+ write('\|${formatter.name}');`
	`48`	`+ for (int i = 0; i < formatter.arguments.length; i++) {`
`49`	`49`	`write(' :');`
`50`		`- visit(filter.arguments[i]);`
	`50`	`+ visit(formatter.arguments[i]);`
`51`	`51`	`}`
`52`	`52`	`write(')');`
`53`	`53`	`}`