Windows conda, status bar errors, refactoring

Author: ElianHugh

src/executables/conda.ts

@@ -0,0 +1,85 @@
+
+import { IExecutableDetails } from './service';
+import * as fs from 'fs-extra';
+import * as vscode from 'vscode';
+import path = require('path');
+import { spawn } from 'child_process';
+
+export function environmentIsActive(name: string): boolean {
+    return process.env.CONDA_DEFAULT_ENV === name ||
+    process.env.CONDA_PREFIX === name;
+}
+
+export function getCondaName(executablePath: string): string {
+    return path.basename(path.dirname(getCondaMetaDir(executablePath)));
+}
+
+export function getCondaMetaDir(executablePath: string): string {
+    let envDir: string = executablePath;
+    for (let index = 0; index < 4; index++) {
+        envDir = path.dirname(envDir);
+    }
+    return path.join(envDir, 'conda-meta');
+}
+
+export function getCondaHistoryPath(executablePath: string): string {
+    return path.join(getCondaMetaDir(executablePath), 'history');
+}
+
+export function getCondaActivationScript(executablePath: string): string {
+    const envDir = path.dirname(getCondaMetaDir(executablePath));
+    return path.join(path.dirname(path.dirname(envDir)), 'Scripts', 'activate');
+}
+
+export function isCondaInstallation(executablePath: string): boolean {
+    console.log(getCondaName(executablePath));
+    return fs.existsSync(getCondaMetaDir(executablePath));
+}
+
+export function getRDetailsFromMetaHistory(executablePath: string): IExecutableDetails {
+    try {
+
+        const reg = new RegExp(/([0-9]{2})::r-base-([0-9.]*)/g);
+        const historyContent = fs.readFileSync(getCondaHistoryPath(executablePath))?.toString();
+        const res = reg.exec(historyContent);
+        return {
+            arch: res?.[1] ? `${res[1]}-bit` : '',
+            version: res?.[2] ? res[2] : ''
+        };
+    } catch (error) {
+        return {
+            arch: '',
+            version: ''
+        };
+    }
+
+}
+
+export function activateCondaEnvironment(executablePath: string): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+        try {
+            const opts = {
+                env: process.env,
+                shell: true
+            };
+            const activationPath = (getCondaActivationScript(executablePath));
+            const commands = [
+                activationPath,
+                `conda activate ${getCondaName(executablePath)}`
+            ].join(' & ');
+            const childProc = spawn(
+                commands,
+                undefined,
+                opts
+            );
+            childProc.on('exit', () => resolve(true));
+            childProc.on('error', (err) => {
+                void vscode.window.showErrorMessage(`Error when activating conda environment: ${err.message}`);
+                reject(false);
+            });
+        } catch (error) {
+            void vscode.window.showErrorMessage(`Error when activating conda environment: ${error as string}`);
+            reject(false);
+        }
+    });
+}

src/executables/index.ts

@@ -5,7 +5,7 @@ import * as vscode from 'vscode';
 import { ExecutableStatusItem, ExecutableQuickPick } from './ui';
 import { isVirtual, RExecutableService, ExecutableType, WorkspaceExecutableEvent } from './service';
 import { extensionContext } from '../extension';
-import { spawnAsync } from '../util';
+import { activateCondaEnvironment } from './conda';
 
 export { ExecutableType as IRExecutable, VirtualExecutableType as IVirtualRExecutable } from './service';
 
@@ -81,24 +81,11 @@ export class RExecutableManager implements vscode.Disposable {
     }
 
 
-    private async activateEnvironment(): Promise<unknown> {
-        if (!this.activeExecutable || !isVirtual(this.activeExecutable) ||
-            process.env.CONDA_DEFAULT_ENV !== this.activeExecutable.name) {
-            return Promise.resolve();
+    private async activateEnvironment(): Promise<boolean> {
+        if (!this.activeExecutable || !isVirtual(this.activeExecutable)) {
+            return Promise.resolve(true);
         }
-
-        const opts = {
-            env: {
-                ...process.env
-            },
-        };
-
-        return spawnAsync(
-            'conda', // hard coded for now
-            this.activeExecutable.activationCommand,
-            opts,
-            undefined
-        );
+        return activateCondaEnvironment(this.activeExecutable?.rBin);
     }
 
 }

src/executables/service/class.ts

@@ -1,10 +1,9 @@
+import { getCondaName, getRDetailsFromMetaHistory, isCondaInstallation } from '../conda';
 import { getRDetailsFromPath } from './locator';
 import { RExecutableRegistry } from './registry';
+import { IExecutableDetails, ExecutableType } from './types';
 
-export type ExecutableType = RExecutable;
-export type VirtualExecutableType = VirtualRExecutable;
-
-export function isVirtual(executable: RExecutable): executable is VirtualRExecutable {
+export function isVirtual(executable: AbstractExecutable): executable is VirtualRExecutable {
     return executable instanceof VirtualRExecutable;
 }
 
@@ -16,12 +15,12 @@ export class RExecutableFactory {
     }
 
     public create(executablePath: string): ExecutableType {
-        const oldExec = [...this.registry.executables.values()].find((v) => v.rBin === executablePath);
-        if (oldExec) {
-            return oldExec;
+        const cachedExec = [...this.registry.executables.values()].find((v) => v.rBin === executablePath);
+        if (cachedExec) {
+            return cachedExec;
         } else {
-            let executable: RExecutable;
-            if (new RegExp('\\.conda')?.exec(executablePath)) {
+            let executable: AbstractExecutable;
+            if (isCondaInstallation(executablePath)) {
                 executable = new VirtualRExecutable(executablePath);
             } else {
                 executable = new RExecutable(executablePath);
@@ -32,18 +31,10 @@ export class RExecutableFactory {
     }
 }
 
-class RExecutable {
-    private _rBin: string;
-    private _rVersion: string;
-    private _arch: string;
-
-    constructor(bin_path: string) {
-        const details = getRDetailsFromPath(bin_path);
-        this._rBin = bin_path;
-        this._rVersion = details.version;
-        this._arch = details.arch;
-    }
-
+export abstract class AbstractExecutable {
+    protected _rBin: string;
+    protected _rVersion: string;
+    protected _rArch: string;
     public get rBin(): string {
         return this._rBin;
     }
@@ -53,39 +44,53 @@ class RExecutable {
     }
 
     public get rArch(): string {
-        return this._arch;
+        return this._rArch;
+    }
+    public abstract tooltip: string;
+}
+
+
+export class RExecutable extends AbstractExecutable {
+    constructor(executablePath: string) {
+        super();
+        const details = getRDetailsFromPath(executablePath);
+        this._rBin = executablePath;
+        this._rVersion = details.version;
+        this._rArch = details.arch;
     }
 
     public get tooltip(): string {
-        const versionString = this.rVersion ? ` ${this.rVersion}` : '';
-        const archString = this.rArch ? ` ${this.rArch}` : '';
-        return `R${versionString}${archString}`;
+        if (this.rVersion && this.rArch) {
+            return `R ${this.rVersion} ${this.rArch}`;
+        }
+        return `$(error) R`;
+    }
+
+    protected getDetailsFromPath(execPath: string): IExecutableDetails {
+        return getRDetailsFromPath(execPath);
     }
 }
 
-class VirtualRExecutable extends RExecutable {
+export class VirtualRExecutable extends AbstractExecutable {
     private _name: string;
 
-    constructor(bin_path: string) {
-        super(bin_path);
-        const reg = new RegExp('(?<=\\/envs\\/)(.*?)(?=\\/)');
-        this._name = reg?.exec(this.rBin)?.[0] ?? '';
+    constructor(executablePath: string) {
+        super();
+        this._name = getCondaName(executablePath);
+        const details = getRDetailsFromMetaHistory(executablePath);
+        this._rBin = executablePath;
+        this._rVersion = details?.version ?? '';
+        this._rArch = details?.arch ?? '';
     }
 
     public get name(): string {
         return this._name;
     }
 
     public get tooltip(): string {
-        return `${this.name} (${super.tooltip})`;
-    }
-
-    // todo, hardcoded
-    public get activationCommand(): string[] {
-        if (this.name) {
-            return ['activate', this.name];
-        } else {
-            return ['activate'];
+        if (this.rVersion && this.rArch) {
+            return `${this.name} (R ${this.rVersion} ${this.rArch})`;
         }
+        return `$(error) ${this.name}`;
     }
 }

src/executables/service/index.ts

@@ -1,25 +1,17 @@
 import * as vscode from 'vscode';
 
 import { validateRExecutablePath } from '..';
-import { ExecutableType, RExecutableFactory } from './class';
+import { RExecutableFactory } from './class';
 import { config, getCurrentWorkspaceFolder, getRPathConfigEntry } from '../../util';
 import { RExecutablePathStorage } from './pathStorage';
 import { RExecutableRegistry } from './registry';
 import { AbstractLocatorService, LocatorServiceFactory } from './locator';
 import { getRenvVersion } from './renv';
+import { ExecutableType, WorkspaceExecutableEvent } from './types';
 
+export * from './types';
 export * from './class';
 
-/**
- * @description
- * @export
- * @interface WorkspaceExecutableEvent
- */
-export interface WorkspaceExecutableEvent {
-    workingFolder: vscode.WorkspaceFolder | undefined,
-    executable: ExecutableType | undefined
-}
-
 /**
  * @description
  * @export
@@ -49,7 +41,7 @@ export class RExecutableService implements vscode.Disposable {
         this.workspaceExecutables = new Map<string, ExecutableType>();
         this.executableEmitter = new vscode.EventEmitter<ExecutableType>();
         this.workspaceEmitter = new vscode.EventEmitter<WorkspaceExecutableEvent>();
-        this.executablePathLocator.binaryPaths.forEach((path) => {
+        this.executablePathLocator.executablePaths.forEach((path) => {
             this.executableFactory.create(path);
         });
 

src/executables/service/locator/shared.ts

@@ -59,14 +59,14 @@ export function getUniquePaths(paths: string[]): string[] {
 }
 
 export abstract class AbstractLocatorService {
-    protected _binaryPaths: string[];
+    protected _executablePaths: string[];
     protected emitter: vscode.EventEmitter<string[]>;
     public abstract refreshPaths(): Promise<void>;
     public get hasPaths(): boolean {
-        return this._binaryPaths.length > 0;
+        return this._executablePaths.length > 0;
     }
-    public get binaryPaths(): string[] {
-        return this._binaryPaths;
+    public get executablePaths(): string[] {
+        return this._executablePaths;
     }
     public get onDidRefreshPaths(): vscode.Event<string[]> {
         return this.emitter.event;