R --version & reduced process creation

- Use R --version for details
- Only create executables when calling refreshPaths()

Author: ElianHugh

src/executables/executable.ts

@@ -1,4 +1,4 @@
-import { getVersionFromPath, getArchitectureFromPath } from './locator';
+import { getRDetailsFromPath } from './locator';
 
 export class RExecutableFactory {
     static createExecutable(executablePath: string): RExecutable {
@@ -20,9 +20,10 @@ export class RExecutable {
     private _arch: string;
 
     constructor(bin_path: string) {
+        const details = getRDetailsFromPath(bin_path);
         this._rBin = bin_path;
-        this._rVersion = getVersionFromPath(bin_path);
-        this._arch = getArchitectureFromPath(bin_path);
+        this._rVersion = details.version;
+        this._arch = details.arch;
     }
 
     public get rBin(): string {

src/executables/locator/shared.ts

@@ -1,36 +1,26 @@
-import path = require('path');
-import * as fs from 'fs-extra';
+import { execSync } from 'child_process';
+import { RExecutable } from '../executable';
 
-export function getVersionFromPath(rPath: string): string {
-    if (process.platform === 'win32') {
-        // not sure how to do this
-        return '';
-    } else {
-        try {
-            const scriptPath = path.normalize(`${rPath}/../Rcmd`);
-            const rCmdFile = fs.readFileSync(scriptPath, 'utf-8');
-            const regex = /(?<=R_VERSION=)[0-9.]*/g;
-            const version = regex.exec(rCmdFile)?.[0];
-            return version ?? '';
-        } catch (error) {
-            return '';
-        }
-    }
-}
-
-export function getArchitectureFromPath(path: string): string {
-    if (process.platform === 'win32') {
-        // \\bin\\i386 = 32bit
-        // \\bin\\x64 = 64bit
-        return '';
-    } else {
-        return '64-bit';
+export function getRDetailsFromPath(rPath: string): {version: string, arch: string} {
+    try {
+        const child = execSync(`${rPath} --version`).toString();
+        const versionRegex = /(?<=R version\s)[0-9.]*/g;
+        const archRegex = /[0-9]*-bit/g;
+        const out = {
+            version: child.match(versionRegex)?.[0] ?? '',
+            arch: child.match(archRegex)?.[0] ?? ''
+        };
+        return out;
+    } catch (error) {
+        return { version: '', arch: '' };
     }
 }
 
 export abstract class AbstractLocatorService {
-    protected binary_paths: string[];
-    public abstract get hasBinaries(): boolean;
-    public abstract get binaries(): string[];
+    protected _binaryPaths: string[];
+    protected _executables: RExecutable[];
+    public abstract get hasExecutables(): boolean;
+    public abstract get executables(): RExecutable[];
+    public abstract get binaryPaths(): string[];
     public abstract refreshPaths(): void;
 }

src/executables/locator/unix.ts

@@ -1,38 +1,53 @@
 import * as fs from 'fs-extra';
 import * as os from 'os';
 import path = require('path');
+import { RExecutable, RExecutableFactory } from '../executable';
 
 import { AbstractLocatorService } from './shared';
 
 export class UnixExecLocator extends AbstractLocatorService {
-    public get hasBinaries(): boolean {
-        return this.binary_paths.length > 0;
+    constructor() {
+        super();
+        this._binaryPaths = [];
+        this._executables = [];
     }
-    public get binaries(): string[] {
-        return this.binary_paths;
+    public get hasExecutables(): boolean {
+        return this._executables.length > 0;
+    }
+    public get executables(): RExecutable[] {
+        return this._executables;
+    }
+    public get binaryPaths(): string[] {
+        return this._binaryPaths;
     }
     public refreshPaths(): void {
-        this.binary_paths = Array.from(
+        const paths = Array.from(
             new Set([
                 ...this.getHomeFromDirs(),
                 ...this.getHomeFromEnv(),
                 ... this.getHomeFromConda()
             ])
         );
+        for (const path of paths) {
+            if (!this._binaryPaths?.includes(path)) {
+                this._binaryPaths.push(path);
+                this._executables.push(RExecutableFactory.createExecutable(path));
+            }
+        }
     }
 
-    private potential_bin_paths: string[] = [
-        '/usr/lib64/R/bin/R',
-        '/usr/lib/R/bin/R',
-        '/usr/local/lib64/R/bin/R',
-        '/usr/local/lib/R/bin/R',
-        '/opt/local/lib64/R/bin/R',
-        '/opt/local/lib/R/bin/R'
-    ];
-
     private getHomeFromDirs(): string[] {
         const dirBins: string[] = [];
-        for (const bin of this.potential_bin_paths) {
+        const potentialPaths: string[] = [
+            '/usr/lib64/R/bin/R',
+            '/usr/lib/R/bin/R',
+            '/usr/local/lib64/R/bin/R',
+            '/usr/local/lib/R/bin/R',
+            '/opt/local/lib64/R/bin/R',
+            '/opt/local/lib/R/bin/R'
+        ];
+
+        for (const bin of potentialPaths) {
             if (fs.existsSync(bin)) {
                 dirBins.push(bin);
             }

src/executables/locator/windows.ts

@@ -1,33 +1,42 @@
 import * as fs from 'fs-extra';
-import * as os from 'os';
 import path = require('path');
 import winreg = require('winreg');
+import { RExecutable, RExecutableFactory } from '../executable';
 
 import { AbstractLocatorService } from './shared';
 
 export class WindowsExecLocator extends AbstractLocatorService {
-    public get hasBinaries(): boolean {
-        return this.binary_paths.length > 0;
+    constructor() {
+        super();
+        this._binaryPaths = [];
+        this._executables = [];
     }
-    public get binaries(): string[] {
-        return this.binary_paths;
+    public get hasExecutables(): boolean {
+        return this._executables.length > 0;
+    }
+    public get executables(): RExecutable[] {
+        return this._executables;
+    }
+    public get binaryPaths(): string[] {
+        return this._binaryPaths;
     }
     public refreshPaths(): void {
-        this.binary_paths = Array.from(
+        const paths = Array.from(
             new Set([
                 ...this.getHomeFromDirs(),
                 ...this.getHomeFromEnv(),
                 ...this.getHomeFromRegistry(),
                 // ... this.getHomeFromConda()
             ])
         );
+        for (const path of paths) {
+            if (!this._binaryPaths?.includes(path)) {
+                this._binaryPaths.push(path);
+                this._executables.push(RExecutableFactory.createExecutable(path));
+            }
+        }
     }
 
-    private potential_bin_paths: string[] = [
-        '%ProgramFiles%\\R\\',
-        '%ProgramFiles(x86)%\\R\\'
-    ];
-
     private getHomeFromRegistry(): string[] {
         const registryBins: string[] = [];
         const potentialBins = [
@@ -68,7 +77,11 @@ export class WindowsExecLocator extends AbstractLocatorService {
 
     private getHomeFromDirs(): string[] {
         const dirBins: string[] = [];
-        for (const bin of this.potential_bin_paths) {
+        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\\`;

src/executables/ui/quickpick.ts

@@ -84,10 +84,9 @@ export class ExecutableQuickPick implements vscode.Disposable {
             }
         );
 
-        this.retriever.binaries.forEach(home => {
+        this.retriever.binaryPaths.forEach(home => {
             if (validateRFolder(home)) {
-                const inst = RExecutableFactory.createExecutable(home);
-                executables.push(inst);
+                executables.push(this.retriever.executables.filter(exec => exec.rBin === home)?.[0]);
             }
         });
         sortBins(executables).forEach((bin: RExecutable) => {
@@ -119,6 +118,7 @@ export class ExecutableQuickPick implements vscode.Disposable {
         function setupQuickpickListeners(self: ExecutableQuickPick, resolver: () => void): void {
             self.qp.onDidTriggerButton((item: vscode.QuickInputButton) => {
                 if (item.tooltip === 'Refresh paths') {
+                    self.retriever.refreshPaths();
                     self.setItems();
                     self.qp.show();
                 } else {