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

Author: Markus-Brand

demos/contraints/index.md

@@ -1 +1 @@
-# #EUD20 Lively Contraints
+# #EUD20 Lively Constraints

doc/journal/2020-09-01.md/index.md

@@ -25,7 +25,7 @@ var lastWindow;
 })()
 ```
 
-## Turning Wiki-pages into Tools (#PaperIdea)
+## Turning Wiki-pages into Tools ( #PaperIdea )
 
 We used markdown pages to prototype tools and visualizations a lot. But to use it, one had to navigate to that specific page and interact with the tool there. A good and working example of the setup are these journal pages and their index page that allows to create new entries. But markdown pages are not easy to integrate into a workflow with other tools. E.g. using the git graph visualization tool directly from our sync tools is not possible.
 

src/client/fetch.js

@@ -140,7 +140,8 @@ export async function installAuthorizedFetch() {
         }          
       }
 
-      if  (isWriting && baseUrlsAuthNeededForWriting.find(ea => url.startsWith(ea))) {
+      if  (isWriting && baseUrlsAuthNeededForWriting.find(
+          ea => url.startsWith(ea) && !url.startsWith(lively4url + "/.transpiled/")  )) {
         return {
             result: (async () => {
               console.log("AuthorizedFetch Write: " + url)

src/client/morphic/selecting.js

@@ -109,26 +109,40 @@ export default class Selecting {
     // lively.showElement(e.composedPath()[0],1300).textContent = "path: " + e.composedPath().map(ea => ea.tagName).join(",")
 
 
-      var rootNode = this.findRootNode(document.body)
 
       var path = this.slicePathIfContainerContent(e.composedPath());
 
-      // var rootNode = lively.findWorldContext(path)
 
       // workaround weird toplevel event issues... the halo should not get the event
       // lively.notify("path " + e.composedPath().map(ea => ea.tagName))
       if (e.composedPath().find(ea => ea.tagName == "LIVELY-HALO")) {
         path = this.lastPath || e.composedPath()
       }      
+      
+      // some inception: deal with containers that should behave as if they are their own document
+      // if we have found one, treat them as root
+      var worldContexts = path
+        .map(ea => lively.findWorldContext(ea))
+        .filter(ea => ea)
+        .filter(ea => ea.id == "container-root")
+      if (worldContexts.length > 0) {
+        var rootNode = this.findRootNode(worldContexts[0])
+      } else {
+        rootNode = this.findRootNode(document.body)
+      }
+      
       this.lastPath = path
       path = path
         // .reverse()
         .filter(ea => ! this.isIgnoredOnMagnify(ea))
 
+      
+      
       if (e.shiftKey) {
         var idx = e.composedPath().indexOf(document.body);
         path= path
       } else {
+        debugger
         // by default: don't go into the shadows
         path = path.filter(ea => rootNode === this.findRootNode(ea))
       }

src/client/poid.js

@@ -844,6 +844,42 @@ export class Lively4URLScheme extends Scheme {
   }
 }
 
+export class GSScheme_Stub extends Scheme {
+  
+  get scheme() {
+    return "gs";
+  }
+
+  resolve() {
+    return true
+  }
+
+  static async delegatee() {
+    if (this._delegatee) {
+      return this._delegatee;
+    } else {
+      return this._delegateePromise = this._delegateePromise || new Promise(resolve => this._delegateeResolve = resolve);
+    }
+  }
+
+  static delegateTo(Scheme) {
+    this._delegatee = Scheme;
+    this._delegateeResolve && this._delegateeResolve(this._delegatee);
+  }
+
+  async holdOff(methodName, ...args) {
+    const NewScheme = await GSScheme_Stub.delegatee();
+    this.migrateTo(NewScheme);
+    return this[methodName](...args);
+  }
+
+  async GET(...args) { return this.holdOff('GET', ...args); }
+  async PUT(...args) { return this.holdOff('PUT', ...args); }
+  async OPTIONS(...args) { return this.holdOff('OPTIONS', ...args); }
+  async POST(...args) { return this.holdOff('POST', ...args); }
+  async DELETE(...args) { return this.holdOff('DELETE', ...args); }
+}
+
 
 export default class PolymorphicIdentifier {
 
@@ -868,6 +904,7 @@ export default class PolymorphicIdentifier {
       DateScheme,
       BooleanScheme,
       Lively4URLScheme,
+      GSScheme_Stub,
     ].forEach(scheme => this.register(scheme));
   }
 

src/client/reactive/babel-plugin-constraint-connectors-active-expression/babel-plugin-constraint-connectors-active-expression.js

@@ -0,0 +1,15 @@
+
+const SHARED_FLAG_GENERATED_IMPORT_IDENTIFIER = 'SHARED_FLAG_GENERATED_IMPORT_IDENTIFIER';
+
+export default function ({ types: t, template }) {
+  return {
+    name: 'constraint-connectors-active-expression',
+    visitor: {
+      Program: {
+        enter(path, state) {
+          
+        }
+      }
+    }
+  };
+}

src/client/reactive/babel-plugin-constraint-connectors/babel-plugin-constraint-connectors.js

@@ -0,0 +1,15 @@
+
+const SHARED_FLAG_GENERATED_IMPORT_IDENTIFIER = 'SHARED_FLAG_GENERATED_IMPORT_IDENTIFIER';
+
+export default function ({ types: t, template }) {
+  return {
+    name: 'constraint-connectors',
+    visitor: {
+      Program: {
+        enter(path, state) {
+          
+        }
+      }
+    }
+  };
+}

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

@@ -2,15 +2,22 @@
 export class PIScheme {
   static get isPIScheme() { return true; }
 
-  applyOptions(options = {}) {
-    Object.assign(this, options);
+  static createRef(options, strings, ...expressions) {
+    const reference = new this();
+    reference.configure(options, strings, ...expressions);
+    reference.initialize();
+    return reference;
   }
-
-  create(strings, ...expressions) {
+  
+  configure(options = {}, strings, ...expressions) {
+    Object.assign(this, options);
     this.strings = strings;
     this.expressions = expressions;
   }
 
+  // hook into a created reference
+  initialize() {}
+
   get access() {
     return this.read();
   }
@@ -19,18 +26,12 @@ export class PIScheme {
   }
 }
 
-export function makeRef(referenceClass, options) {
-  if (referenceClass && referenceClass.isPIScheme) {
-    const reference = new referenceClass(options);
-    reference.applyOptions(options);
-
-    return (strings, ...expressions) => {
-      reference.create(strings, ...expressions);
-      return reference
-    };
+export function makeRef(Scheme, options) {
+  if (Scheme && Scheme.isPIScheme) {
+    return (strings, ...expressions) => Scheme.createRef(options, strings, ...expressions);
   }
 
   return (...args) => ({
-    access: referenceClass(...args)
+    access: Scheme(...args)
   });
 }

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

@@ -0,0 +1,25 @@
+'cc-ae'
+'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 'polymorphic-identifiers';
+import { uuid } from 'utils';
+
+describe("PI", function() {
+  
+  it("detects accesses", () => {
+    class fourtyTwo extends PIScheme {
+      read() {
+        return 42;
+      }
+    }
+
+    expect(fourtyTwo``).to.equal(42)
+    
+  });
+
+});