feat(change_detection): add mode to ChangeDetector

Author: vsavkin

modules/change_detection/src/abstract_change_detector.js

@@ -1,12 +1,15 @@
+import {isPresent} from 'facade/src/lang';
 import {List, ListWrapper} from 'facade/src/collection';
-import {ChangeDetector} from './interfaces';
+import {ChangeDetector, CHECK_ALWAYS, CHECK_ONCE, CHECKED, DETACHED} from './interfaces';
 
 export class AbstractChangeDetector extends ChangeDetector {
  children:List;
  parent:ChangeDetector;
+ status:string;
 
  constructor() {
  this.children = [];
+ this.status = CHECK_ALWAYS;
  }
 
  addChild(cd:ChangeDetector) {
@@ -31,8 +34,20 @@ export class AbstractChangeDetector extends ChangeDetector {
  }
 
  _detectChanges(throwOnChange:boolean) {
+ if (this.mode === DETACHED || this.mode === CHECKED) return;
+
  this.detectChangesInRecords(throwOnChange);
  this._detectChangesInChildren(throwOnChange);
+
+ if (this.mode === CHECK_ONCE) this.mode = CHECKED;
+ }
+
+ markAsCheckOnce(){
+ var c = this;
+ while(isPresent(c) && (c.mode === CHECKED || c.mode === CHECK_ALWAYS)) {
+ if (c.mode === CHECKED) c.mode = CHECK_ONCE;
+ c = c.parent;
+ }
  }
 
  detectChangesInRecords(throwOnChange:boolean){}

modules/change_detection/src/binding_propagation_config.js

@@ -0,0 +1,88 @@
+import {isPresent} from 'facade/lang';
+import {List, ListWrapper, Map, MapWrapper} from 'facade/collection';
+import {RECORD_TYPE_SELF, ProtoRecord} from './proto_change_detector';
+
+/**
+ * Removes "duplicate" records. It assuming that record evaluation does not
+ * have side-effects.
+ *
+ * Records that are not last in bindings are removed and all the indices
+ * of the records that depend on them are updated.
+ *
+ * Records that are last in bindings CANNOT be removed, and instead are
+ * replaced with very cheap SELF records.
+ */
+export function coalesce(records:List<ProtoRecord>):List<ProtoRecord> {
+ var res = ListWrapper.create();
+ var indexMap = MapWrapper.create();
+
+ for (var i = 0; i < records.length; ++i) {
+ var r = records[i];
+ var record = _replaceIndices(r, res.length + 1, indexMap);
+ var matchingRecord = _findMatching(record, res);
+
+ if (isPresent(matchingRecord) && record.lastInBinding) {
+ ListWrapper.push(res, _selfRecord(record, matchingRecord.selfIndex, res.length + 1));
+ MapWrapper.set(indexMap, r.selfIndex, matchingRecord.selfIndex);
+
+ } else if (isPresent(matchingRecord) && !record.lastInBinding) {
+ MapWrapper.set(indexMap, r.selfIndex, matchingRecord.selfIndex);
+
+ } else {
+ ListWrapper.push(res, record);
+ MapWrapper.set(indexMap, r.selfIndex, record.selfIndex);
+ }
+ }
+
+ return res;
+}
+
+function _selfRecord(r:ProtoRecord, contextIndex:number, selfIndex:number):ProtoRecord {
+ return new ProtoRecord(
+ RECORD_TYPE_SELF,
+ "self",
+ null,
+ [],
+ r.fixedArgs,
+ contextIndex,
+ selfIndex,
+ r.bindingMemento,
+ r.groupMemento,
+ r.expressionAsString,
+ r.lastInBinding,
+ r.lastInGroup
+ );
+}
+
+function _findMatching(r:ProtoRecord, rs:List<ProtoRecord>){
+ return ListWrapper.find(rs, (rr) =>
+ rr.mode === r.mode &&
+ rr.funcOrValue === r.funcOrValue &&
+ rr.contextIndex === r.contextIndex &&
+ ListWrapper.equals(rr.args, r.args)
+ );
+}
+
+function _replaceIndices(r:ProtoRecord, selfIndex:number, indexMap:Map) {
+ var args = ListWrapper.map(r.args, (a) => _map(indexMap, a));
+ var contextIndex = _map(indexMap, r.contextIndex);
+ return new ProtoRecord(
+ r.mode,
+ r.name,
+ r.funcOrValue,
+ args,
+ r.fixedArgs,
+ contextIndex,
+ selfIndex,
+ r.bindingMemento,
+ r.groupMemento,
+ r.expressionAsString,
+ r.lastInBinding,
+ r.lastInGroup
+ );
+}
+
+function _map(indexMap:Map, value:number) {
+ var r = MapWrapper.get(indexMap, value)
+ return isPresent(r) ? r : value;
+}

modules/change_detection/src/interfaces.js

@@ -19,12 +19,38 @@ export class ChangeRecord {
  }
 }
 
+
+/**
+ * CHECK_ONCE means that after calling detectChanges the mode of the change detector
+ * will become CHECKED.
+ */
+export const CHECK_ONCE="CHECK_ONCE";
+
+/**
+ * CHECKED means that the change detector should be skipped until its mode changes to
+ * CHECK_ONCE or CHECK_ALWAYS.
+ */
+export const CHECKED="CHECKED";
+
+/**
+ * CHECK_ALWAYS means that after calling detectChanges the mode of the change detector
+ * will remain CHECK_ALWAYS.
+ */
+export const CHECK_ALWAYS="ALWAYS_CHECK";
+
+/**
+ * DETACHED means that the change detector sub tree is not a part of the main tree and
+ * should be skipped.
+ */
+export const DETACHED="DETACHED";
+
 export class ChangeDispatcher {
  onRecordChange(groupMemento, records:List<ChangeRecord>) {}
 }
 
 export class ChangeDetector {
  parent:ChangeDetector;
+ mode:string;
 
  addChild(cd:ChangeDetector) {}
  removeChild(cd:ChangeDetector) {}

modules/change_detection/test/change_detection_spec.js

@@ -13,6 +13,7 @@ import {ChangeDispatcher, DynamicChangeDetector, ChangeDetectionError, ContextWi
 
 
 import {JitProtoChangeDetector, DynamicProtoChangeDetector} from 'change_detection/src/proto_change_detector';
+import {CHECK_ALWAYS, CHECK_ONCE, CHECKED, DETACHED} from 'change_detection/src/interfaces';
 
 
 export function main() {
@@ -473,6 +474,75 @@ export function main() {
  expect(count).toEqual(1);
  });
  });
+
+ describe("mode", () => {
+ it("should not check a detached change detector", () => {
+ var c = createChangeDetector('name', 'a', new TestData("value"));
+ var cd = c["changeDetector"];
+ var dispatcher = c["dispatcher"];
+
+ cd.mode = DETACHED;
+ cd.detectChanges();
+
+ expect(dispatcher.log).toEqual([]);
+ });
+
+ it("should not check a checked change detector", () => {
+ var c = createChangeDetector('name', 'a', new TestData("value"));
+ var cd = c["changeDetector"];
+ var dispatcher = c["dispatcher"];
+
+ cd.mode = CHECKED;
+ cd.detectChanges();
+
+ expect(dispatcher.log).toEqual([]);
+ });
+
+ it("should change CHECK_ONCE to CHECKED", () => {
+ var cd = createProtoChangeDetector().instantiate(null, null);
+ cd.mode = CHECK_ONCE;
+
+ cd.detectChanges();
+
+ expect(cd.mode).toEqual(CHECKED);
+ });
+
+ it("should not change the CHECK_ALWAYS", () => {
+ var cd = createProtoChangeDetector().instantiate(null, null);
+ cd.mode = CHECK_ALWAYS;
+
+ cd.detectChanges();
+
+ expect(cd.mode).toEqual(CHECK_ALWAYS);
+ });
+ });
+
+ describe("markAsCheckOnce", () => {
+ function changeDetector(mode, parent) {
+ var cd = createProtoChangeDetector().instantiate(null, null);
+ cd.mode = mode;
+ if (isPresent(parent)) parent.addChild(cd);
+ return cd;
+ }
+
+ it("should mark all checked detectors as CHECK_ONCE " +
+ "until reaching a detached one", () => {
+
+ var root = changeDetector(CHECK_ALWAYS, null);
+ var disabled = changeDetector(DETACHED, root);
+ var parent = changeDetector(CHECKED, disabled);
+ var child = changeDetector(CHECK_ALWAYS, parent);
+ var grandChild = changeDetector(CHECKED, child);
+
+ grandChild.markAsCheckOnce();
+
+ expect(root.mode).toEqual(CHECK_ALWAYS);
+ expect(disabled.mode).toEqual(DETACHED);
+ expect(parent.mode).toEqual(CHECK_ONCE);
+ expect(child.mode).toEqual(CHECK_ALWAYS);
+ expect(grandChild.mode).toEqual(CHECK_ONCE);
+ });
+ });
  });
  });
 }