feat(refactor): replaced ObservablePipe and PromisePipe with AsyncPipe

Author: vsavkin

modules/angular2/pipes.ts

@@ -4,10 +4,9 @@
  * This module provides advanced support for extending change detection.
  */
 
-export {PromisePipe} from './src/change_detection/pipes/promise_pipe';
 export {UpperCasePipe} from './src/change_detection/pipes/uppercase_pipe';
 export {LowerCasePipe} from './src/change_detection/pipes/lowercase_pipe';
-export {ObservablePipe} from './src/change_detection/pipes/observable_pipe';
+export {AsyncPipe} from './src/change_detection/pipes/async_pipe';
 export {JsonPipe} from './src/change_detection/pipes/json_pipe';
 export {DatePipe} from './src/change_detection/pipes/date_pipe';
 export {DecimalPipe, PercentPipe, CurrencyPipe} from './src/change_detection/pipes/number_pipe';

modules/angular2/src/change_detection/change_detection.ts

@@ -7,8 +7,7 @@ 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 {ObservablePipeFactory} from './pipes/observable_pipe';
-import {PromisePipeFactory} from './pipes/promise_pipe';
+import {AsyncPipeFactory} from './pipes/async_pipe';
 import {UpperCasePipe} from './pipes/uppercase_pipe';
 import {LowerCasePipe} from './pipes/lowercase_pipe';
 import {JsonPipe} from './pipes/json_pipe';
@@ -75,11 +74,8 @@ export const iterableDiff: IterableDifferFactory[] =
 /**
  * Async binding to such types as Observable.
  */
-export const async: List<PipeFactory> = CONST_EXPR([
-  CONST_EXPR(new ObservablePipeFactory()),
-  CONST_EXPR(new PromisePipeFactory()),
-  CONST_EXPR(new NullPipeFactory())
-]);
+export const async: List<PipeFactory> =
+    CONST_EXPR([CONST_EXPR(new AsyncPipeFactory()), CONST_EXPR(new NullPipeFactory())]);
 
 /**
  * Uppercase text transform.

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

@@ -0,0 +1,134 @@
+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 {ChangeDetectorRef} from '../change_detector_ref';
+
+
+class ObservableStrategy {
+  createSubscription(async: any, updateLatestValue: any): any {
+    return ObservableWrapper.subscribe(async, updateLatestValue, e => { throw e; });
+  }
+
+  dispose(subscription: any): void { ObservableWrapper.dispose(subscription); }
+
+  onDestroy(subscription: any): void { ObservableWrapper.dispose(subscription); }
+}
+
+class PromiseStrategy {
+  createSubscription(async: any, updateLatestValue: any): any {
+    return async.then(updateLatestValue);
+  }
+
+  dispose(subscription: any): void {}
+
+  onDestroy(subscription: any): void {}
+}
+
+var _promiseStrategy = new PromiseStrategy();
+var _observableStrategy = new ObservableStrategy();
+
+
+/**
+ * Implements async bindings to Observable and Promise.
+ *
+ * # Example
+ *
+ * In this example we bind the description observable to the DOM. The async pipe will convert an
+ *observable to the
+ * latest value it emitted. It will also request a change detection check when a new value is
+ *emitted.
+ *
+ *  ```
+ * @Component({
+ *   selector: "task-cmp",
+ *   changeDetection: ON_PUSH
+ * })
+ * @View({
+ *   template: "Task Description {{ description | async }}"
+ * })
+ * class Task {
+ *  description:Observable<string>;
+ * }
+ *
+ * ```
+ */
+export class AsyncPipe implements Pipe {
+  _latestValue: Object = null;
+  _latestReturnedValue: Object = null;
+
+  _subscription: Object = null;
+  _obj: Observable | Promise<any> = null;
+  private _strategy: any = null;
+
+  constructor(public _ref: ChangeDetectorRef) {}
+
+  supports(obj: any): boolean { return true; }
+
+  onDestroy(): void {
+    if (isPresent(this._subscription)) {
+      this._dispose();
+    }
+  }
+
+  transform(obj: Observable | Promise<any>, args?: any[]): any {
+    if (isBlank(this._obj)) {
+      if (isPresent(obj)) {
+        this._subscribe(obj);
+      }
+      return null;
+    }
+
+    if (obj !== this._obj) {
+      this._dispose();
+      return this.transform(obj);
+    }
+
+    if (this._latestValue === this._latestReturnedValue) {
+      return this._latestReturnedValue;
+    } else {
+      this._latestReturnedValue = this._latestValue;
+      return WrappedValue.wrap(this._latestValue);
+    }
+  }
+
+  _subscribe(obj: Observable | Promise<any>): void {
+    this._obj = obj;
+    this._strategy = this._selectStrategy(obj);
+    this._subscription =
+        this._strategy.createSubscription(obj, value => this._updateLatestValue(obj, value));
+  }
+
+  _selectStrategy(obj: Observable | Promise<any>) {
+    if (isPromise(obj)) {
+      return _promiseStrategy;
+    } else if (ObservableWrapper.isObservable(obj)) {
+      return _observableStrategy;
+    } else {
+      throw new BaseException(`Async pipe does not support object '${obj}'`);
+    }
+  }
+
+  _dispose(): void {
+    this._strategy.dispose(this._subscription);
+    this._latestValue = null;
+    this._latestReturnedValue = null;
+    this._subscription = null;
+    this._obj = null;
+  }
+
+  _updateLatestValue(async: any, value: Object) {
+    if (async === this._obj) {
+      this._latestValue = value;
+      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/observable_pipe.ts

@@ -1,5 +1,6 @@
 import {
   ChangeDetector,
+  ChangeDetectorRef,
   ProtoChangeDetector,
   DynamicChangeDetector
 } from 'angular2/src/change_detection/change_detection';
@@ -26,3 +27,7 @@ export class SpyPipeFactory extends SpyObject {}
 export class SpyDependencyProvider extends SpyObject {}
 
 export class SpyIterableDifferFactory extends SpyObject {}
+
+export class SpyChangeDetectorRef extends SpyObject {
+  constructor() { super(ChangeDetectorRef); }
+}