Merge pull request #110 from ManuelHentschel/helpViewer

Help viewer

Author: ManuelHentschel

.vscode/tasks.json

@@ -17,7 +17,7 @@
 			"label": "Package and install Extension",
 			"type": "shell",
 			"problemMatcher": [],
-			"command": "vsce package -o rdebugger.vsix && code --install-extension rdebugger.vsix --force",
+			"command": "vsce package -o ${workspaceFolderBasename}.vsix && code --install-extension ${workspaceFolderBasename}.vsix --force",
 			"group": {
 				"kind": "build",
 				"isDefault": true

package.json

@@ -228,6 +228,11 @@
                 "default": true,
                 "markdownDescription": "Whether to attach a modified `load_all()` function (requries pkgload, direct calls to `pkgload::load_all()` are not affected)."
               },
+              "overwriteHelp": {
+                "type": "boolean",
+                "default": true,
+                "markdownDescription": "Whether to register a new S3 print method for `help_files_with_topic` to use the help panel from vscode-R."
+              },
               "setBreakpointsInPackages": {
                 "type": "boolean",
                 "default": false,
@@ -410,12 +415,5 @@
     "semver": "^7.3.2",
     "tree-kill": "^1.2.2",
     "winreg": "^1.2.4"
-  },
-  "definitions": {
-    "testDefinition": {
-      "type": "string",
-      "default": "testDefault",
-      "description": "testDescription"
-    }
   }
 }

src/debugAdapter.ts

@@ -14,12 +14,13 @@ import { DebugRuntime } from './debugRuntime';
 import { DebugProtocol } from 'vscode-debugprotocol';
 import { InitializeRequest } from './debugProtocolModifications';
 import { config, getVSCodePackageVersion } from './utils';
+import { RExtension, HelpPanel } from './rExtensionApi';
 
 import * as vscode from 'vscode';
 
 import * as log from 'loglevel';
 const logger = log.getLogger("DebugSession");
-logger.setLevel(config().get<log.LogLevelDesc>('logLevelSession', 'INFO'));
+logger.setLevel(config().get<log.LogLevelDesc>('logLevelSession', 'SILENT'));
 
 
 function logMessage(message: DebugProtocol.ProtocolMessage){
@@ -46,9 +47,9 @@ export class DebugAdapter implements vscode.DebugAdapter {
     private runtime: DebugRuntime; // actually handles requests etc. that are not forwarded
     private disconnectTimeout: number = config().get<number>('timeouts.startup', 1000);
 
-    constructor() {
+    constructor(helpPanel?: HelpPanel) {
 		// construct R runtime
-		this.runtime = new DebugRuntime();
+		this.runtime = new DebugRuntime(helpPanel);
 
 		// setup event handler
         this.runtime.on('protocolMessage', (message: DebugProtocol.ProtocolMessage) => {
@@ -119,7 +120,7 @@ export class DebugAdapter implements vscode.DebugAdapter {
                 case 'disconnect':
                     // kill R process after timeout, in case it doesn't quit successfully
                     setTimeout(()=>{
-                        console.log('killing R...');
+                        logger.info('killing R...');
                         this.runtime.killR();
                     }, this.disconnectTimeout);
                     dispatchToR = true;

src/debugProtocolModifications.ts

@@ -1,6 +1,7 @@
 
 
 import { DebugProtocol } from 'vscode-debugprotocol';
+// @ts-ignore
 import * as VsCode from 'vscode';
 // import { DebugProtocol } from './debugProtocol';
 
@@ -43,12 +44,14 @@ export interface DebugConfiguration extends VsCode.DebugConfiguration {
     overwriteStr?: boolean;
     overwriteSource?: boolean;
     overwriteLoadAll?: boolean;
+    overwriteHelp?: boolean;
     splitOverwrittenOutput?: boolean;
 
     // custom events/requests/capabilities:
     supportsWriteToStdinEvent?: boolean;
     supportsShowingPromptRequest?: boolean;
     supportsStdoutReading?: boolean;
+    supportsHelpViewer?: boolean;
     ignoreFlowControl?: boolean;
 
     useCustomSocket?: boolean;
@@ -145,6 +148,15 @@ export interface CustomEvent extends DebugProtocol.Event {
     }
 }
 
+// Request help panel
+export interface ViewHelpEvent extends CustomEvent {
+    body: ViewHelpBody;
+}
+export interface ViewHelpBody {
+    reason: "viewHelp";
+    requestPath: string;
+}
+
 // Indicate that VS-Code should write a given text to R's stdin
 export interface WriteToStdinEvent extends CustomEvent {
     body: WriteToStdinBody;

src/debugRuntime.ts

@@ -8,12 +8,13 @@ import { RSession } from './rSession';
 import { DebugProtocol } from 'vscode-debugprotocol';
 import * as MDebugProtocol from './debugProtocolModifications';
 import { explainRPackage, PackageVersionInfo } from './installRPackage';
+import { RExtension, HelpPanel } from './rExtensionApi';
 
 const { Subject } = require('await-notify');
 
 import * as log from 'loglevel';
 const logger = log.getLogger("DebugRuntime");
-logger.setLevel(config().get<log.LogLevelDesc>('logLevelRuntime', 'info'));
+logger.setLevel(config().get<log.LogLevelDesc>('logLevelRuntime', 'SILENT'));
 
 
 export type LineHandler = (line: string, from: DataSource, isFullLine: boolean) => string;
@@ -46,6 +47,8 @@ export class DebugRuntime extends EventEmitter {
 	// The rSession used to run the code
 	public rSession: RSession;
 
+	readonly helpPanel: HelpPanel;
+
 	// // state info about the R session
 	// R session
 	private rSessionStartup = new Subject(); // used to wait for R session to start
@@ -70,8 +73,9 @@ export class DebugRuntime extends EventEmitter {
 	private writeOnPrompt: WriteOnPrompt[] = [];
 
 	// constructor
-	constructor() {
+	constructor(helpPanel?: HelpPanel) {
 		super();
+		this.helpPanel = helpPanel;
 	}
 
 	public async initializeRequest(response: DebugProtocol.InitializeResponse, args: MDebugProtocol.InitializeRequestArguments, request: MDebugProtocol.InitializeRequest) {
@@ -387,7 +391,7 @@ export class DebugRuntime extends EventEmitter {
 				this.writeToStdin(wop.text);
 				this.writeOnPrompt.unshift(wop);
 			} else{
-				console.log('invalid wop');
+				logger.error('invalid writeOnPrompt entry');
 			}
 		} else {
 			const cmdListen = this.rStrings.packageName + `::.vsc.listenForJSON(timeout = -1)`;
@@ -444,6 +448,8 @@ export class DebugRuntime extends EventEmitter {
 			if(json.event === 'custom'){
 				if(json.body.reason === "writeToStdin"){
 					this.handleWriteToStdinEvent(json.body);
+				} else if(json.body.reason === "viewHelp" && json.body.requestPath){
+					this.helpPanel.showHelpForPath(json.body.requestPath);
 				}
 				logger.info("event: " + json.event, json.body);
 			} else{

src/extension.ts

@@ -11,19 +11,35 @@ import {
 import { updateRPackage } from './installRPackage';
 import { trackTerminals, TerminalHandler } from './terminals';
 
-let terminalHandler: TerminalHandler;
+import { RExtension, HelpPanel } from './rExtensionApi';
+
 import * as fs from 'fs';
 import * as path from 'path';
 
 
 // this method is called when the extension is activated
 export async function activate(context: vscode.ExtensionContext) {
 
-	terminalHandler = new TerminalHandler();
+	const rExtension = vscode.extensions.getExtension<RExtension>('ikuyadeu.r');
+
+	let rHelpPanel: HelpPanel = undefined;
+
+	if(rExtension){
+		const api = await rExtension.activate();
+		if(api){
+			rHelpPanel = api.helpPanel;
+		}
+	}
+
+	const supportsHelpViewer = !!rHelpPanel;
+
+	const terminalHandler = new TerminalHandler();
 	const port = await terminalHandler.portPromise;
 
+	context.subscriptions.push(terminalHandler);
+
 	// register configuration resolver
-	const resolver = new DebugConfigurationResolver(port);
+	const resolver = new DebugConfigurationResolver(port, 'localhost', supportsHelpViewer);
 	context.subscriptions.push(vscode.debug.registerDebugConfigurationProvider('R-Debugger', resolver));
 
 	// register dynamic configuration provider
@@ -35,7 +51,7 @@ export async function activate(context: vscode.ExtensionContext) {
 	context.subscriptions.push(vscode.debug.registerDebugConfigurationProvider('R-Debugger', initialProvider, DebugConfigurationProviderTriggerKind.Initial));
 
 	// register the debug adapter descriptor provider
-    const factory = new DebugAdapterDescriptorFactory();
+    const factory = new DebugAdapterDescriptorFactory(rHelpPanel);
 	context.subscriptions.push(vscode.debug.registerDebugAdapterDescriptorFactory('R-Debugger', factory));
 
 	if(vscode.workspace.getConfiguration('rdebugger').get<boolean>('trackTerminals', false)){
@@ -48,18 +64,18 @@ export async function activate(context: vscode.ExtensionContext) {
 }
 
 // this method is called when the extension is deactivated
-export function deactivate() {
-	// close connections opened by terminalHandler
-	if(terminalHandler){
-		terminalHandler.close();
-	}
-}
+export function deactivate() {}
 
 class DebugAdapterDescriptorFactory implements vscode.DebugAdapterDescriptorFactory {
+	helpPanel?: HelpPanel;
+
+	constructor(helpPanel?: HelpPanel){
+		this.helpPanel = helpPanel;
+	}
 	createDebugAdapterDescriptor(session: vscode.DebugSession): ProviderResult<vscode.DebugAdapterDescriptor> {
 		const config = session.configuration;
 		if(config.request === 'launch'){
-			return new vscode.DebugAdapterInlineImplementation(new DebugAdapter());
+			return new vscode.DebugAdapterInlineImplementation(new DebugAdapter(this.helpPanel));
 		} else if(config.request === 'attach'){
 			const port: number = config.port || 18721;
 			const host: string = config.host || 'localhost';
@@ -190,10 +206,12 @@ class DebugConfigurationResolver implements vscode.DebugConfigurationProvider {
 
 	readonly customPort: number;
 	readonly customHost: string;
+	readonly supportsHelpViewer: boolean;
 
-	constructor(customPort: number, customHost: string = 'localhost') {
+	constructor(customPort: number, customHost: string = 'localhost', supportsHelpViewer: boolean = false) {
 		this.customPort = customPort;
 		this.customHost = customHost;
+		this.supportsHelpViewer = supportsHelpViewer;
 	}
 
 	resolveDebugConfiguration(folder: WorkspaceFolder | undefined, config: vscode.DebugConfiguration, token?: CancellationToken): ProviderResult<StrictDebugConfiguration> {
@@ -250,6 +268,9 @@ class DebugConfigurationResolver implements vscode.DebugConfigurationProvider {
 			config.supportsStdoutReading = true;
 			config.supportsWriteToStdinEvent = true;
 			config.supportsShowingPromptRequest = true;
+			// set to true if not specified. necessary since its default in vscDebugger is FALSE:
+			config.overwriteHelp = config.overwriteHelp ?? true; 
+			config.overwriteHelp =  config.overwriteHelp && this.supportsHelpViewer; // check if helpview available
 		} else if (config.request === 'attach'){
 			// communication info with TerminalHandler():
 			config.customPort = config.customPort ?? this.customPort;

src/rExtensionApi.d.ts

@@ -0,0 +1,17 @@
+
+
+
+export declare class RExtension {
+    helpPanel: HelpPanel;
+}
+
+
+export interface HelpPanel {
+	dispose(): void;
+	showHelpForInput(): Promise<boolean>;
+	showHelpForFunctionName(fncName: string, pkgName: string): void;
+	showHelpForPath(requestPath: string): void;
+}
+
+
+

src/rSession.ts

@@ -32,7 +32,7 @@ export class RSession {
 
 
     constructor(){
-		logger.setLevel(config().get<log.LogLevelDesc>('logLevelRSession', 'silent'));
+		logger.setLevel(config().get<log.LogLevelDesc>('logLevelRSession', 'SILENT'));
     };
 
     public async startR(

src/terminals.ts

@@ -32,7 +32,7 @@ import { WriteToStdinEvent, WriteToStdinBody } from './debugProtocolModification
 import { config, getPortNumber } from './utils';
 
 const logger = log.getLogger("DebugRuntime");
-logger.setLevel(config().get<log.LogLevelDesc>('logLevelTerminals', 'INFO'));
+logger.setLevel(config().get<log.LogLevelDesc>('logLevelTerminals', 'SILENT'));
 
 let doTrackTerminals: boolean = false;
 
@@ -106,8 +106,8 @@ export class TerminalHandler {
         this.portPromise = portPromise;
     }
 
-    public close(){
-        console.log('Closing custom server connections');
+    public dispose(){
+        logger.info('Closing custom server connections');
         this.lineCache.forEach((_, socket) => {
             socket.destroy();
         });

test/R/.vscode/launch.json

@@ -38,4 +38,4 @@
             "splitOverwrittenOutput": true
         }
     ]
-}
+}