Fix results different with REPL outputs;

plylrnsdy · plylrnsdy · commit 3aeea2f5c65b · 2018-12-05T19:07:58.000+08:00
Remove useless operations.
diff --git a/src/code.ts b/src/code.ts
@@ -38,14 +38,15 @@ export function rewriteModulePathInRequire(code: string, basePath: string, fileP
 
 
 const lineBreak = /\r?\n/;
-const consoleLogCall = /console\s*\.(log|debug|error)\(/g;
+const consoleLogCall = /console\s*\.(debug|error|info|log|warn)\(/g;
 
 export function rewriteConsoleToAppendLineNumber(code: string): string {
     let num = 0,
         out = [];
 
     for (let line of code.split(lineBreak)) {
-        out.push(line.replace(consoleLogCall, `global['\`console\`'].$1(${num++}, `));
+        out.push(line.replace(consoleLogCall, (str, method) => `global['\`console\`'].${method}(${num}, `));
+        num++;
     }
 
     return out.join('\n');
diff --git a/src/decorator.ts b/src/decorator.ts
@@ -9,8 +9,6 @@ import {
     window,
 } from "vscode";
 
-import * as Util from 'util';
-
 
 // create a decorator type that we use to decorate small numbers
 const resultDecorationType = window.createTextEditorDecorationType({
@@ -23,10 +21,7 @@ const colorOfType = {
     'Console': '#457abb',
     'Error': 'red',
 }
-// TODO: if Node's Version of VSCode >=9.9, use default option
-const inspectOptions: NodeJS.InspectOptions = { depth: 20 };
-
-type Data = { line: number, type: 'Expression' | 'Terminal', value: any };
+type Data = { line: number, value: string };
 type Result = { line: number, type: 'Value of Expression' | 'Console' | 'Error', text: string, value: string };
 
 export default class Decorator {
@@ -45,19 +40,48 @@ export default class Decorator {
     }
 
     async update(data: Data) {
+        if (!data) return;
+
+        let result = this.format(data);
+
+        this.outputChannel.appendLine(`  ${result.value}`);
+
+        if (result.type === 'Console') {
+            result = this.mergeConsoleOutput(result);
+        }
+        this.updateWith(result);
+        this.decorateAll();
+    }
+    private format({ line, value }: Data): Result {
+        let match: RegExpExecArray;
 
-        let result = (data.type === 'Expression')
-            ? await this.formatExpressionValue(data)
-            : this.formatTerminalOutput(data);
+        if ((match = /((\w*Error(?:\s\[[^\]]+\])?:\s.*)(?:\n\s*at\s[\s\S]+)?)$/.exec(value)) != null) {
+            return { line, type: 'Error', text: match[1], value: match[2] };
+        }
+        else if ((match = /^`\{(\d+)\}`([\s\S]*)$/.exec(value)) != null) {
+            let value = match[2] || '';
+            return { line: +match[1], type: 'Console', text: value.replace(/\r?\n/g, ' '), value };
+        }
+        else {
+            return { line, type: 'Value of Expression', text: value.replace(/\r?\n/g, ' '), value };
+        }
+    }
+    private mergeConsoleOutput({ line, text, value }: Result) {
+        let output = this.lineToOutput.get(line);
+        if (output == null) {
+            this.lineToOutput.set(line, output = { line, type: 'Console', text: '', value: '' });
+        }
 
-        if (!result) return;
+        output.text += (output.text && ', ') + text;
+        output.value += (output.value && '\n') + value;
 
+        return output;
+    }
+    private updateWith({ line, type, text, value }: Result) {
         let decorator: DecorationOptions;
 
-        if ((decorator = this.lineToDecorator.get(result.line)) == null) {
-            let line = result.line,
-                length = this.editor.document.getText(new Range(new Position(line, 0), new Position(line, 37768))).length + 1,
-                pos = new Position(line, length);
+        if ((decorator = this.lineToDecorator.get(line)) == null) {
+            let pos = new Position(line, Number.MAX_SAFE_INTEGER);
 
             decorator = {
                 renderOptions: { before: { margin: '0 0 0 1em' } },
@@ -67,79 +91,11 @@ export default class Decorator {
             this.decorators.push(decorator);
         }
 
-        decorator.renderOptions.before.color = colorOfType[result.type];
-        decorator.renderOptions.before.contentText = ` ${result.text}`;
+        decorator.renderOptions.before.color = colorOfType[type];
+        decorator.renderOptions.before.contentText = ` ${text}`;
 
-        decorator.hoverMessage = new MarkdownString(result.type);
-        decorator.hoverMessage.appendCodeblock(result.value, result.type === 'Error' ? 'text' : 'javascript');
-
-        this.decorateAll();
-    }
-    private async formatExpressionValue(data: Data): Promise<Result> {
-        let result = data.value;
-        switch (typeof result) {
-            case 'undefined':
-                return null;
-
-            case 'object':
-                if (result.constructor && result.constructor.name === 'Promise' && result.then) {
-                    try {
-                        data.value = await (<Promise<any>>result);
-                        return data.value ? this.formatExpressionValue(data) : null;
-                    } catch (error) {
-                        return {
-                            line: data.line,
-                            type: 'Error',
-                            text: `${error.name}: ${error.message}`,
-                            value: error.stack,
-                        }
-                    }
-                }
-
-                let string = Util.inspect(result, inspectOptions);
-                return {
-                    line: data.line,
-                    type: 'Value of Expression',
-                    text: string.replace(/\n/g, ' '),
-                    value: string,
-                }
-
-            default:
-                return {
-                    line: data.line,
-                    type: 'Value of Expression',
-                    text: result.toString().replace(/\r?\n/g, ' '),
-                    value: result,
-                }
-        }
-    }
-    private formatTerminalOutput(data: Data): Result {
-        let out = data.value as string;
-        let match: RegExpExecArray;
-
-        if ((match = /^(\w*Error(?: \[[^\]]+\])?:\s.*)(?:\n\s*at\s)?/.exec(out)) != null) {
-            this.outputChannel.appendLine(`  ${out}`);
-
-            return { line: data.line, type: 'Error', text: match[1], value: out };
-        }
-        else if ((match = /^`\{(\d+)\}`([\s\S]*)$/.exec(out)) != null) {
-            let line = +match[1];
-            let msg = match[2] || '';
-
-            let output = this.lineToOutput.get(line);
-            if (output == null) {
-                this.lineToOutput.set(line, output = { line, type: 'Console', text: '', value: '' });
-            }
-
-            output.text += (output.text && ', ') + msg.replace(/\r?\n/g, ' ');
-            output.value += (output.value && '\n') + msg;
-
-            this.outputChannel.appendLine(`  ${msg}`);
-            return output;
-        }
-        else {
-            this.outputChannel.appendLine(`  ${out}`);
-        }
+        decorator.hoverMessage = new MarkdownString(type)
+            .appendCodeblock(value, type === 'Error' ? 'text' : 'javascript');
     }
 
     decorateAll() {
diff --git a/src/repl-client.ts b/src/repl-client.ts
@@ -138,12 +138,11 @@ export default class ReplClient {
     }
 
     dispose() {
+        if (!this.isClosed) this.close();
+
         this.changeActiveDisposable.dispose();
         this.closeTextDocumentDisposable.dispose();
         this.changeEventDisposable.dispose();
         this.editor = null;
-
-        this.repl.send({ operation: 'exit' });
-        this.repl = null;
     }
 }
diff --git a/src/repl-server.ts b/src/repl-server.ts
@@ -3,8 +3,7 @@ import * as Util from 'util';
 import { Writable, Readable } from 'stream';
 
 
-type ReplServer = Repl.REPLServer & { inputStream: Readable, eval: ReplEval };
-type ReplEval = (cmd: string, context: any, filename: string, cb: (err?: Error, result?: any) => void) => void;
+type ReplServer = Repl.REPLServer & { inputStream: Readable };
 
 let lineCount = 0;
 
@@ -13,63 +12,49 @@ const server = Repl.start({
     input: new Readable({ read: () => { } }),
     output: new Writable({
         write: (chunk, encoding, callback) => {
-            let out = chunk.toString().trim();
-            switch (out) {
-                case '...': break;
-                case '': break;
-                default:
-                    process.send({ line: lineCount, type: 'Terminal', value: out });
-                    break;
-            }
+            let value = chunk.toString().trim();
+
+            if (value !== '' && /^\.{3,}$/.test(value) === false)
+                process.send({ line: lineCount, value });
+
             callback();
         }
     }),
     ignoreUndefined: true,
 
 }) as ReplServer;
 
-
-const originEval = server.eval; // keep a backup of original eval
-const lineNumber = /\/\*`(\d+)`\*\//g;
-
-// nice place to read the result in sequence and inject it in the code
-server.eval = (cmd, context, filename, callback) => {
-    originEval(cmd, context, filename, (err, result) => {
-        let match: RegExpExecArray;
-
-        while ((match = lineNumber.exec(cmd)) != null)
-            lineCount += +match[1];
-
-        if (result)
-            process.send({ line: lineCount, type: 'Expression', value: result });
-
-        callback(err, result);
-    });
-
-    lineCount++;
-}
-
 const originLog = server.context.console.log;
 const appendLineLog = (lineNumber: number, text: any, ...args: any[]) => {
     originLog(`\`{${lineNumber}}\`${typeof text === 'string' ? text : Util.inspect(text)}`, ...args);
 }
 Object.defineProperty(server.context, '`console`', {
     value: {
-        log: appendLineLog,
         debug: appendLineLog,
         error: appendLineLog,
+        info: appendLineLog,
+        log: appendLineLog,
+        warn: appendLineLog,
     }
 });
 
+const lineNumber = /\/\*`(\d+)`\*\//g;
+
 process.on('message', data => {
-    if (data.code) {
-        try {
-            for (let line of data.code.split('\n'))
-                server.inputStream.push(line + '\n');
-        } catch (error) {
-            process.emit('error', error);
+
+    if (typeof data.code === 'string') {
+        for (let codeLine of data.code.split('\n')) {
+            let match: RegExpExecArray;
+
+            while ((match = lineNumber.exec(codeLine)) != null)
+                lineCount += +match[1];
+
+            server.inputStream.push(codeLine + '\n');
+
+            lineCount++;
         }
-    } else if (data.operation === 'exit') {
+    }
+    else if (data.operation === 'exit') {
         process.exit();
     }
 });

Original file line number	Diff line number	Diff line change
`@@ -138,12 +138,11 @@ export default class ReplClient {`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`dispose() {`
	`141`	`+ if (!this.isClosed) this.close();`
	`142`	`+`
`141`	`143`	`this.changeActiveDisposable.dispose();`
`142`	`144`	`this.closeTextDocumentDisposable.dispose();`
`143`	`145`	`this.changeEventDisposable.dispose();`
`144`	`146`	`this.editor = null;`
`145`		`-`
`146`		`- this.repl.send({ operation: 'exit' });`
`147`		`- this.repl = null;`
`148`	`147`	`}`
`149`	`148`	`}`