Add R path to debug config

Author: ManuelHentschel

package.json

@@ -207,6 +207,11 @@
                 "default": true,
                 "markdownDescription": "Whether to allow debugging in the global workspace after running the function/file."
               },
+              "rPath": {
+                "type": "string",
+                "markdownDescription": "Path to an R executable. Set to the empty string to use the path from the settings.",
+                "default": ""
+              },
               "workingDirectory": {
                 "type": "string",
                 "markdownDescription": "Absolute path to a directory. Is switched to using `setwd()` after launching R.",

src/debugConfig.ts

@@ -12,6 +12,7 @@ import { HelpPanel } from './rExtensionApi';
 
 import * as fs from 'fs';
 import * as path from 'path';
+import { getRpathFromConfig } from './utils';
 
 
 export class DebugAdapterDescriptorFactory implements vscode.DebugAdapterDescriptorFactory {
@@ -214,8 +215,10 @@ export class DebugConfigurationResolver implements vscode.DebugConfigurationProv
 		config.debugMode ||= (docValid ? 'file' : 'workspace');
 		config.allowGlobalDebugging ??= true;
 
-		// fill custom capabilities/socket info
+		// fill custom capabilities/socket info/rPath
 		if(config.request === 'launch'){
+			// if not specified, set rPath from config
+			config.rPath ||= getRpathFromConfig();
 			// capabilities that are always true for this extension:
 			config.supportsStdoutReading = true;
 			config.supportsWriteToStdinEvent = true;

src/debugProtocolModifications.ts

@@ -64,6 +64,7 @@ export interface DebugConfiguration extends vsCode.DebugConfiguration {
 
 export interface LaunchConfiguration extends DebugConfiguration {
     request: 'launch';
+    rPath?: string;
     commandLineArgs?: string[];
     env?: {
         [key: string]: string;

src/utils.ts

@@ -50,7 +50,7 @@ function getRfromEnvPath(platform: string) {
     return '';
 }
 
-export async function getRpathFromSystem(): Promise<string> {
+async function getRpathFromSystem(): Promise<string> {
 
     let rpath = '';
     const platform: string = process.platform;
@@ -75,41 +75,49 @@ export async function getRpathFromSystem(): Promise<string> {
     return rpath;
 }
 
-export async function getRpath(quote: boolean=false, overwriteConfig?: string): Promise<string> {
-    let rpath: string | undefined = undefined;
-    
+export function getRpathFromConfig(): string | undefined {
+    const platform: string = process.platform;
     const configEntry = (
-        process.platform === 'win32' ? 'rpath.windows' :
-        process.platform === 'darwin' ? 'rpath.mac' :
+        platform === 'win32' ? 'rpath.windows' :
+        platform === 'darwin' ? 'rpath.mac' :
         'rpath.linux'
     );
+    return config(false).get<string>(configEntry);
+}
 
-    // try the config entry specified in the function arg:
-    if(overwriteConfig){
-        rpath = config().get<string>(overwriteConfig);
+export function quoteRPathIfNeeded(rpath: string): string {
+    if (/^'.* .*'$/.exec(rpath) || /^".* .*"$/.exec(rpath)) {
+        // already quoted
+        return rpath;
+    } else if (/.* .*/.exec(rpath)) {
+        // contains spaces, add quotes
+        if (process.platform === 'win32') {
+            return `"${rpath}"`;
+        } else {
+            return `'${rpath}'`;
+        }
+    } else {
+        // no spaces, no quotes needed
+        return rpath;
     }
+}
 
+export async function getRpath(): Promise<string> {
+    let rpath: string | undefined;
+    
     // try the os-specific config entry for the rpath:
-    rpath ||= config(false).get<string>(configEntry);
+    rpath = getRpathFromConfig();
 
     // read from path/registry:
     rpath ||= await getRpathFromSystem();
 
-    // represent all invalid paths (undefined, '', null) as '':
-    rpath ||= '';
-
     if(!rpath){
         // inform user about missing R path:
-        void vscode.window.showErrorMessage(`${process.platform} can't use R`);
-    } else if(quote && /^[^'"].* .*[^'"]$/.exec(rpath)){
-        // if requested and rpath contains spaces, add quotes:
-        rpath = `"${rpath}"`;
-    } else if(process.platform === 'win32' && /^'.* .*'$/.exec(rpath)){
-        // replace single quotes with double quotes on windows
-        rpath = rpath.replace(/^'(.*)'$/, '"$1"');
+        void vscode.window.showErrorMessage(`No R executable found. Please set the path in the settings r.rPath.xxx!`);
     }
 
-    return rpath;
+    // represent all invalid paths (undefined, '', null) as '':
+    return rpath || '';
 }
 
 export function getPortNumber(server?: net.Server): number {
@@ -131,10 +139,13 @@ export async function getRStartupArguments(launchConfig: {
     env?: {[key: string]: string};
     commandLineArgs?: string[];
     launchDirectory?: string;
+    rPath?: string;
 } = {}): Promise<RStartupArguments> {
     const platform: string = process.platform;
 
-    const rpath = await getRpath(true);
+    let rPath = launchConfig.rPath;
+    rPath ||= await getRpath();
+    rPath = quoteRPathIfNeeded(rPath);
 
     const rArgs: string[] = [
         '--quiet',
@@ -148,13 +159,13 @@ export async function getRStartupArguments(launchConfig: {
     rArgs.push(...(launchConfig.commandLineArgs || []));
 
     const ret: RStartupArguments = {
-        path: rpath,
+        path: rPath,
         args: rArgs,
         cwd: launchConfig.launchDirectory,
         env: launchConfig.env
     };
 
-    if(rpath === ''){
+    if(rPath === ''){
         void vscode.window.showErrorMessage(`${process.platform} can't find R`);
     }
     return ret;

test/R/.vscode/launch.json

@@ -12,8 +12,12 @@
             "workingDirectory": "${workspaceFolder}",
             "allowGlobalDebugging": true,
             "env": {
-                "abc": "123"
-            }
+                "abc": "123",
+                "dcUserProfile": "${env:USERPROFILE}",
+                "dcUserHome": "${userHome}",
+                "dcRPath": "${userHome}/../../Program Files/R/R-4.3.3/bin/x64/R.exe",
+            },
+            "rPath": "${userHome}/../../Program Files/R/R-4.4.3/bin/x64/R.exe",
         },
         {
             "type": "R-Debugger",