Add nREPL evaluation status bar indicator

Author: stefan-toubia

src/nrepl/events.ts

@@ -0,0 +1,13 @@
+interface Event {
+    type: string
+}
+
+export class NReplEvaluationStartedEvent implements Event {
+    type = "started"
+    constructor(public fileName: string, public filePath: string){}
+}
+
+export class NReplEvaluationFinishedEvent implements Event {
+    type = "finished";
+    constructor(public fileName: string, public filePath: string, public error?:string){}
+}

src/nrepl/index.ts

@@ -1,10 +1,15 @@
+import { Event, EventEmitter } from "vscode";
 import * as net from "net";
 import { BEncoderStream, BDecoderStream } from "./bencode";
 import * as state from './../state';
 import * as replWindow from './../repl-window';
 import * as util from '../utilities';
 import { prettyPrint } from '../../out/cljs-lib/cljs-lib';
 import { PrettyPrintingOptions, disabledPrettyPrinter, getServerSidePrinter } from "../printer";
+import { NReplEvaluationStartedEvent, NReplEvaluationFinishedEvent } from "./events";
+
+const eventEmitter = new EventEmitter<NReplEvaluationStartedEvent | NReplEvaluationFinishedEvent>();
+export const onNReplEvent = eventEmitter.event;
 
 /** An nRREPL client */
 export class NReplClient {
@@ -29,6 +34,7 @@ export class NReplClient {
     ns: string = "user";
 
     private constructor(socket: net.Socket) {
+        // TODO: Emit client connection events
         this.socket = socket;
         this.socket.on("error", e => {
             console.error(e);
@@ -305,14 +311,27 @@ export class NReplSession {
             stderr?: (x: string) => void,
             stdout?: (x: string) => void,
             pprintOptions: PrettyPrintingOptions
-        } = { 
+        } = {
             pprintOptions: disabledPrettyPrinter
         }) {
 
+        eventEmitter.fire(new NReplEvaluationStartedEvent(opts.fileName, opts.filePath));
+
+        const fireEventOnFin = (
+            finalize: ((response: string) => any),
+            createEvent: ((response: string) => any)
+            ) => (response: string) => {
+                eventEmitter.fire(createEvent(response));
+                finalize(response);
+        }
+
         let id = this.client.nextId;
         let evaluation = new NReplEvaluation(id, this, opts.stderr, opts.stdout, null, new Promise((resolve, reject) => {
             this.messageHandlers[id] = (msg) => {
-                evaluation.setHandlers(resolve, reject);
+                evaluation.setHandlers(
+                    fireEventOnFin(resolve, _ => new NReplEvaluationFinishedEvent(opts.fileName, opts.filePath)),
+                    fireEventOnFin(reject, (reason: string) => new NReplEvaluationFinishedEvent(opts.fileName, opts.filePath, reason))
+                    );
                 if (evaluation.onMessage(msg, opts.pprintOptions)) {
                     return true;
                 }
@@ -762,4 +781,4 @@ export class NReplEvaluation {
         });
         return (num);
     }
-}
+}

src/statusbar/file-type.ts

@@ -1,13 +1,38 @@
 import { window, StatusBarAlignment, StatusBarItem } from "vscode";
 import { activeReplWindow } from '../repl-window';
+
+import { onNReplEvent } from "../nrepl";
+import { NReplEvaluationStartedEvent, NReplEvaluationFinishedEvent } from "../nrepl/events";
+
 import configReader from "../configReader";
 import * as state from '../state';
 import * as util from '../utilities';
 
+export interface EvaluationError {
+    fileName: string;
+    filePath: string;
+    message: string;
+}
+
 export class FileTypeStatusBarItem {
     private statusBarItem: StatusBarItem;
+
+    private activeEvals = new Array<string>();
+
+    private errors = new Array<EvaluationError>();
+
+    private get isEvaluating() {
+        return this.activeEvals.length > 0;
+    }
+
+    private get hasErrors(){
+        return this.errors.length > 0;
+    }
+
     constructor(alignment: StatusBarAlignment) {
         this.statusBarItem = window.createStatusBarItem(alignment);
+        // TODO: Event handling and resulting state should be moved to global state
+        onNReplEvent(this.handleNreplEvent);
     }
 
     update() {
@@ -23,19 +48,22 @@ export class FileTypeStatusBarItem {
 
         if(connected) {
             if (fileType == 'cljc' && sessionType !== null && !activeReplWindow()) {
-                text = "cljc/" + sessionType;
+                text = this.statusTextDecorator("cljc/" + sessionType);
                 if (util.getSession('clj') !== null && util.getSession('cljs') !== null) {
                     command = "calva.toggleCLJCSession";
                     tooltip = `Click to use ${(sessionType === 'clj' ? 'cljs' : 'clj')} REPL for cljc`;
                 }
             } else if (sessionType === 'cljs') {
-                text = "cljs";
+                text = this.statusTextDecorator("cljs");
                 tooltip = "Connected to ClojureScript REPL";
             } else if (sessionType === 'clj') {
-                text = "clj";
+                text = this.statusTextDecorator("clj");
                 tooltip = "Connected to Clojure REPL";
             }
-            color = configReader.colors.typeStatus;
+            color = this.connectedStatusColor();
+            if(this.hasErrors) {
+                tooltip = this.errorTooltip();
+            }
         }
 
         this.statusBarItem.command = command;
@@ -45,6 +73,70 @@ export class FileTypeStatusBarItem {
         this.statusBarItem.show();
     }
 
+    private statusTextDecorator(text): string {
+        if(this.hasErrors) {
+            const c = this.errors.length;
+            text = `${text} $(alert) ${c > 1 ? c : ""}`
+        }
+        if(this.isEvaluating) {
+            text = text + " $(gear~spin)";
+        }
+        return text;
+    }
+
+    private connectedStatusColor(): string {
+        const c = configReader.colors;
+        if(this.hasErrors) {
+            return c.error;
+        } else if (this.isEvaluating) {
+            return c.launching;
+        }
+        return c.typeStatus;
+    }
+
+    private errorTooltip(): string {
+        if(this.errors.length > 1){
+            return "There are errors in multiple files";
+        }
+        const err = this.errors[0];
+        return `Error: ${err.fileName}: ${err.message}`;
+    }
+
+    private handleNreplEvent = (e: NReplEvaluationStartedEvent | NReplEvaluationFinishedEvent) => {
+        switch(e.type){
+            case "started":
+                this.removeError(e.filePath);
+                this.activeEvals.push(e.filePath);
+                break;
+            case "finished":
+                this.removeActive(e.filePath);
+                const fe = <NReplEvaluationFinishedEvent> e;
+                if(fe.error) {
+                    this.errors.push({
+                        fileName: fe.fileName,
+                        filePath: fe.filePath,
+                        message: fe.error
+                    });
+                }
+                break;
+        }
+        this.update();
+    }
+
+    private removeActive(filePath: string) {
+        const idx = this.activeEvals.indexOf(filePath);
+        if(idx !== -1) {
+            this.activeEvals.splice(idx, 1);
+        }
+    }
+
+    private removeError(filePath: string) {
+        const idx = this.errors.findIndex(e => e.filePath === filePath);
+        if(idx !== -1) {
+            this.errors.splice(idx, 1);
+        }
+    }
+
     dispose() {
         this.statusBarItem.dispose();
     }