feature(change detection): implement barebone ChangeDetector

fixes angular#39

modules/change_detection/src/change_detection.js → modules/change_detection/src/change_detector.js

@@ -1,21 +1,23 @@
-import {ProtoWatchGrou, WatchGroup} from './watch_group';
+import {ProtoWatchGroup, WatchGroup} from './watch_group';
 import {ProtoRecord, Record} from './record';
 import {FIELD} from 'facade/lang';
 export * from './record';
 export * from './watch_group'
 
-export class ChangeDetection {
+export class ChangeDetector {
 
   @FIELD('final _rootWatchGroup:WatchGroup')
   constructor(watchGroup:WatchGroup) {
     this._rootWatchGroup = watchGroup;
   }
 
   detectChanges():int {
-    var current:Record = _rootWatchGroup.headRecord;
-    var count:number = 0;
-    while (current != null) {
-      if (current.check()) {
+    var record:Record = this._rootWatchGroup.headRecord;
+    var count:int = 0;
+    for (record = this._rootWatchGroup.headRecord;
+         record != null;
+         record = record.checkNext) {
+      if (record.check()) {
         count++;
       }
     }

modules/change_detection/src/facade.dart

@@ -1,3 +1,14 @@
 library change_detection.facade;
 
+@MirrorsUsed(targets: const [FieldGetterFactory], metaTargets: const [] )
+import 'dart:mirrors';
+
 typedef SetterFn(Object obj, value);
+
+class FieldGetterFactory {
+  getter(Object object, String name) {
+    Symbol symbol = new Symbol(name);
+    InstanceMirror instanceMirror = reflect(object);
+    return (Object object) => instanceMirror.getField(symbol).reflectee;
+  }
+}

modules/change_detection/src/facade.es6

@@ -1 +1,7 @@
 export var SetterFn = Function;
+
+export class FieldGetterFactory {
+  getter(object, name:string) {
+    return new Function('o', 'return o[' + name + ']');
+  }
+}

modules/change_detection/src/record.js

@@ -1,48 +1,28 @@
-//import * as wg from './watch_group';
+import {ProtoWatchGroup, WatchGroup} from './watch_group';
 import {FIELD} from 'facade/lang';
+import {FieldGetterFactory} from './facade';
 
 /**
- * For now we are dropping expression coelescence. We can always add it later, but
- * real world numbers should that it does not provide significant benefits.
+ * For now we are dropping expression coalescence. We can always add it later, but
+ * real world numbers show that it does not provide significant benefits.
  */
 export class ProtoRecord {
-
   @FIELD('final watchGroup:wg.ProtoWatchGroup')
   @FIELD('final fieldName:String')
   /// order list of all records. Including head/tail markers
   @FIELD('next:ProtoRecord')
   @FIELD('prev:ProtoRecord')
-  // Opeque data which will be the target of notification.
-  // If the object is instance of Record, than it it is directly procssed
+  // Opaque data which will be the target of notification.
+  // If the object is instance of Record, than it it is directly processed
   // Otherwise it is the context used by  WatchGroupDispatcher.
   @FIELD('memento')
-  @FIELD('_clone')
-  constructor(watchGroup/*:wg.ProtoWatchGroup*/, fieldName:String, memento) {
+  constructor(watchGroup:ProtoWatchGroup, fieldName:string, dispatchMemento) {
     this.watchGroup = watchGroup;
     this.fieldName = fieldName;
-    this.memento = memento;
+    this.dispatchMemento = dispatchMemento;
     this.next = null;
     this.prev = null;
-    this.changeNotifier = null;
-    this._clone = null;
-    this.changeContext = null;
-    this.dispatcherContext = null;
  }
-
-  instantiate(watchGroup/*:wg.WatchGroup*/):Record {
-    var record = this._clone = new Record(watchGroup, this);
-    record.prev = this.prev._clone;
-    record._checkPrev = this.prev._clone;
-    return _clone;
-  }
-
-  instantiateComplete():Record {
-    var record = this._clone;
-    record.next = this.next._clone;
-    record._checkNext = this.next._clone;
-    this._clone = null;
-    return this.next;
-  }
 }
 
 
@@ -59,11 +39,8 @@ export class ProtoRecord {
  *  - Atomic watch operations
  *  - Defaults to dirty checking
  *  - Keep this object as lean as possible. (Lean in number of fields)
- *
- * MEMORY COST: 13 Words;
  */
 export class Record {
-
   @FIELD('final watchGroup:WatchGroup')
   @FIELD('final protoRecord:ProtoRecord')
   /// order list of all records. Including head/tail markers
@@ -86,57 +63,87 @@ export class Record {
     this.watchGroup = watchGroup;
     this.next = null;
     this.prev = null;
-    this._checkNext = null;
-    this._checkPrev = null;
-    this._notifierNext = null;
-
-    this._mode = MODE_STATE_MARKER;
-    this._context = null;
-    this._getter = null;
-    this._arguments = null;
-    this.currentValue = null;
+    this.checkNext = null;
+    this.checkPrev = null;
+    this.notifierNext = null;
+
+    this.mode = MODE_STATE_MARKER;
+    this.context = null;
+    this.getter = null;
+    this.arguments = null;
+    // The value of this record as observed during the last call to `check()`
     this.previousValue = null;
   }
 
   check():bool {
-    var mode = this._mode;
+    var mode = this.mode;
     var state = mode & MODE_MASK_STATE;
     var notify = mode & MODE_MASK_NOTIFY;
-    var currentValue;
+    var newValue;
     switch (state) {
       case MODE_STATE_MARKER:
         return false;
       case MODE_STATE_PROPERTY:
-        currentValue = this._getter(this._context);
+        newValue = this.getter(this.context);
         break;
       case MODE_STATE_INVOKE_CLOSURE:
-        currentValue = this._context(this._arguments);
+        newValue = this.context(this.arguments);
         break;
       case MODE_STATE_INVOKE_METHOD:
-        currentValue = this._getter(this._context, this._arguments);
+        newValue = this.getter(this.context, this.arguments);
         break;
       case MODE_STATE_MAP:
+        throw 'not implemented';
       case MODE_STATE_LIST:
+        throw 'not implemented';
+      default:
+        throw 'not implemented';
     }
-    var previousValue = this.previousValue;
-    if (isSame(previousValue, currentValue)) return false;
-    if (previousValue instanceof String && currentValue instanceof String
-        && previousValue == currentValue) {
-      this.previousValue = currentValue;
-      return false
+
+    var previousValue;
+
+    if (this.previousValue === this) {
+      // When the record is checked for the first time we should always notify
+      previousValue = null;
+    } else {
+      previousValue = this.previousValue;
+
+      if (isSame(previousValue, newValue)) return false;
+
+      // In Dart, we can have `str1 !== str2` but `str1 == str2`
+      if (previousValue instanceof String &&
+          newValue instanceof String &&
+          previousValue == newValue) {
+        this.previousValue = newValue;
+        return false
+      }
     }
-    this.previousValue = currentValue;
-    if (this.protoRecord.changeContext instanceof ProtoRecord) {
-      // forward propaget to the next record
+
+    // todo(vicb): compute this info only once in ctor ? (add a bit in mode not to grow the mem req)
+    if (this.protoRecord.dispatchMemento === null) {
+      // forward propagate to the next record
     } else {
-      // notify throught dispatcher
-      this.watchGroup.dispatcher.onRecordChange(this, this.protoRecord.dispatcherContext);
+      // notify through dispatcher
+      this.watchGroup.dispatcher.onRecordChange(this, newValue, this.protoRecord.dispatchMemento);
     }
+
+    this.previousValue = newValue;
+
     return true;
   }
+
+  setContext(context) {
+    // use `this` as a marker for a fresh record
+    this.previousValue = this;
+    this.mode = MODE_STATE_PROPERTY;
+    this.context = context;
+    var factory = new FieldGetterFactory();
+    this.getter = factory.getter(context, this.protoRecord.fieldName);
+  }
+
 }
 
-// The mode is devided into two partes. Which notification mechanism
+// The mode is divided into two parts. Which notification mechanism
 // to use and which dereference mode to execute.
 
 // We use dirty checking aka no notification
@@ -160,11 +167,7 @@ const MODE_STATE_MAP = 0x0004;
 const MODE_STATE_LIST = 0x0005;
 
 function isSame(a, b) {
-  if (a === b) {
-    return true;
-  } else if ((a !== a) && (b !== b)) {
-    return true;
-  } else {
-    return false;
-  }
+  if (a === b) return true;
+  if ((a !== a) && (b !== b)) return true;
+  return false;
 }

modules/change_detection/src/watch_group.js

@@ -13,38 +13,47 @@ export class ProtoWatchGroup {
    * Parses [expression] into [ProtoRecord]s and adds them to [ProtoWatchGroup].
    *
    * @param expression The expression to watch
-   * @param memento an opeque object which will be bassed to WatchGroupDispatcher on
+   * @param memento an opaque object which will be passed to WatchGroupDispatcher on
    *        detecting a change.
    * @param shallow Should collections be shallow watched
    */
   watch(
-    expression:String,
+    expression:string,
     memento,
-    {shallow/*=false*/}:{shallow:bool})
+    {shallow/*=false*/} /*:{shallow:boolean}*/)
   {
-    /// IMPLEMENT
+    var protoRecord = new ProtoRecord(this, expression, memento);
+
+    if (this.headRecord === null) {
+      this.headRecord = this.tailRecord = protoRecord;
+    } else {
+      this.tailRecord.next = protoRecord;
+      protoRecord.prev = this.tailRecord;
+      this.tailRecord = protoRecord;
+    }
   }
 
   instantiate(dispatcher:WatchGroupDispatcher):WatchGroup {
     var watchGroup:WatchGroup = new WatchGroup(this, dispatcher);
-    var head:Record = null;
     var tail:Record = null;
-    var proto:ProtoRecord = this.headRecord;
+    var proto:ProtoRecord;
+    var prevRecord:Record = null;
 
-    while(proto != null) {
-      tail = proto.instantiate(watchGroup);
-      if (head == null) head = tail;
-      proto = proto.next;
-    }
+    if (this.headRecord !== null) {
+      watchGroup.headRecord = tail = new Record(watchGroup, this.headRecord);
 
-    proto = this.headRecord;
-    while(proto != null) {
-      proto.instantiateComplete();
-      proto = proto.next;
+      for (proto = this.headRecord.next; proto != null; proto = proto.next) {
+        prevRecord = tail;
+        tail = new Record(watchGroup, proto);
+        tail.prev = prevRecord;
+        prevRecord.next = tail;
+        tail.checkPrev = prevRecord;
+        prevRecord.checkNext = tail;
+      }
+
+      watchGroup.tailRecord = tail;
     }
 
-    watchGroup.headRecord = head;
-    watchGroup.tailRecord = tail;
     return watchGroup;
   }
 
@@ -60,27 +69,34 @@ export class WatchGroup {
     this.dispatcher = dispatcher;
     this.headRecord = null;
     this.tailRecord = null;
+    this.context = null;
   }
 
   insertChildGroup(newChild:WatchGroup, insertAfter:WatchGroup) {
-    /// IMPLEMENT
+    throw 'not implemented';
   }
 
   remove() {
-    /// IMPLEMENT
+    throw 'not implemented';
   }
 
   /**
    * Sets the context (the object) on which the change detection expressions will
    * dereference themselves on. Since the WatchGroup can be reused the context
    * can be re-set many times during the lifetime of the WatchGroup.
    *
-   * @param context the new context for change dection for the curren WatchGroup
+   * @param context the new context for change detection for the current WatchGroup
    */
   setContext(context) {
+    for (var record:Record = this.headRecord;
+         record != null;
+         record = record.next) {
+      record.setContext(context);
+    }
   }
 }
 
 export class WatchGroupDispatcher {
-  onRecordChange(record:Record, context) {}
+  // The record holds the previous value at the time of the call
+  onRecordChange(record:Record, newValue, context) {}
 }