WIP windows support

Author: ElianHugh

src/executables/index.ts

@@ -112,6 +112,11 @@ export class RExecutableManager implements vscode.Disposable {
  * @returns boolean
  */
 export function validateRExecutablePath(execPath: string): boolean {
-    const basename = process.platform === 'win32' ? 'R.exe' : 'R';
-    return fs.existsSync(execPath) && (path.basename(execPath) === basename);
+    try {
+        const basename = process.platform === 'win32' ? 'R.exe' : 'R';
+        fs.accessSync(execPath, fs.constants.X_OK);
+        return  (path.basename(execPath) === basename);
+    } catch (error) {
+        return false;
+    }
 }

src/executables/service/locator/shared.ts

@@ -1,13 +1,13 @@
-import { execSync } from 'child_process';
+import { spawnSync } from 'child_process';
 import * as fs from 'fs-extra';
 import * as vscode from 'vscode';
 import { normaliseRPathString } from '../../../util';
 
-export function getRDetailsFromPath(rPath: string): {version: string, arch: string} {
+export function getRDetailsFromPath(rPath: string): { version: string, arch: string } {
     try {
         const path = normaliseRPathString(rPath);
-        const child = execSync(`${path} --version`)?.toString();
-        const versionRegex = /(?<=R version\s)[0-9.]*/g;
+        const child = spawnSync(path, [`--version`]).output.join('\n');
+        const versionRegex = /(?<=R\sversion\s)[0-9.]*/g;
         const archRegex = /[0-9]*-bit/g;
         const out = {
             version: child.match(versionRegex)?.[0] ?? '',

src/executables/service/locator/windows.ts

@@ -3,6 +3,15 @@ import * as vscode from 'vscode';
 import path = require('path');
 import winreg = require('winreg');
 import { getUniquePaths, AbstractLocatorService } from './shared';
+import { validateRExecutablePath } from '../..';
+
+const WindowsKnownPaths = [
+    path.join(process.env.ProgramFiles, 'R'),
+    path.join(process.env['ProgramFiles(x86)'], 'R'),
+    path.join(process.env.ProgramFiles, 'Microsoft', 'R Open'),
+    path.join(process.env.ProgramFiles, 'Microsoft', 'R Open'),
+];
+
 
 export class WindowsExecLocator extends AbstractLocatorService {
     constructor() {
@@ -62,22 +71,19 @@ export class WindowsExecLocator extends AbstractLocatorService {
 
     private getHomeFromDirs(): string[] {
         const dirBins: string[] = [];
-        const potential_bin_paths: string[] = [
-            '%ProgramFiles%\\R\\',
-            '%ProgramFiles(x86)%\\R\\'
-        ];
-        for (const bin of potential_bin_paths) {
-            const resolvedBin = path.resolve(bin);
-            if (fs.existsSync(resolvedBin)) {
-                const i386 = `${resolvedBin}\\i386\\`;
-                const x64 = `${resolvedBin}\\x64\\`;
-
-                if (fs.existsSync(i386)) {
-                    dirBins.push(i386);
-                }
+        for (const bin of WindowsKnownPaths) {
+            if (fs.existsSync(bin)) {
+                const dirs = fs.readdirSync(bin);
+                for (const dir of dirs) {
+                    const i386 = `${bin}\\${dir}\\bin\\i386\\R.exe`;
+                    const x64 = `${bin}\\${dir}\\bin\\x64\\R.exe`;
+                    if (validateRExecutablePath(i386)) {
+                        dirBins.push(i386);
+                    }
 
-                if (fs.existsSync(x64)) {
-                    dirBins.push(x64);
+                    if (validateRExecutablePath(x64)) {
+                        dirBins.push(x64);
+                    }
                 }
             }
         }
@@ -90,7 +96,7 @@ export class WindowsExecLocator extends AbstractLocatorService {
 
         if (os_paths) {
             for (const os_path of os_paths) {
-                const os_r_path: string = path.join(os_path, 'R' + '.exe');
+                const os_r_path: string = path.join(os_path, '/R.exe');
                 if (fs.existsSync(os_r_path)) {
                     envBins.push(os_r_path);
                 }

src/executables/ui/quickpick.ts

@@ -1,3 +1,4 @@
+import path = require('path');
 import * as vscode from 'vscode';
 
 import { ExecutableNotifications } from '.';
@@ -64,6 +65,9 @@ export class ExecutableQuickPick implements vscode.Disposable {
     private setItems(): void {
         const qpItems: vscode.QuickPickItem[] = [];
         const configPath = config().get<string>(getRPathConfigEntry());
+        const sortExecutables = (a: ExecutableType, b: ExecutableType) => {
+            return -a.rVersion.localeCompare(b.rVersion, undefined, { numeric: true, sensitivity: 'base' });
+        };
         qpItems.push(
             {
                 label: PathQuickPickMenu.search,
@@ -101,7 +105,7 @@ export class ExecutableQuickPick implements vscode.Disposable {
             }
         ];
 
-        [...this.service.executables].forEach((v) => {
+        [...this.service.executables].sort(sortExecutables).forEach((v) => {
             const item = new ExecutableQuickPickItem(v, recommendPath(v, this.currentFolder, renvVersion));
             if (item.recommended) {
                 recommendedItems.push(item);
@@ -118,6 +122,8 @@ export class ExecutableQuickPick implements vscode.Disposable {
                 }
             }
         });
+
+
         this.quickpick.items = [...qpItems, ...recommendedItems, ...virtualItems, ...globalItems];
         for (const item of this.quickpick.items) {
             if (item.description === this.service.getWorkspaceExecutable(this.currentFolder?.uri?.fsPath)?.rBin) {
@@ -172,9 +178,10 @@ export class ExecutableQuickPick implements vscode.Disposable {
                                 canSelectMany: false,
                                 title: ' R executable file'
                             };
-                            void vscode.window.showOpenDialog(opts).then((execPath) => {
-                                if (execPath?.[0].fsPath && validateRExecutablePath(execPath[0].fsPath)) {
-                                    const rExec = this.service.executableFactory.create(execPath[0].fsPath);
+                            void vscode.window.showOpenDialog(opts).then((epath) => {
+                                const execPath = path.normalize(epath?.[0].fsPath);
+                                if (execPath && validateRExecutablePath(execPath)) {
+                                    const rExec = this.service.executableFactory.create(execPath);
                                     this.service.setWorkspaceExecutable(this.currentFolder?.uri?.fsPath, rExec);
                                 } else {
                                     void vscode.window.showErrorMessage(ExecutableNotifications.badFolder);