refactor(pipes): use Injector instead of pipe factories for pipe instantiation

BREAKING CHANGE
    - Pipe factories have been removed.
    - PIpe names to pipe implementations are 1-to-1  instead of 1-to-*

 Before:
     class DateFormatter {
         transform(date, args){}
     }

     class DateFormatterFactory {
       supporst(obj) { return true; }
       create(cdRef) { return new DateFormatter(); }
     }
     new Pipes({date: [new DateFormatterFactory()]})

After
    class DateFormatter {
      transform(date, args){}
    }
    new Pipes({date: DateFormatter})

Author: vsavkin

modules/angular2/change_detection.ts

@@ -29,8 +29,5 @@ export {
   KeyValueDiffers,
   KeyValueDiffer,
   KeyValueDifferFactory,
-  PipeFactory,
-  BasePipe,
-  NullPipe,
-  NullPipeFactory
+  BasePipe
 } from 'angular2/src/change_detection/change_detection';

modules/angular2/src/change_detection/change_detection.ts

@@ -1,22 +1,20 @@
 import {JitProtoChangeDetector} from './jit_proto_change_detector';
 import {PregenProtoChangeDetector} from './pregen_proto_change_detector';
 import {DynamicProtoChangeDetector} from './proto_change_detector';
-import {PipeFactory, Pipe} from './pipes/pipe';
 import {Pipes} from './pipes/pipes';
 import {IterableDiffers, IterableDifferFactory} from './differs/iterable_differs';
 import {DefaultIterableDifferFactory} from './differs/default_iterable_differ';
 import {KeyValueDiffers, KeyValueDifferFactory} from './differs/keyvalue_differs';
 import {DefaultKeyValueDifferFactory} from './differs/default_keyvalue_differ';
-import {AsyncPipeFactory} from './pipes/async_pipe';
+import {AsyncPipe} from './pipes/async_pipe';
 import {UpperCasePipe} from './pipes/uppercase_pipe';
 import {LowerCasePipe} from './pipes/lowercase_pipe';
 import {JsonPipe} from './pipes/json_pipe';
-import {LimitToPipeFactory} from './pipes/limit_to_pipe';
+import {LimitToPipe} from './pipes/limit_to_pipe';
 import {DatePipe} from './pipes/date_pipe';
 import {DecimalPipe, PercentPipe, CurrencyPipe} from './pipes/number_pipe';
-import {NullPipeFactory} from './pipes/null_pipe';
 import {ChangeDetection, ProtoChangeDetector, ChangeDetectorDefinition} from './interfaces';
-import {Inject, Injectable, OpaqueToken, Optional} from 'angular2/di';
+import {Injector, Inject, Injectable, OpaqueToken, Optional, Binding} from 'angular2/di';
 import {List, StringMap, StringMapWrapper} from 'angular2/src/facade/collection';
 import {CONST, CONST_EXPR, isPresent, BaseException} from 'angular2/src/facade/lang';
 
@@ -55,9 +53,27 @@ export {ChangeDetectorRef} from './change_detector_ref';
 export {Pipes} from './pipes/pipes';
 export {IterableDiffers, IterableDiffer, IterableDifferFactory} from './differs/iterable_differs';
 export {KeyValueDiffers, KeyValueDiffer, KeyValueDifferFactory} from './differs/keyvalue_differs';
-export {WrappedValue, Pipe, PipeFactory, BasePipe} from './pipes/pipe';
-export {NullPipe, NullPipeFactory} from './pipes/null_pipe';
+export {WrappedValue, Pipe, BasePipe} from './pipes/pipe';
+
+
+function createPipes(inj: Injector): Pipes {
+  return new Pipes(
+      {
+        "async": AsyncPipe,
+        "uppercase": UpperCasePipe,
+        "lowercase": LowerCasePipe,
+        "json": JsonPipe,
+        "limitTo": LimitToPipe,
+        "number": DecimalPipe,
+        "percent": PercentPipe,
+        "currency": CurrencyPipe,
+        "date": DatePipe
+      },
+      inj);
+}
 
+export const defaultPipes: Binding =
+    CONST_EXPR(new Binding(Pipes, {toFactory: createPipes, deps: [Injector]}));
 
 /**
  * Structural diffing for `Object`s and `Map`s.
@@ -71,73 +87,6 @@ export const keyValDiff: KeyValueDifferFactory[] =
 export const iterableDiff: IterableDifferFactory[] =
     CONST_EXPR([CONST_EXPR(new DefaultIterableDifferFactory())]);
 
-/**
- * Async binding to such types as Observable.
- */
-export const async: List<PipeFactory> =
-    CONST_EXPR([CONST_EXPR(new AsyncPipeFactory()), CONST_EXPR(new NullPipeFactory())]);
-
-/**
- * Uppercase text transform.
- */
-export const uppercase: List<PipeFactory> =
-    CONST_EXPR([CONST_EXPR(new UpperCasePipe()), CONST_EXPR(new NullPipeFactory())]);
-
-/**
- * Lowercase text transform.
- */
-export const lowercase: List<PipeFactory> =
-    CONST_EXPR([CONST_EXPR(new LowerCasePipe()), CONST_EXPR(new NullPipeFactory())]);
-
-/**
- * Json stringify transform.
- */
-export const json: List<PipeFactory> =
-    CONST_EXPR([CONST_EXPR(new JsonPipe()), CONST_EXPR(new NullPipeFactory())]);
-
-/**
- * LimitTo text transform.
- */
-export const limitTo: List<PipeFactory> =
-    CONST_EXPR([CONST_EXPR(new LimitToPipeFactory()), CONST_EXPR(new NullPipeFactory())]);
-
-/**
- * Number number transform.
- */
-export const decimal: List<PipeFactory> =
-    CONST_EXPR([CONST_EXPR(new DecimalPipe()), CONST_EXPR(new NullPipeFactory())]);
-
-/**
- * Percent number transform.
- */
-export const percent: List<PipeFactory> =
-    CONST_EXPR([CONST_EXPR(new PercentPipe()), CONST_EXPR(new NullPipeFactory())]);
-
-/**
- * Currency number transform.
- */
-export const currency: List<PipeFactory> =
-    CONST_EXPR([CONST_EXPR(new CurrencyPipe()), CONST_EXPR(new NullPipeFactory())]);
-
-/**
- * Date/time formatter.
- */
-export const date: List<PipeFactory> =
-    CONST_EXPR([CONST_EXPR(new DatePipe()), CONST_EXPR(new NullPipeFactory())]);
-
-
-export const defaultPipes: Pipes = CONST_EXPR(new Pipes({
-  "async": async,
-  "uppercase": uppercase,
-  "lowercase": lowercase,
-  "json": json,
-  "limitTo": limitTo,
-  "number": decimal,
-  "percent": percent,
-  "currency": currency,
-  "date": date
-}));
-
 export const defaultIterableDiffers = CONST_EXPR(new IterableDiffers(iterableDiff));
 
 export const defaultKeyValueDiffers = CONST_EXPR(new KeyValueDiffers(keyValDiff));

modules/angular2/src/change_detection/change_detection_jit_generator.ts

@@ -184,10 +184,7 @@ export class ChangeDetectorJITGenerator {
 
     var read = `
       if (${pipe} === ${UTIL}.uninitialized) {
-        ${pipe} = ${this._names.getPipesAccessorName()}.get('${pipeType}', ${context}, ${cdRef});
-      } else if (!${pipe}.supports(${context})) {
-        ${pipe}.onDestroy();
-        ${pipe} = ${this._names.getPipesAccessorName()}.get('${pipeType}', ${context}, ${cdRef});
+        ${pipe} = ${this._names.getPipesAccessorName()}.get('${pipeType}', ${cdRef});
       }
       ${newValue} = ${pipe}.transform(${context}, [${argString}]);
     `;

modules/angular2/src/change_detection/dynamic_change_detector.ts

@@ -267,13 +267,9 @@ export class DynamicChangeDetector extends AbstractChangeDetector<any> {
 
   _pipeFor(proto: ProtoRecord, context) {
     var storedPipe = this._readPipe(proto);
-    if (isPresent(storedPipe) && storedPipe.supports(context)) {
-      return storedPipe;
-    }
-    if (isPresent(storedPipe)) {
-      storedPipe.onDestroy();
-    }
-    var pipe = this.pipes.get(proto.name, context, this.ref);
+    if (isPresent(storedPipe)) return storedPipe;
+
+    var pipe = this.pipes.get(proto.name, this.ref);
     this._writePipe(proto, pipe);
     return pipe;
   }

modules/angular2/src/change_detection/pipes/async_pipe.ts

@@ -1,6 +1,7 @@
 import {isBlank, isPresent, isPromise, CONST, BaseException} from 'angular2/src/facade/lang';
 import {Observable, Promise, ObservableWrapper} from 'angular2/src/facade/async';
-import {Pipe, WrappedValue, PipeFactory} from './pipe';
+import {Injectable} from 'angular2/di';
+import {Pipe, WrappedValue, InvalidPipeArgumentException} from './pipe';
 import {ChangeDetectorRef} from '../change_detector_ref';
 
 
@@ -52,6 +53,7 @@ var _observableStrategy = new ObservableStrategy();
  *
  * ```
  */
+@Injectable()
 export class AsyncPipe implements Pipe {
   _latestValue: Object = null;
   _latestReturnedValue: Object = null;
@@ -62,8 +64,6 @@ export class AsyncPipe implements Pipe {
 
   constructor(public _ref: ChangeDetectorRef) {}
 
-  supports(obj: any): boolean { return true; }
-
   onDestroy(): void {
     if (isPresent(this._subscription)) {
       this._dispose();
@@ -98,13 +98,13 @@ export class AsyncPipe implements Pipe {
         this._strategy.createSubscription(obj, value => this._updateLatestValue(obj, value));
   }
 
-  _selectStrategy(obj: Observable | Promise<any>) {
+  _selectStrategy(obj: Observable | Promise<any>): any {
     if (isPromise(obj)) {
       return _promiseStrategy;
     } else if (ObservableWrapper.isObservable(obj)) {
       return _observableStrategy;
     } else {
-      throw new BaseException(`Async pipe does not support object '${obj}'`);
+      throw new InvalidPipeArgumentException(AsyncPipe, obj);
     }
   }
 
@@ -122,13 +122,4 @@ export class AsyncPipe implements Pipe {
       this._ref.requestCheck();
     }
   }
-}
-
-/**
- * Provides a factory for [AsyncPipe].
- */
-@CONST()
-export class AsyncPipeFactory implements PipeFactory {
-  supports(obj: any): boolean { return true; }
-  create(cdRef: ChangeDetectorRef): Pipe { return new AsyncPipe(cdRef); }
-}
+}

modules/angular2/src/change_detection/pipes/date_pipe.ts

@@ -5,12 +5,13 @@ import {
   Date,
   DateWrapper,
   CONST,
+  isBlank,
   FunctionWrapper
 } from 'angular2/src/facade/lang';
 import {DateFormatter} from 'angular2/src/facade/intl';
+import {Injectable} from 'angular2/di';
 import {StringMapWrapper, ListWrapper} from 'angular2/src/facade/collection';
-import {Pipe, BasePipe, PipeFactory} from './pipe';
-import {ChangeDetectorRef} from '../change_detector_ref';
+import {Pipe, BasePipe, InvalidPipeArgumentException} from './pipe';
 
 // TODO: move to a global configable location along with other i18n components.
 var defaultLocale: string = 'en-US';
@@ -70,7 +71,8 @@ var defaultLocale: string = 'en-US';
  *     {{ dateObj | date:'mmss' }}        // output is '43:11'
  */
 @CONST()
-export class DatePipe extends BasePipe implements PipeFactory {
+@Injectable()
+export class DatePipe extends BasePipe {
   static _ALIASES = {
     'medium': 'yMMMdjms',
     'short': 'yMdjm',
@@ -84,6 +86,12 @@ export class DatePipe extends BasePipe implements PipeFactory {
 
 
   transform(value: any, args: List<any>): string {
+    if (isBlank(value)) return null;
+
+    if (!this.supports(value)) {
+      throw new InvalidPipeArgumentException(DatePipe, value);
+    }
+
     var pattern: string = isPresent(args) && args.length > 0 ? args[0] : 'mediumDate';
     if (isNumber(value)) {
       value = DateWrapper.fromMillis(value);
@@ -95,6 +103,4 @@ export class DatePipe extends BasePipe implements PipeFactory {
   }
 
   supports(obj: any): boolean { return isDate(obj) || isNumber(obj); }
-
-  create(cdRef: ChangeDetectorRef): Pipe { return this; }
 }

modules/angular2/src/change_detection/pipes/json_pipe.ts

@@ -1,6 +1,6 @@
 import {isBlank, isPresent, Json, CONST} from 'angular2/src/facade/lang';
-import {Pipe, BasePipe, PipeFactory} from './pipe';
-import {ChangeDetectorRef} from '../change_detector_ref';
+import {Injectable} from 'angular2/di';
+import {Pipe, BasePipe} from './pipe';
 
 /**
  * Implements json transforms to any object.
@@ -26,8 +26,7 @@ import {ChangeDetectorRef} from '../change_detector_ref';
  * ```
  */
 @CONST()
-export class JsonPipe extends BasePipe implements PipeFactory {
+@Injectable()
+export class JsonPipe extends BasePipe {
   transform(value: any, args: List<any> = null): string { return Json.stringify(value); }
-
-  create(cdRef: ChangeDetectorRef): Pipe { return this; }
 }

modules/angular2/src/change_detection/pipes/limit_to_pipe.ts

@@ -8,8 +8,8 @@ import {
 } from 'angular2/src/facade/lang';
 import {ListWrapper} from 'angular2/src/facade/collection';
 import {Math} from 'angular2/src/facade/math';
-import {WrappedValue, Pipe, PipeFactory} from './pipe';
-import {ChangeDetectorRef} from '../change_detector_ref';
+import {Injectable} from 'angular2/di';
+import {WrappedValue, Pipe, InvalidPipeArgumentException} from './pipe';
 
 /**
  * Creates a new List or String containing only a prefix/suffix of the
@@ -50,15 +50,18 @@ import {ChangeDetectorRef} from '../change_detector_ref';
  *     {{ 'abcdefghij' | limitTo: -4 }}      // output is 'ghij'
  *     {{ 'abcdefghij' | limitTo: -100 }}    // output is 'abcdefghij'
  */
+@Injectable()
 export class LimitToPipe implements Pipe {
-  static supportsObj(obj: any): boolean { return isString(obj) || isArray(obj); }
-
-  supports(obj: any): boolean { return LimitToPipe.supportsObj(obj); }
+  supports(obj: any): boolean { return isString(obj) || isArray(obj); }
 
   transform(value: any, args: List<any> = null): any {
     if (isBlank(args) || args.length == 0) {
       throw new BaseException('limitTo pipe requires one argument');
     }
+    if (!this.supports(value)) {
+      throw new InvalidPipeArgumentException(LimitToPipe, value);
+    }
+    if (isBlank(value)) return value;
     var limit: int = args[0];
     var left = 0, right = Math.min(limit, value.length);
     if (limit < 0) {
@@ -73,10 +76,3 @@ export class LimitToPipe implements Pipe {
 
   onDestroy(): void {}
 }
-
-@CONST()
-export class LimitToPipeFactory implements PipeFactory {
-  supports(obj: any): boolean { return LimitToPipe.supportsObj(obj); }
-
-  create(cdRef: ChangeDetectorRef): Pipe { return new LimitToPipe(); }
-}

modules/angular2/src/change_detection/pipes/lowercase_pipe.ts

@@ -1,6 +1,6 @@
-import {isString, StringWrapper, CONST} from 'angular2/src/facade/lang';
-import {Pipe, BasePipe, PipeFactory} from './pipe';
-import {ChangeDetectorRef} from '../change_detector_ref';
+import {isString, StringWrapper, CONST, isBlank} from 'angular2/src/facade/lang';
+import {Injectable} from 'angular2/di';
+import {Pipe, BasePipe, InvalidPipeArgumentException} from './pipe';
 
 /**
  * Implements lowercase transforms to text.
@@ -23,12 +23,13 @@ import {ChangeDetectorRef} from '../change_detector_ref';
  * ```
  */
 @CONST()
-export class LowerCasePipe extends BasePipe implements PipeFactory {
-  supports(str: any): boolean { return isString(str); }
-
+@Injectable()
+export class LowerCasePipe extends BasePipe {
   transform(value: string, args: List<any> = null): string {
+    if (isBlank(value)) return value;
+    if (!isString(value)) {
+      throw new InvalidPipeArgumentException(LowerCasePipe, value);
+    }
     return StringWrapper.toLowerCase(value);
   }
-
-  create(cdRef: ChangeDetectorRef): Pipe { return this; }
 }