Use promises for host -> child queries.

refs #27
closes #19

Author: basarat

lib/globals.ts

@@ -9,3 +9,4 @@
 /// <reference path="./typings/mustache.d.ts"/>
 
 /// <reference path="./node_modules/views/views.d.ts"/>
+/// <reference path="./typings/atompromise.d.ts"/>

lib/main/atomts.js

@@ -44,11 +44,7 @@ function activate(state) {
                         return;
                     }
                     var text = editor.getText();
-                    parent.updateText({ filePath: filePath, text: text }, function () {
-                        parent.getErrorsForFile({ filePath: filePath }, function (resp) {
-                            errorView.setErrors(filePath, resp.errors);
-                        });
-                    });
+                    parent.updateText({ filePath: filePath, text: text }).then(function () { return parent.getErrorsForFile({ filePath: filePath }); }).then(function (resp) { return errorView.setErrors(filePath, resp.errors); });
                     program.languageServiceHost.updateScript(filePath, text);
                     var position = atomUtils.getEditorPosition(editor);
                     signatureProvider.requestHandler({

lib/main/atomts.ts

@@ -109,12 +109,10 @@ export function activate(state: PackageState) {
                     var text = editor.getText();
 
                     // Update the file in the worker
-                    parent.updateText({ filePath: filePath, text: text },() => {
-                        parent.getErrorsForFile({ filePath: filePath },(resp) => {
-                            // Set errors in project per file
-                            errorView.setErrors(filePath, resp.errors);
-                        });
-                    });
+                    parent.updateText({ filePath: filePath, text: text })
+                    // Set errors in project per file
+                        .then(() => parent.getErrorsForFile({ filePath: filePath }))
+                        .then((resp) => errorView.setErrors(filePath, resp.errors));
 
                     // Update the file
                     program.languageServiceHost.updateScript(filePath, text);

lib/tsconfig.json

@@ -4,7 +4,8 @@
         "module": "commonjs",
         "declaration": false,
         "noImplicitAny": false,
-        "removeComments": true
+        "removeComments": true,
+        "noLib": false
     },
     "filesGlob": [
         "./**/*.ts"
@@ -25,6 +26,7 @@
         "./main/tsconfig/tsconfig.ts",
         "./node_modules/views/views.d.ts",
         "./typings/atom/atom.d.ts",
+        "./typings/atompromise.d.ts",
         "./typings/bluebird.d.ts",
         "./typings/brackets.d.ts",
         "./typings/codemirror.d.ts",

lib/typings/atompromise.d.ts

@@ -0,0 +1,98 @@
+// Ripped from lib.es6.d.ts with addtions for atom
+
+/**
+ * Represents the completion of an asynchronous operation
+ */
+interface Promise<T> {
+    /**
+    * Attaches callbacks for the resolution and/or rejection of the Promise.
+    * @param onfulfilled The callback to execute when the Promise is resolved.
+    * @param onrejected The callback to execute when the Promise is rejected.
+    * @returns A Promise for the completion of which ever callback is executed.
+    */
+    then<TResult>(onfulfilled?: (value: T) => TResult | Promise<TResult>, onrejected?: (reason: any) => TResult | Promise<TResult>): Promise<TResult>;
+
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of the callback.
+     */
+    catch(onrejected?: (reason: any) => T | Promise<T>): Promise<T>;
+}
+
+interface PromiseConstructor {
+    /**
+      * A reference to the prototype.
+      */
+    prototype: Promise<any>;
+
+    /**
+     * Creates a new Promise.
+     * @param init A callback used to initialize the promise. This callback is passed two arguments:
+     * a resolve callback used resolve the promise with a value or the result of another promise,
+     * and a reject callback used to reject the promise with a provided reason or error.
+     */
+    new <T>(init: (resolve: (value?: T | Promise<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
+
+    <T>(init: (resolve: (value?: T | Promise<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
+
+    /**
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
+     * resolve, or rejected when any Promise is rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    all<T>(values: (T | Promise<T>)[]): Promise<T[]>;
+
+    /**
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
+     * resolve, or rejected when any Promise is rejected.
+     * @param values An array of values.
+     * @returns A new Promise.
+     */
+    all(values: Promise<void>[]): Promise<void>;
+
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    race<T>(values: (T | Promise<T>)[]): Promise<T>;
+
+    /**
+     * Creates a new rejected promise for the provided reason.
+     * @param reason The reason the promise was rejected.
+     * @returns A new rejected Promise.
+     */
+    reject(reason: any): Promise<void>;
+
+    /**
+     * Creates a new rejected promise for the provided reason.
+     * @param reason The reason the promise was rejected.
+     * @returns A new rejected Promise.
+     */
+    reject<T>(reason: any): Promise<T>;
+
+    /**
+      * Creates a new resolved promise for the provided value.
+      * @param value A promise.
+      * @returns A promise whose internal state matches the provided promise.
+      */
+    resolve<T>(value: T | Promise<T>): Promise<T>;
+
+    /**
+     * Creates a new resolved promise .
+     * @returns A resolved promise.
+     */
+    resolve(): Promise<void>;
+
+    /// BAS ADDITIONS AFTER INSPECTION INTO ATOM
+    defer<T>(): PromiseDeferred<T>;
+}
+
+interface PromiseDeferred<T> {
+    promise: Promise<T>; resolve(value: T): any; reject(error: T): any;
+}
+
+declare var Promise: PromiseConstructor;

lib/worker/parent.js

@@ -30,7 +30,7 @@ function startWorker() {
                 return;
             }
             else {
-                currentListeners[parsed.message][parsed.id](parsed.data);
+                currentListeners[parsed.message][parsed.id].resolve(parsed.data);
                 delete currentListeners[parsed.message][parsed.id];
             }
         }
@@ -79,25 +79,25 @@ function createId() {
         return v.toString(16);
     });
 }
-function query(message, data, callback) {
-    if (callback === void 0) { callback = function () {
-    }; }
+function query(message, data) {
     if (!child || !child.stdin.writable) {
         console.log('PARENT ERR: no child when you tried to send :', message);
         return;
     }
     var id = createId();
     if (!currentListeners[message])
         currentListeners[message] = {};
-    currentListeners[message][id] = callback;
+    var defer = Promise.defer();
+    currentListeners[message][id] = defer;
     child.stdin.write(JSON.stringify({ message: message, id: id, data: data }) + messages.BufferedBySeperatorHandler.seperator);
+    return defer.promise;
 }
 function showError(error) {
     atom.notifications.addError("Failed to start a child TypeScript worker. Atom-TypeScript is disabled.");
     if (error) {
         console.error('Failed to activate ts-worker:', error);
     }
 }
-exports.echo = function (data, callback) { return query(messages.echo, data, callback); };
-exports.updateText = function (data, callback) { return query(messages.updateText, data, callback); };
-exports.getErrorsForFile = function (data, callback) { return query(messages.getErrorsForFile, data, callback); };
+exports.echo = function (data) { return query(messages.echo, data); };
+exports.updateText = function (data) { return query(messages.updateText, data); };
+exports.getErrorsForFile = function (data) { return query(messages.getErrorsForFile, data); };

lib/worker/parent.ts

@@ -10,7 +10,7 @@ var exec = childprocess.exec;
 var spawn = childprocess.spawn;
 
 var child: childprocess.ChildProcess;
-var currentListeners: { [messages: string]: { [id: string]: Function } } = {};
+var currentListeners: { [messages: string]: { [id: string]: PromiseDeferred<any> } } = {};
 export function startWorker() {
     try {
         var env = Object.create(process.env);
@@ -41,7 +41,7 @@ export function startWorker() {
                 return;
             }
             else {
-                currentListeners[parsed.message][parsed.id](parsed.data);
+                currentListeners[parsed.message][parsed.id].resolve(parsed.data);
                 delete currentListeners[parsed.message][parsed.id];
             }
         }
@@ -98,7 +98,7 @@ function createId(): string {
     });
 }
 
-function query<Query, Response>(message: string, data: Query, callback: (response: Response) => any = () => { }) {
+function query<Query, Response>(message: string, data: Query) : Promise<Response> {
 
     // If we don't have a child exit
     if (!child || !child.stdin.writable) {
@@ -111,14 +111,17 @@ function query<Query, Response>(message: string, data: Query, callback: (respons
 
     // Store the callback against this Id:
     if (!currentListeners[message]) currentListeners[message] = {};
-    currentListeners[message][id] = callback;
+
+    var defer = Promise.defer();
+    currentListeners[message][id] = defer;
 
     // Send data to worker
     child.stdin.write(JSON.stringify({ message: message, id: id, data: data }) + messages.BufferedBySeperatorHandler.seperator);
+    return defer.promise;
 }
 
-export interface Exec<Query, Response> {
-    (data: Query, callback?: (res: Response) => any);
+export interface Exec<Query,Response> {
+    (data: Query): Promise<Response>;
 }
 
 function showError(error?: Error) {
@@ -132,10 +135,10 @@ function showError(error?: Error) {
 
 
 export var echo: Exec<messages.EchoQuery, messages.EchoResponse>
-    = (data, callback) => query(messages.echo, data, callback);
+    = (data) => query(messages.echo, data);
 
 export var updateText: Exec<messages.UpdateTextQuery, messages.EchoResponse>
-    = (data, callback?) => query(messages.updateText, data, callback);
+    = (data) => query(messages.updateText, data);
 
 export var getErrorsForFile: Exec<messages.GetErrorsForFileQuery, messages.GetErrorsForFileResponse>
-    = (data, callback) => query(messages.getErrorsForFile, data, callback);
+    = (data) => query(messages.getErrorsForFile, data);