allow apps to load without the editor and make the server database useful

Signed-off-by: Chris Granger <[email protected]>

Author: ibdknox

src/client.ts

@@ -138,8 +138,7 @@ export class EveClient {
   showIDE:boolean = true;
   ide:IDE;
 
-  constructor(ide:IDE, url?:string) {
-    this.ide = ide;
+  constructor(url?:string) {
     let loc = url ? url : this.getUrl();
     let self = this;
 
@@ -203,7 +202,10 @@ export class EveClient {
   onError() {
     this.localControl = true;
     this.localEve = true;
-    this.ide.local = true;
+    if(this.showIDE) {
+      this.ide = new IDE();
+      this.ide.local = true;
+    }
   }
 
   onOpen() {
@@ -265,30 +267,36 @@ export class EveClient {
 
   _initProgram(data) {
     this.localEve = data.local;
+    this.showIDE = data.withIDE;
     if(data.local) {
       browser.init(data.code);
     }
     if(this.showIDE) {
-      initIDE(this.ide, this);
+      this.ide = new IDE();
+      initIDE(this);
       this.ide.render();
       this.ide.loadFile(data.path, data.code);
     }
     onHashChange({});
   }
 
   _parse(data) {
+    if(!this.showIDE) return;
     this.ide.loadDocument(data.generation, data.text, data.spans, data.extraInfo); // @FIXME
   }
 
   _comments(data) {
+    if(!this.showIDE) return;
     this.ide.injectSpans(data.spans, data.extraInfo);
   }
 
   _findNode(data) {
+    if(!this.showIDE) return;
     this.ide.attachView(data.recordId, data.spanId);
   }
 
   _error(data) {
+    if(!this.showIDE) return;
     this.ide.injectNotice("error", data.message);
   }
 
@@ -347,9 +355,15 @@ function subscribeToTagDiff(tag:string, callback: (inserts: string[], removes: s
   });
 }
 
-subscribeToTagDiff("editor", (inserts, removes, records) => ide.updateActions(inserts, removes, records));
+subscribeToTagDiff("editor", (inserts, removes, records) => {
+  if(!client.showIDE) return;
+  client.ide.updateActions(inserts, removes, records);
+});
 
-subscribeToTagDiff("view", (inserts, removes, records) => ide.updateViews(inserts, removes, records));
+subscribeToTagDiff("view", (inserts, removes, records) => {
+  if(!client.showIDE) return;
+  client.ide.updateViews(inserts, removes, records)
+});
 
 //---------------------------------------------------------
 // Communication helpers
@@ -391,10 +405,10 @@ function recordToEAVs(record) {
 //---------------------------------------------------------
 // Initialize an IDE
 //---------------------------------------------------------
-let ide = new IDE();
-export let client = new EveClient(ide);
+export let client = new EveClient();
 
-function initIDE(ide:IDE, client:EveClient) {
+function initIDE(client:EveClient) {
+  let ide = client.ide;
   ide.onChange = (ide:IDE) => {
     let generation = ide.generation;
     let md = ide.editor.toMarkdown();
@@ -430,6 +444,8 @@ function initIDE(ide:IDE, client:EveClient) {
 }
 
 function changeDocument() {
+  if(!client.showIDE) return;
+  let ide = client.ide;
   let docId = "quickstart.eve";
   let path = "/" + location.hash.split('?')[0].split("#/")[1];
   console.log("PATH", path, location.hash);
@@ -447,14 +463,12 @@ function changeDocument() {
   ide.render();
 }
 
-console.log(ide);
-
 //---------------------------------------------------------
 // Handlers
 //---------------------------------------------------------
 
 function onHashChange(event) {
-  if(ide.loaded) changeDocument();
+  if(client.ide && client.ide.loaded) changeDocument();
   let hash = window.location.hash.split("#/")[2];
   let queryParam = window.location.hash.split('?')[1];
 

src/runtime/browser.ts

@@ -10,6 +10,7 @@ import * as builder from "./builder";
 import {ids} from "./id";
 import {RuntimeClient} from "./runtimeClient";
 import {HttpDatabase} from "./databases/http";
+import {BrowserViewDatabase, BrowserEditorDatabase, BrowserInspectorDatabase} from "./databases/browserSession";
 
 //---------------------------------------------------------------------
 // Utils
@@ -34,7 +35,15 @@ class BrowserRuntimeClient extends RuntimeClient {
   client: EveClient;
 
   constructor(client:EveClient) {
-    super({"http": new HttpDatabase()}, client.showIDE);
+    let dbs = {
+      "http": new HttpDatabase()
+    }
+    if(client.showIDE) {
+      dbs["view"] = new BrowserViewDatabase();
+      dbs["editor"] = new BrowserEditorDatabase();
+      dbs["inspector"] = new BrowserInspectorDatabase();
+    }
+    super(dbs);
     this.client = client;
   }
 

src/runtime/databases/node/server.ts

@@ -9,23 +9,21 @@ import * as request from "request";
 
 export class ServerDatabase extends Database {
 
+  handling: boolean;
   receiving: boolean;
   requestId: number;
   requestToResponse: any;
 
   constructor() {
     super();
+    this.handling = false;
     this.requestId = 0;
     this.receiving = false;
     this.requestToResponse = {};
   }
 
   handleHttpRequest(request, response) {
-    if(!this.receiving) {
-      // we need to 404
-      response.writeHead(404, {"Content-Type": "text/plain"});
-      return response.end("Nothing is listening to HTTP requests");
-    }
+    if(!this.receiving) return;
 
     let scopes = ["server"];
     let requestId = `request|${this.requestId++}|${(new Date()).getTime()}`
@@ -72,7 +70,7 @@ export class ServerDatabase extends Database {
     }
   }
 
-  sendResponse(requestId, status, body) {
+  sendResponse(evaluation, requestId, status, body) {
     let response = this.requestToResponse[requestId];
     response.statusCode = status;
     response.end(body);
@@ -90,17 +88,22 @@ export class ServerDatabase extends Database {
         handled[e] = true;
         if(index.lookup(e,"tag", "request") && !index.lookup(e, "tag", "sent")) {
           let responses = index.asValues(e, "response");
+          if(responses || index.lookup(e, "tag", "handling")) this.handling = true;
           if(responses === undefined) continue;
           let [response] = responses;
           let {status, body} = index.asObject(response);
           actions.push(new InsertAction("server|sender", e, "tag", "sent", undefined, [name]));
-          this.sendResponse(e, status[0], body[0]);
+          this.sendResponse(evaluation, e, status[0], body[0]);
         }
       }
     }
     if(actions.length) {
       process.nextTick(() => {
         evaluation.executeActions(actions);
+        // because this database is created per http request, we need to destroy this
+        // evaluation once a response has been sent and we've dealt with any consequences
+        // of the send.
+        evaluation.close();
       })
     }
   }

src/runtime/runtime.ts

@@ -122,7 +122,7 @@ export class Evaluation {
 
   registerDatabase(name: string, db: Database) {
     if(this.nameToDatabase[name]) {
-      throw new Error("Trying to register a database name that is already registered");
+      throw new Error("Trying to register a database name that is already registered: " + name);
     }
     for(let database of this.databases) {
       db.analyze(this, database);

src/runtime/runtimeClient.ts

@@ -19,11 +19,9 @@ import {ids} from "./id";
 export abstract class RuntimeClient {
   lastParse: any;
   evaluation: Evaluation;
-  withIDE: boolean;
   extraDBs: any;
 
-  constructor(extraDBs:any = {}, withIDE = true) {
-    this.withIDE = withIDE;
+  constructor(extraDBs:any = {}) {
     this.extraDBs = extraDBs;
   }
 
@@ -47,32 +45,32 @@ export abstract class RuntimeClient {
     let build = builder.buildDoc(parse);
     let {blocks, errors} = build;
     this.sendErrors(errors);
-    analyzer.analyze(blocks.map((block) => block.parse), parse.spans, parse.extraInfo);
-    let browser = new BrowserSessionDatabase(this);
-    let event = new BrowserEventDatabase();
+    // TODO: What is the right way to gate analysis? This seems hacky, but I'm not sure
+    // that the RuntimeClient should really know/care about whether or not the editor is
+    // hooked up. Maybe there should be a flag for analysis instead?
+    if(this.extraDBs["editor"]) {
+      analyzer.analyze(blocks.map((block) => block.parse), parse.spans, parse.extraInfo);
+    }
+
+    let ev = new Evaluation();
     let session = new Database();
     session.blocks = blocks;
-    // console.log(blocks);
-    let ev = new Evaluation();
-
     ev.registerDatabase("session", session);
-    ev.registerDatabase("browser", browser);
-    ev.registerDatabase("event", event);
 
-    if(this.withIDE) {
-      let view = new BrowserViewDatabase();
-      let editor = new BrowserEditorDatabase();
-      let inspector = new BrowserInspectorDatabase();
-
-      ev.registerDatabase("view", view);
-      ev.registerDatabase("editor", editor);
-      ev.registerDatabase("inspector", inspector);
+    let extraDBs = this.extraDBs;
+    if(!extraDBs["browser"]) {
+      ev.registerDatabase("browser", new BrowserSessionDatabase(this));
+    }
+    if(!extraDBs["event"]) {
+      ev.registerDatabase("event", new BrowserEventDatabase());
     }
 
-    ev.registerDatabase("system", system.instance);
+    if(!extraDBs["system"]) {
+      ev.registerDatabase("system", system.instance);
+    }
 
     for(let dbName of Object.keys(this.extraDBs)) {
-      let db = this.extraDBs[dbName];
+      let db = extraDBs[dbName];
       ev.registerDatabase(dbName, db);
     }
 
@@ -147,7 +145,9 @@ export abstract class RuntimeClient {
         let {blocks, errors} = build;
         let spans = [];
         let extraInfo = {};
-        analyzer.analyze(blocks.map((block) => block.parse), spans, extraInfo);
+        if(this.extraDBs["editor"]) {
+          analyzer.analyze(blocks.map((block) => block.parse), spans, extraInfo);
+        }
         this.sendErrors(errors);
         for(let block of blocks) {
           if(block.singleRun) block.dormant = true;
@@ -245,6 +245,8 @@ export abstract class RuntimeClient {
         }
       }
       this.evaluation.load(data.info.databases);
+    } else {
+      console.error("Unhandled message type: " + json);
     }
   }
 }