refactor(change_detection): removed NO_CHANGED and replaced it with WrappedValue

modules/angular2/test/change_detection/change_detection_spec.js

@@ -8,7 +8,7 @@ import {Lexer} from 'angular2/src/change_detection/parser/lexer';
 import {Locals} from 'angular2/src/change_detection/parser/locals';
 
 import {ChangeDispatcher, DynamicChangeDetector, ChangeDetectionError, BindingRecord, DirectiveRecord, DirectiveIndex,
-  PipeRegistry, Pipe, NO_CHANGE, CHECK_ALWAYS, CHECK_ONCE, CHECKED, DETACHED, ON_PUSH, DEFAULT} from 'angular2/change_detection';
+  PipeRegistry, Pipe, CHECK_ALWAYS, CHECK_ONCE, CHECKED, DETACHED, ON_PUSH, DEFAULT, WrappedValue} from 'angular2/change_detection';
 
 import {JitProtoChangeDetector, DynamicProtoChangeDetector} from 'angular2/src/change_detection/proto_change_detector';
 
@@ -733,7 +733,7 @@ export function main() {
           });
         });
 
-        it("should do nothing when returns NO_CHANGE", () => {
+        it("should do nothing when no change", () => {
           var registry = new FakePipeRegistry('pipe', () => new IdentityPipe())
           var ctx = new Person("Megatron");
 
@@ -741,16 +741,27 @@ export function main() {
           var cd = c["changeDetector"];
           var dispatcher = c["dispatcher"];
 
-          cd.detectChanges();
           cd.detectChanges();
 
           expect(dispatcher.log).toEqual(['memo=Megatron']);
 
-          ctx.name = "Optimus Prime";
           dispatcher.clear();
           cd.detectChanges();
 
-          expect(dispatcher.log).toEqual(['memo=Optimus Prime']);
+          expect(dispatcher.log).toEqual([]);
+        });
+
+        it("should unwrap the wrapped value", () => {
+          var registry = new FakePipeRegistry('pipe', () => new WrappedPipe())
+          var ctx = new Person("Megatron");
+
+          var c  = createChangeDetector("memo", "name | pipe", ctx, null, registry);
+          var cd = c["changeDetector"];
+          var dispatcher = c["dispatcher"];
+
+          cd.detectChanges();
+
+          expect(dispatcher.log).toEqual(['memo=Megatron']);
         });
       });
   });
@@ -798,19 +809,14 @@ class OncePipe extends Pipe {
 }
 
 class IdentityPipe extends Pipe {
-  state:any;
-
-  supports(newValue) {
-    return true;
-  }
-
   transform(value) {
-    if (this.state === value) {
-      return NO_CHANGE;
-    } else {
-      this.state = value;
-      return value;
-    }
+    return value;
+  }
+}
+
+class WrappedPipe extends Pipe {
+  transform(value) {
+    return WrappedValue.wrap(value);
   }
 }
 

modules/angular2/test/change_detection/pipes/async_pipe_spec.js

@@ -2,8 +2,8 @@ import {ddescribe, describe, it, iit, xit, expect, beforeEach, afterEach,
   AsyncTestCompleter, inject, proxy, SpyObject} from 'angular2/test_lib';
 import {IMPLEMENTS} from 'angular2/src/facade/lang';
 
+import {WrappedValue} from 'angular2/src/change_detection/pipes/pipe';
 import {AsyncPipe} from 'angular2/src/change_detection/pipes/async_pipe';
-import {NO_CHANGE} from 'angular2/src/change_detection/pipes/pipe';
 import {ChangeDetectorRef} from 'angular2/src/change_detection/change_detector_ref';
 import {EventEmitter, Observable, ObservableWrapper, PromiseWrapper} from 'angular2/src/facade/async';
 
@@ -36,25 +36,25 @@ export function main() {
         expect(pipe.transform(emitter)).toBe(null);
       });
 
-      it("should return the latest available value", inject([AsyncTestCompleter], (async) => {
+      it("should return the latest available value wrapped", inject([AsyncTestCompleter], (async) => {
         pipe.transform(emitter);
 
         ObservableWrapper.callNext(emitter, message);
 
         PromiseWrapper.setTimeout(() => {
-          expect(pipe.transform(emitter)).toEqual(message);
+          expect(pipe.transform(emitter)).toEqual(new WrappedValue(message));
           async.done();
         }, 0)
       }));
 
-      it("should return NO_CHANGE when nothing has changed since the last call",
+      it("should return same value when nothing has changed since the last call",
           inject([AsyncTestCompleter], (async) => {
         pipe.transform(emitter);
         ObservableWrapper.callNext(emitter, message);
 
         PromiseWrapper.setTimeout(() => {
           pipe.transform(emitter);
-          expect(pipe.transform(emitter)).toBe(NO_CHANGE);
+          expect(pipe.transform(emitter)).toBe(message);
           async.done();
         }, 0)
       }));
@@ -66,11 +66,11 @@ export function main() {
         var newEmitter = new EventEmitter();
         expect(pipe.transform(newEmitter)).toBe(null);
 
-        // this should not affect the pipe, so it should return NO_CHANGE
+        // this should not affect the pipe
         ObservableWrapper.callNext(emitter, message);
 
         PromiseWrapper.setTimeout(() => {
-          expect(pipe.transform(newEmitter)).toBe(NO_CHANGE);
+          expect(pipe.transform(newEmitter)).toBe(null);
           async.done();
         }, 0)
       }));