Refactor + simplify executable access

Executables access is now handled purely through the RExecutableManager, rather than any member classes

Author: ElianHugh

src/executables/index.ts

@@ -2,26 +2,23 @@ import path = require('path');
 import * as fs from 'fs-extra';
 import * as vscode from 'vscode';
 
-import { LocatorServiceFactory, AbstractLocatorService } from './locator';
 import { ExecutableStatusItem, ExecutableQuickPick } from './ui';
-import { RExecutableService, WorkspaceExecutableEvent } from './service';
+import { isVirtual, RExecutableService, ExecutableType, WorkspaceExecutableEvent } from './service';
 import { extensionContext } from '../extension';
 import { spawnAsync } from '../util';
-import { RExecutable, VirtualRExecutable } from './executable';
+
+export { ExecutableType as IRExecutable, VirtualExecutableType as IVirtualRExecutable } from './service';
 
 // super class that manages relevant sub classes
-export class RExecutableManager {
-    private retrievalService: AbstractLocatorService;
-    private statusBar: ExecutableStatusItem;
-    private quickPick: ExecutableQuickPick;
-    private executableService: RExecutableService;
+export class RExecutableManager implements vscode.Disposable {
+    private readonly statusBar: ExecutableStatusItem;
+    private readonly quickPick: ExecutableQuickPick;
+    private readonly executableService: RExecutableService;
 
     constructor() {
-        this.retrievalService = LocatorServiceFactory.getLocator();
-        this.retrievalService.refreshPaths();
         this.executableService = new RExecutableService();
         this.statusBar = new ExecutableStatusItem(this.executableService);
-        this.quickPick = new ExecutableQuickPick(this.executableService, this.retrievalService);
+        this.quickPick = new ExecutableQuickPick(this.executableService);
 
         extensionContext.subscriptions.push(
             this.onDidChangeActiveExecutable(() => {
@@ -32,26 +29,35 @@ export class RExecutableManager {
                     this.reload();
                 }
             }),
-            this.executableService,
-            this.statusBar,
-            this.quickPick
+            this
         );
+
         this.reload();
     }
 
-    public get activeExecutable(): RExecutable {
-        return this.executableService.activeExecutable;
+    public dispose(): void {
+        this.executableService.dispose();
+        this.statusBar.dispose();
+        this.quickPick.dispose();
     }
 
     public get executableQuickPick(): ExecutableQuickPick {
         return this.quickPick;
     }
 
-    public get executableStatusItem(): ExecutableStatusItem {
-        return this.statusBar;
+    public get activeExecutablePath(): string {
+        return this.executableService.activeExecutable.rBin;
+    }
+
+    public getExecutablePath(workingDir: string): string {
+        return this.executableService.getWorkspaceExecutable(workingDir).rBin;
+    }
+
+    public get activeExecutable(): ExecutableType {
+        return this.executableService.activeExecutable;
     }
 
-    public get onDidChangeActiveExecutable(): vscode.Event<RExecutable> {
+    public get onDidChangeActiveExecutable(): vscode.Event<ExecutableType> {
         return this.executableService.onDidChangeActiveExecutable;
     }
 
@@ -72,21 +78,23 @@ export class RExecutableManager {
     }
 
     private async activateEnvironment(): Promise<unknown> {
+        if (!isVirtual(this.activeExecutable) ||
+            process.env.CONDA_DEFAULT_ENV !== this.activeExecutable.name) {
+            return Promise.resolve();
+        }
+
         const opts = {
             env: {
                 ...process.env
             },
         };
-        if (this.activeExecutable instanceof VirtualRExecutable && opts.env.CONDA_DEFAULT_ENV !== this.activeExecutable.name) {
-            return spawnAsync(
-                'conda', // hard coded for now
-                this.activeExecutable.activationCommand,
-                opts,
-                undefined
-            );
-        } else {
-            return Promise.resolve();
-        }
+
+        return spawnAsync(
+            'conda', // hard coded for now
+            this.activeExecutable.activationCommand,
+            opts,
+            undefined
+        );
     }
 
 }
@@ -99,8 +107,7 @@ export class RExecutableManager {
  * @param execPath
  * @returns boolean
  */
-export function validateRFolder(execPath: string): boolean {
+export function validateRExecutablePath(execPath: string): boolean {
     const basename = process.platform === 'win32' ? 'R.exe' : 'R';
-    const scriptPath = path.normalize(`${execPath}/../Rcmd`);
-    return fs.existsSync(execPath) && path.basename(basename) && fs.existsSync(scriptPath);
+    return fs.existsSync(execPath) && (path.basename(execPath) === basename);
 }

src/executables/locator/shared.ts

@@ -1,20 +1,38 @@
 import { getRDetailsFromPath } from './locator';
+import { RExecutableRegistry } from './registry';
+
+export type ExecutableType = RExecutable;
+export type VirtualExecutableType = VirtualRExecutable;
+
+export function isVirtual(executable: RExecutable): executable is VirtualRExecutable {
+    return executable instanceof VirtualRExecutable;
+}
 
 export class RExecutableFactory {
-    static createExecutable(executablePath: string): RExecutable {
-        if (new RegExp('\\.conda').exec(executablePath)?.length > 0) {
-            return new VirtualRExecutable(executablePath);
-        } else {
-            return new RExecutable(executablePath);
-        }
+    private readonly registry: RExecutableRegistry;
+
+    constructor(registry: RExecutableRegistry) {
+        this.registry = registry;
     }
 
-    private constructor() {
-        //
+    public create(executablePath: string): ExecutableType {
+        const oldExec = [...this.registry.executables.values()].find((v) => v.rBin === executablePath);
+        if (oldExec) {
+            return oldExec;
+        } else {
+            let executable: RExecutable;
+            if (new RegExp('\\.conda').exec(executablePath)?.length > 0) {
+                executable = new VirtualRExecutable(executablePath);
+            } else {
+                executable = new RExecutable(executablePath);
+            }
+            this.registry.addExecutable(executable);
+            return executable;
+        }
     }
 }
 
-export class RExecutable {
+class RExecutable {
     private _rBin: string;
     private _rVersion: string;
     private _arch: string;
@@ -45,7 +63,7 @@ export class RExecutable {
     }
 }
 
-export class VirtualRExecutable extends RExecutable {
+class VirtualRExecutable extends RExecutable {
     constructor(bin_path: string) {
         super(bin_path);
     }