Merge branch 'gh-pages' of https://github.com/LivelyKernel/lively4-core into gh-pages

Author: JensLincke

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

@@ -216,33 +216,35 @@ class Dependency {
 
 const DependenciesToAExprs = {
   _depsToAExprs: new BidirectionalMultiMap(),
+  _AEsPerFile: new Map(),
 
   associate(dep, aexpr) {
+    const location = aexpr.meta().get("location").file;
+    if(!this._AEsPerFile.has(location)) {
+      this._AEsPerFile.set(location, new Set());
+    }
+    this._AEsPerFile.get(location).add(aexpr);
     this._depsToAExprs.associate(dep, aexpr);
     dep.updateTracking();
     debouncedUpdateDebuggingViews();
   },
 
   disconnectAllForAExpr(aexpr) {
+    const location = aexpr.meta().get("location").file;
+    if(this._AEsPerFile.has(location)) {
+      this._AEsPerFile.get(location).delete(aexpr);
+    }
     const deps = this.getDepsForAExpr(aexpr);
     this._depsToAExprs.removeAllLeftFor(aexpr);
     deps.forEach(dep => dep.updateTracking());
     debouncedUpdateDebuggingViews();
   },
 
-  getAETriplesForFile(url) {
-    const result = [];
-    for (const ae of this._depsToAExprs.getAllRight()) {
-      const location = ae.meta().get("location").file;
-      if (location.includes(url)) {
-        for (const dependency of this.getDepsForAExpr(ae)) {
-          for (const hook of HooksToDependencies.getHooksForDep(dependency)) {
-            result.push({ hook, dependency, ae });
-          }
-        }
-      }
+  getAEsInFile(url) {
+    for(const [location, aes] of this._AEsPerFile.entries()) {
+      if(location.includes(url)) return aes;
     }
-    return result;
+    return [];
   },
 
   getAExprsForDep(dep) {
@@ -275,24 +277,20 @@ const HooksToDependencies = {
     this._hooksToDeps.associate(hook, dep);
     debouncedUpdateDebuggingViews();
   },
+  
   remove(hook, dep) {
     this._hooksToDeps.remove(hook, dep);
     debouncedUpdateDebuggingViews();
   },
 
-  async getHookTriplesForFile(url) {
-    const result = [];
-    for (const hook of this._hooksToDeps.getAllLeft()) {
-      const locations = await hook.getLocations();
-      if (locations.some(loc => loc && loc.source.includes(url))) {
-        for (const dependency of this.getDepsForHook(hook)) {
-          for (const ae of DependenciesToAExprs.getAExprsForDep(dependency)) {
-            result.push({ hook, dependency, ae });
-          }
-        }
-      }
-    }
-    return result;
+  async getHooksInFile(url) {
+    const hooksWithLocations = await Promise.all(this._hooksToDeps.getAllLeft().map(hook => {
+      return hook.getLocations().then(locations => {return {hook, locations}});     
+    }))
+    return hooksWithLocations.filter(({hook, locations}) => {
+      const location = locations.find(loc => loc && loc.source); 
+      return location && locations.source.includes(url);
+    }).map(({hook, locations}) => hook);
   },
 
   disconnectAllForDependency(dep) {
@@ -932,12 +930,19 @@ export async function registerFileForAEDebugging(url, context, triplesCallback)
 
 export async function getDependencyTriplesForFile(url) {
   const result = [];
-  for (const hook of HooksToDependencies._hooksToDeps.getAllLeft()) {
-    const locations = await hook.getLocations();
+  for (const ae of DependenciesToAExprs.getAEsInFile(url)) {
+    for (const dependency of DependenciesToAExprs.getDepsForAExpr(ae)) {
+      for(const hook of HooksToDependencies.getHooksForDep(dependency)) {
+          result.push({ hook, dependency, ae });
+      }
+    }
+  }
+  for (const hook of await HooksToDependencies.getHooksInFile(url)) {
     for (const dependency of HooksToDependencies.getDepsForHook(hook)) {
-      for (const ae of DependenciesToAExprs.getAExprsForDep(dependency)) {
+      for(const ae of DependenciesToAExprs.getAExprsForDep(dependency)) {
         const location = ae.meta().get("location").file;
-        if (location.includes(url) || locations.some(loc => loc && loc.file.includes(url))) {
+        // if the AE is also in this file, we already covered it with the previous loop
+        if (!location.includes(url)){
           result.push({ hook, dependency, ae });
         }
       }

src/client/reactive/active-expression-rewriting/bidirectional-multi-map.js

@@ -27,6 +27,14 @@ export default class BidirectionalMultiMap {
     this.domainToRange.clear();
     this.rangeToDomain.clear();
   }
+  
+  hasRight(val) {    
+    return this.rangeToDomain.has(val);
+  }
+  
+  hasLeft(val) {
+    return this.domainToRange.has(val);
+  }
 
   getRightsFor(left) {
     return this.domainToRange.getOrCreate(left, () => new Set());

src/client/reactive/babel-plugin-polymorphic-identifiers/polymorphic-identifiers.js

@@ -30,7 +30,6 @@ export default function ({ types: t, template }) {
             return foundDirective;
           }
 
-          debugger
           const shouldTransform = state.opts.executedIn === 'workspace' || hasDirective(path, "pi");
           if (!shouldTransform) {
             return;

src/client/reactive/polymorphic-identifiers/index.md

@@ -1,10 +1,11 @@
 # Polymorphic-Identifiers
 
 ```JavaScript
-import { PIReference } from 'polymorphic-identifiers';
+'pi';
+import { PIScheme } from 'polymorphic-identifiers';
 
 // example scheme
-class qa extends PIReference {
+class qa extends PIScheme {
   read() {
     const { elements } = this.parse();
     return elements;

src/client/reactive/polymorphic-identifiers/polymorphic-identifiers.js

@@ -1,6 +1,6 @@
 
-export class PIReference {
-  static get isPIReference() { return true; }
+export class PIScheme {
+  static get isPIScheme() { return true; }
 
   applyOptions(options = {}) {
     Object.assign(this, options);
@@ -20,7 +20,7 @@ export class PIReference {
 }
 
 export function makeRef(referenceClass, options) {
-  if (referenceClass && referenceClass.isPIReference) {
+  if (referenceClass && referenceClass.isPIScheme) {
     const reference = new referenceClass(options);
     reference.applyOptions(options);
 

src/client/reactive/test/babel-plugin-polymorphic-identifiers/babel-plugin-polymorphic-identifiers.spec.js

@@ -0,0 +1,114 @@
+'pi'
+"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);
+
+import { PIScheme } from 'src/client/reactive/polymorphic-identifiers/polymorphic-identifiers.js';
+import { uuid } from 'utils';
+
+describe("PI", function() {
+  
+  it("is defined", () => {
+    expect(PIScheme).to.be.ok;
+  });
+
+  it("detects accesses", () => {
+    class fourtyTwo extends PIScheme {
+      read() {
+        return 42;
+      }
+    }
+
+    expect(fourtyTwo``).to.equal(42)
+    
+  });
+
+  it("can access the `this` reference", () => {
+    class prop extends PIScheme {
+      create(strings) {
+        this.prop = strings.first;
+      }
+      read() {
+        return this.thisReference[this.prop];
+      }
+      write(value) {
+        return this.thisReference[this.prop] = value;
+      }
+    }
+
+    // read
+    const o = {
+      foo: 17,
+      func() {
+        return prop`foo`;
+      },
+      write(value) {
+        prop`bar` << value;
+      }
+    };
+    expect(o.func()).to.equal(17)
+    
+    // write
+    o.write(23)
+    expect(o.bar).to.equal(23)
+  });
+
+  it("can access locals with eval", () => {
+    class local extends PIScheme {
+      create(strings) {
+        this.local = strings.first;
+      }
+      read() {
+        return this.evalFunction(this.local);
+      }
+      write(value) {
+        const id = uuid();
+        self[id] = value;
+        try {
+          return this.evalFunction(this.local + ` = self['${id}']`);
+        } finally {
+          delete self[id];
+        }
+      }
+    }
+
+    let v1 = 'v1', v2 = 42;
+
+    // read
+    expect(local`v1`).to.equal('v1')
+    
+    // write
+    local`v2` << "v2";
+    expect(v2).to.equal('v2');
+    
+    // read/write
+    local`v2` << local`v2` + '.2';
+    expect(v2).to.equal('v2.2');
+  });
+
+  it("ignore normal tagged template strings", () => {
+    function foo() {
+      return 'bar';
+    }
+    
+    expect(foo``).to.equal('bar')
+  });
+
+});
+describe("AEs", function() {
+  
+  it("AExprs insert default constructors", () => {
+    class A {
+      constructor(prop) {
+        this.prop = prop;
+      }
+    }
+    class B extends A {}
+    
+    const b = new B(42);
+    expect(b.prop).to.equal(42);
+  });
+
+});

src/client/reactive/test/polymorphic-identifiers/polymorphic-identifiers.spec.js

@@ -4,18 +4,18 @@ import sinon from 'src/external/sinon-3.2.1.js';
 import sinonChai from 'src/external/sinon-chai.js';
 chai.use(sinonChai);
 
-import { PIReference, makeRef } from 'src/client/reactive/polymorphic-identifiers/polymorphic-identifiers.js';
+import { PIScheme, makeRef } from 'src/client/reactive/polymorphic-identifiers/polymorphic-identifiers.js';
 import { uuid } from 'utils';
 
 describe("PI", function() {
 
   it("is defined", () => {
-    expect(PIReference).to.be.ok;
+    expect(PIScheme).to.be.ok;
     expect(makeRef).to.be.ok;
   });
 
   it("detects accesses", () => {
-    class fourtyTwo extends PIReference {
+    class fourtyTwo extends PIScheme {
       read() {
         return 42;
       }
@@ -29,7 +29,7 @@ describe("PI", function() {
   });
 
   it("can access the `this` reference", () => {
-    class prop extends PIReference {
+    class prop extends PIScheme {
       create(strings) {
         this.prop = strings.first;
       }
@@ -65,7 +65,7 @@ describe("PI", function() {
   });
 
   it("can access locals with eval", () => {
-    class local extends PIReference {
+    class local extends PIScheme {
       create(strings) {
         this.local = strings.first;
       }