thenable active expressions

SQUASHED: AUTO-COMMIT-src-client-reactive-active-expression-active-expression.js,AUTO-COMMIT-src-client-reactive-test-active-expression-utility-methods.spec.js,AUTO-COMMIT-src-components-tools-lively-editor.js,

Author: onsetsu

src/client/reactive/active-expression/active-expression.js

@@ -457,6 +457,21 @@ export class BaseActiveExpression {
     if(value !== undefined)this.meta({isMeta : value});
     else return this.meta().has('isMeta') && this.meta().get('isMeta');
   }
+  
+  /*MD ## Iterators and Utility Methods MD*/
+  nextValue() {
+    return new Promise((resolve, reject) => {
+      const callback = value => {
+        this.offChange(callback);
+        resolve(value);
+      };
+      this.onChange(callback);
+    });
+  }
+  
+  then(...args) {
+    return this.nextValue().then(...args);
+  }
 }
 
 export function aexpr(func, ...args) {

src/client/reactive/test/active-expression/utility-methods.spec.js

@@ -0,0 +1,167 @@
+"enable aexpr";
+
+import chai, {expect} from 'src/external/chai.js';
+import sinon from 'src/external/sinon-3.2.1.js';
+import sinonChai from 'src/external/sinon-chai.js';
+chai.use(sinonChai);
+
+describe('Iterators and Utility Methods for Active Expressions', () => {
+  it("chainable", () => {
+    let obj = {a: 2},
+        spy = sinon.spy();
+
+    aexpr(() => obj.a > 5)
+      .onBecomeFalse(spy)
+      .onBecomeTrue(spy)
+      .onBecomeFalse(spy)
+      .onBecomeTrue(spy);
+
+    expect(spy).to.be.calledTwice;
+  });
+
+  it("flank up", () => {
+    let obj = {a: 2},
+        spy = sinon.spy();
+
+    let axp = aexpr(() => obj.a > 5);
+    axp.onBecomeTrue(spy);
+    expect(spy).not.to.be.called;
+
+    obj.a = 10;
+    expect(spy).to.be.calledOnce;
+
+    obj.a = 0;
+    expect(spy).to.be.calledOnce;
+
+    obj.a = 10;
+    expect(spy).to.be.calledTwice;
+  });
+
+  it("immediately triggers onBecomeTrue", () => {
+    let obj = {a: 7},
+        spy = sinon.spy();
+
+    let axp = aexpr(() => obj.a > 5);
+    axp.onBecomeTrue(spy);
+    expect(spy).to.be.calledOnce;
+
+    obj.a = 0;
+    expect(spy).to.be.calledOnce;
+
+    obj.a = 10;
+    expect(spy).to.be.calledTwice;
+  });
+
+  it("flank down", () => {
+    let obj = {a: 2},
+        spy = sinon.spy();
+
+    let axp = aexpr(() => obj.a > 0);
+    axp.onBecomeFalse(spy);
+    expect(spy).not.to.be.called;
+
+    obj.a = -2;
+    expect(spy).to.be.calledOnce;
+
+    obj.a = 2;
+    expect(spy).to.be.calledOnce;
+
+    obj.a = -2;
+    expect(spy).to.be.calledTwice;
+  });
+
+  it("immediately triggers onBecomeFalse", () => {
+    let obj = {a: -2},
+        spy = sinon.spy();
+
+    let axp = aexpr(() => obj.a > 0);
+    axp.onBecomeFalse(spy);
+    expect(spy).to.be.calledOnce;
+
+    obj.a = 2;
+    expect(spy).to.be.calledOnce;
+
+    obj.a = -2;
+    expect(spy).to.be.calledTwice;
+  });
+
+  describe('nextValue', () => {
+    it("aexprs define nextValue", () => {
+      expect(aexpr(() => {})).to.respondTo('nextValue');
+    });
+
+    it("nextValue returns a Promise", () => {
+      expect(aexpr(() => {}).nextValue()).to.be.an.instanceof(Promise);
+    });
+
+    it("nextValue resolves on first change of monitored expression", async () => {
+      let obj = {a: 1},
+          spy = sinon.spy();
+
+      let axp = aexpr(() => obj.a);
+
+      async function waitingForChange() {
+        const v = await axp.nextValue();
+        spy(v);
+      }
+      
+      waitingForChange();
+      
+      expect(spy).not.to.be.called;
+      
+      obj.a = 42;
+      // await is resolved as a separate micro task
+      expect(spy).not.to.be.called;
+      
+      await lively.sleep(10);
+      
+      expect(spy).to.be.calledOnce;
+      expect(spy).to.be.calledWith(42);
+      spy.reset();
+
+      obj.a = 43;
+
+      await lively.sleep(10);
+      expect(spy).not.to.be.called;
+    });
+
+    describe('thenable AExprs', () => {
+      
+      it("Active Expressions are thenables", async () => {
+        let obj = {a: 1},
+            spy = sinon.spy();
+
+        let axp = aexpr(() => obj.a);
+        
+        async function waitingForChange() {
+          const v = await axp;
+          spy(v);
+        }
+
+        waitingForChange();
+
+        expect(spy).not.to.be.called;
+
+        // the following await is crutial, as the `.then` on axp is executed
+        // in waitingForChange in its own micro task only AFTER this 
+        // synchronous part is over!!!
+        await lively.sleep(10);
+
+        obj.a = 17;
+        // await is resolved as a separate micro task
+        expect(spy).not.to.be.called;
+
+        await lively.sleep(10);
+
+        expect(spy).to.be.calledOnce;
+        expect(spy).to.be.calledWith(17);
+        spy.reset();
+
+        obj.a = 43;
+        expect(spy).not.to.be.called;
+      });
+
+    });
+
+  });
+});

src/components/tools/lively-editor.js

@@ -967,6 +967,7 @@ export default class Editor extends Morph {
   }
 
   async enableAnnotations() { 
+    debugger
     await this.loadAnnotations(this.getText(), this.lastVersion) 
     lively.removeEventListener("annotations", this)
     lively.addEventListener("annotations", this, "loaded-file", async evt => {