consistent naming for parent and child. Also childQuery is now sendToIpc (as it is going to be bidirectional)

refs #51

Author: basarat

lib/tsconfig.json

@@ -58,7 +58,7 @@
         "./typings/status-bar/status-bar.d.ts",
         "./typings/text-buffer/text-buffer.d.ts",
         "./typings/tsd.d.ts",
-        "./worker/childMain.ts",
+        "./worker/child.ts",
         "./worker/lib/workerLib.ts",
         "./worker/parent.ts",
         "./worker/parentResponses.ts"

lib/worker/childMain.js lib/worker/child.jslib/worker/childMain.js renamed to lib/worker/child.js

@@ -1,4 +1,6 @@
 var workerLib = require('./lib/workerLib');
-var projectService = require('../main/lang/projectService');
 var child = new workerLib.Child();
+var parentResponses = require('./parentResponses');
+exports.plus1 = child.sendToIpc(parentResponses.plus1);
+var projectService = require('../main/lang/projectService');
 child.registerAllFunctionsExportedFromAsResponders(projectService);

lib/worker/childMain.ts lib/worker/child.tslib/worker/childMain.ts renamed to lib/worker/child.ts

@@ -2,10 +2,16 @@
 /// <reference path="../globals.ts"/> ///ts:ref:generated
 
 import workerLib = require('./lib/workerLib');
-import projectService = require('../main/lang/projectService'); ///ts:import:generated
+
 
 // Initiate the child logic
 var child = new workerLib.Child();
 
+/////////////////////////////////////// END INFRASTRUCTURE ////////////////////////////////////////////////////
+
+import parentResponses = require('./parentResponses');
+export var plus1 = child.sendToIpc(parentResponses.plus1);
+
 // Automatically include all functions from "projectService" as a responder
+import projectService = require('../main/lang/projectService');
 child.registerAllFunctionsExportedFromAsResponders(projectService);

lib/worker/lib/workerLib.js

@@ -74,7 +74,7 @@ var RequesterResponder = (function () {
             delete this.currentListeners[parsed.message][parsed.id];
         }
     };
-    RequesterResponder.prototype.childQuery = function (func) {
+    RequesterResponder.prototype.sendToIpc = function (func) {
         var _this = this;
         var that = this;
         return function (data) {

lib/worker/lib/workerLib.ts

@@ -41,12 +41,12 @@ class RequesterResponder {
         (): { send?: <T>(message: Message<T>) => any }
     }
     = () => { throw new Error('getProcess is abstract'); return null; }
-    
-    
+
+
     ///////////////////////////////// REQUESTOR /////////////////////////
-    
+
     private currentListeners: { [messages: string]: { [id: string]: PromiseDeferred<any> } } = {};
-    
+
     /** process a message from the child */
     protected processResponse(m: any) {
         var parsed: Message<any> = m;
@@ -67,39 +67,39 @@ class RequesterResponder {
             delete this.currentListeners[parsed.message][parsed.id];
         }
     }
-    
-    /** 
-     * Takes a sync named function 
-     * and returns a function that will execute the function by name on the child
-     * if the child has a responder registered
+
+    /**
+     * Takes a sync named function
+     * and returns a function that will execute this function by name using IPC
+     * (will only work if the process on the other side has this function as a registered responder)
      */
-    childQuery<Query, Response>(func: (query: Query) => Promise<Response>): (data: Query) => Promise<Response> {
+    sendToIpc<Query, Response>(func: (query: Query) => Promise<Response>): (data: Query) => Promise<Response> {
         var that = this; // Needed because of a bug in the TS compiler (Don't change the previous line to labmda ^ otherwise this becomes _this but _this=this isn't emitted)
         return (data) => {
             var message = func.name;
-    
+
             // If we don't have a child exit
             if (!that.getProcess()) {
                 console.log('PARENT ERR: no child when you tried to send :', message);
                 return <any>Promise.reject(new Error("No worker active to recieve message: " + message));
             }
-    
+
             // Initialize if this is the first call of this type
             if (!that.currentListeners[message]) this.currentListeners[message] = {};
-    
+
             // Create an id unique to this call and store the defered against it
             var id = createId();
             var defer = Promise.defer<Response>();
             that.currentListeners[message][id] = defer;
-    
+
             // Send data to worker
             that.getProcess().send({ message: message, id: id, data: data, request: true });
             return defer.promise;
         };
     }
-    
+
     ////////////////////////////////// RESPONDER ////////////////////////
-    
+
     private responders: { [message: string]: <Query,Response>(query: Query) => Promise<Response> } = {};
 
     protected processRequest = (m: any) => {
@@ -115,7 +115,7 @@ class RequesterResponder {
         } catch (err) {
             responsePromise = Promise.reject({ method: message, message: err.message, stack: err.stack, details: err.details || {} });
         }
-        
+
         responsePromise
             .then((response)=>{
                 this.getProcess().send({
@@ -154,12 +154,12 @@ class RequesterResponder {
 export class Parent extends RequesterResponder {
 
     private child: childprocess.ChildProcess;
-    private node = process.execPath;   
-    
+    private node = process.execPath;
+
     /** If we get this error then the situation if fairly hopeless */
     private gotENOENTonSpawnNode = false;
     protected getProcess = () => this.child;
-    
+
     /** start worker */
     startWorker(childJsPath: string, terminalError: (e: Error) => any) {
         try {
@@ -211,7 +211,7 @@ export class Parent extends RequesterResponder {
             terminalError(err);
         }
     }
-    
+
     /** stop worker */
     stopWorker() {
         if (!this.child) return;
@@ -231,10 +231,10 @@ export class Child extends RequesterResponder {
 
     constructor() {
         super();
-        
-        // Keep alive 
+
+        // Keep alive
         this.keepAlive();
-        
+
         // Start listening
         process.on('message',(message: Message<any>) => {
             if (message.request) {
@@ -245,7 +245,7 @@ export class Child extends RequesterResponder {
             }
         });
     }
-    
+
     /** keep the child process alive while its connected and die otherwise */
     private keepAlive() {
         setInterval(() => {
@@ -255,4 +255,4 @@ export class Child extends RequesterResponder {
             }
         }, 1000);
     }
-}
+}

lib/worker/parent.js

@@ -4,7 +4,7 @@ var spawn = childprocess.spawn;
 var workerLib = require('./lib/workerLib');
 var parent = new workerLib.Parent();
 function startWorker() {
-    parent.startWorker(__dirname + '/childMain.js', showError);
+    parent.startWorker(__dirname + '/child.js', showError);
     console.log('AtomTS worker started');
 }
 exports.startWorker = startWorker;
@@ -23,19 +23,19 @@ function showError(error) {
     }
 }
 var projectService = require('../main/lang/projectService');
-exports.echo = parent.childQuery(projectService.echo);
-exports.quickInfo = parent.childQuery(projectService.quickInfo);
-exports.build = parent.childQuery(projectService.build);
-exports.errorsForFileFiltered = parent.childQuery(projectService.errorsForFileFiltered);
-exports.getCompletionsAtPosition = parent.childQuery(projectService.getCompletionsAtPosition);
-exports.emitFile = parent.childQuery(projectService.emitFile);
-exports.regenerateProjectGlob = parent.childQuery(projectService.regenerateProjectGlob);
-exports.formatDocument = parent.childQuery(projectService.formatDocument);
-exports.formatDocumentRange = parent.childQuery(projectService.formatDocumentRange);
-exports.getDefinitionsAtPosition = parent.childQuery(projectService.getDefinitionsAtPosition);
-exports.updateText = parent.childQuery(projectService.updateText);
-exports.errorsForFile = parent.childQuery(projectService.errorsForFile);
-exports.getSignatureHelps = parent.childQuery(projectService.getSignatureHelps);
-exports.getRenameInfo = parent.childQuery(projectService.getRenameInfo);
+exports.echo = parent.sendToIpc(projectService.echo);
+exports.quickInfo = parent.sendToIpc(projectService.quickInfo);
+exports.build = parent.sendToIpc(projectService.build);
+exports.errorsForFileFiltered = parent.sendToIpc(projectService.errorsForFileFiltered);
+exports.getCompletionsAtPosition = parent.sendToIpc(projectService.getCompletionsAtPosition);
+exports.emitFile = parent.sendToIpc(projectService.emitFile);
+exports.regenerateProjectGlob = parent.sendToIpc(projectService.regenerateProjectGlob);
+exports.formatDocument = parent.sendToIpc(projectService.formatDocument);
+exports.formatDocumentRange = parent.sendToIpc(projectService.formatDocumentRange);
+exports.getDefinitionsAtPosition = parent.sendToIpc(projectService.getDefinitionsAtPosition);
+exports.updateText = parent.sendToIpc(projectService.updateText);
+exports.errorsForFile = parent.sendToIpc(projectService.errorsForFile);
+exports.getSignatureHelps = parent.sendToIpc(projectService.getSignatureHelps);
+exports.getRenameInfo = parent.sendToIpc(projectService.getRenameInfo);
 var parentResponses = require('./parentResponses');
 parent.registerAllFunctionsExportedFromAsResponders(parentResponses);

lib/worker/parent.ts

@@ -11,7 +11,7 @@ import tsconfig = require('../main/tsconfig/tsconfig');
 
 var parent = new workerLib.Parent();
 export function startWorker() {
-    parent.startWorker(__dirname + '/childMain.js', showError);
+    parent.startWorker(__dirname + '/child.js', showError);
     console.log('AtomTS worker started')
 }
 
@@ -37,21 +37,21 @@ function showError(error: Error) {
 ///ts:import=projectService
 import projectService = require('../main/lang/projectService'); ///ts:import:generated
 
-export var echo = parent.childQuery(projectService.echo);
-export var quickInfo = parent.childQuery(projectService.quickInfo);
-export var build = parent.childQuery(projectService.build);
-export var errorsForFileFiltered = parent.childQuery(projectService.errorsForFileFiltered);
-export var getCompletionsAtPosition = parent.childQuery(projectService.getCompletionsAtPosition);
-export var emitFile = parent.childQuery(projectService.emitFile);
-export var regenerateProjectGlob = parent.childQuery(projectService.regenerateProjectGlob);
-export var formatDocument = parent.childQuery(projectService.formatDocument);
-export var formatDocumentRange = parent.childQuery(projectService.formatDocumentRange);
-export var getDefinitionsAtPosition = parent.childQuery(projectService.getDefinitionsAtPosition);
-export var updateText = parent.childQuery(projectService.updateText);
-export var errorsForFile = parent.childQuery(projectService.errorsForFile);
-export var getSignatureHelps = parent.childQuery(projectService.getSignatureHelps);
-export var getRenameInfo = parent.childQuery(projectService.getRenameInfo);
+export var echo = parent.sendToIpc(projectService.echo);
+export var quickInfo = parent.sendToIpc(projectService.quickInfo);
+export var build = parent.sendToIpc(projectService.build);
+export var errorsForFileFiltered = parent.sendToIpc(projectService.errorsForFileFiltered);
+export var getCompletionsAtPosition = parent.sendToIpc(projectService.getCompletionsAtPosition);
+export var emitFile = parent.sendToIpc(projectService.emitFile);
+export var regenerateProjectGlob = parent.sendToIpc(projectService.regenerateProjectGlob);
+export var formatDocument = parent.sendToIpc(projectService.formatDocument);
+export var formatDocumentRange = parent.sendToIpc(projectService.formatDocumentRange);
+export var getDefinitionsAtPosition = parent.sendToIpc(projectService.getDefinitionsAtPosition);
+export var updateText = parent.sendToIpc(projectService.updateText);
+export var errorsForFile = parent.sendToIpc(projectService.errorsForFile);
+export var getSignatureHelps = parent.sendToIpc(projectService.getSignatureHelps);
+export var getRenameInfo = parent.sendToIpc(projectService.getRenameInfo);
 
 // Automatically include all functions from "parentResponses" as a responder
 import parentResponses = require('./parentResponses');
-parent.registerAllFunctionsExportedFromAsResponders(parentResponses);
+parent.registerAllFunctionsExportedFromAsResponders(parentResponses);

lib/worker/parentResponses.js

@@ -1,4 +1,4 @@
 function plus1(query) {
-    return { num: query.num + 1 };
+    return Promise.resolve({ num: query.num + 1 });
 }
 exports.plus1 = plus1;

lib/worker/parentResponses.ts

@@ -1,5 +1,5 @@
 /// Functions that the parent allows the child to query
 
-export function plus1(query: { num: number }): { num: number } {
-    return { num: query.num + 1 };
-}
+export function plus1(query: { num: number }): Promise<{ num: number }> {
+    return Promise.resolve({ num: query.num + 1 });
+}