Bug fixes and API tweaks (#25)

Fixes #26

Author: karthiknadig

src/api.ts

@@ -1,4 +1,14 @@
-import { Uri, Disposable, MarkdownString, Event, LogOutputChannel, ThemeIcon, Terminal, TaskExecution } from 'vscode';
+import {
+    Uri,
+    Disposable,
+    MarkdownString,
+    Event,
+    LogOutputChannel,
+    ThemeIcon,
+    Terminal,
+    TaskExecution,
+    TerminalOptions,
+} from 'vscode';
 
 /**
  * The path to an icon, or a theme-specific configuration of icons.
@@ -954,7 +964,7 @@ export interface PythonPackageManagementApi {
      * @param packages The packages to install.
      * @param options Options for installing packages.
      */
-    installPackages(environment: PythonEnvironment, packages: string[], options: PackageInstallOptions): Promise<void>;
+    installPackages(environment: PythonEnvironment, packages: string[], options?: PackageInstallOptions): Promise<void>;
 
     /**
      * Uninstall packages from a Python Environment.
@@ -1027,25 +1037,27 @@ export interface PythonProjectModifyApi {
  */
 export interface PythonProjectApi extends PythonProjectCreationApi, PythonProjectGetterApi, PythonProjectModifyApi {}
 
+export interface PythonTerminalOptions extends TerminalOptions {
+    /**
+     * Whether to show the terminal.
+     */
+    disableActivation?: boolean;
+}
+
 export interface PythonTerminalCreateApi {
-    createTerminal(
-        environment: PythonEnvironment,
-        cwd: string | Uri,
-        envVars?: { [key: string]: string },
-    ): Promise<Terminal>;
+    createTerminal(environment: PythonEnvironment, options: PythonTerminalOptions): Promise<Terminal>;
 }
 
 export interface PythonTerminalExecutionOptions {
     cwd: string | Uri;
     args?: string[];
-
     show?: boolean;
 }
 
 export interface PythonTerminalRunApi {
     runInTerminal(environment: PythonEnvironment, options: PythonTerminalExecutionOptions): Promise<Terminal>;
     runInDedicatedTerminal(
-        terminalKey: Uri,
+        terminalKey: Uri | string,
         environment: PythonEnvironment,
         options: PythonTerminalExecutionOptions,
     ): Promise<Terminal>;
@@ -1082,7 +1094,7 @@ export interface PythonTaskRunApi {
 export interface PythonBackgroundRunOptions {
     args: string[];
     cwd?: string;
-    env?: { [key: string]: string };
+    env?: { [key: string]: string | undefined };
 }
 export interface PythonBackgroundRunApi {
     runInBackground(environment: PythonEnvironment, options: PythonBackgroundRunOptions): Promise<PythonProcess>;

src/common/pickers/projects.ts

@@ -1,7 +1,7 @@
 import path from 'path';
 import { QuickPickItem } from 'vscode';
 import { PythonProject } from '../../api';
-import { showQuickPick } from '../window.apis';
+import { showQuickPick, showQuickPickWithButtons } from '../window.apis';
 
 interface ProjectQuickPickItem extends QuickPickItem {
     project: PythonProject;
@@ -27,17 +27,21 @@ export async function pickProject(projects: ReadonlyArray<PythonProject>): Promi
     return undefined;
 }
 
-export async function pickProjectMany(projects: ReadonlyArray<PythonProject>): Promise<PythonProject[] | undefined> {
+export async function pickProjectMany(
+    projects: readonly PythonProject[],
+    showBackButton?: boolean,
+): Promise<PythonProject[] | undefined> {
     if (projects.length > 1) {
         const items: ProjectQuickPickItem[] = projects.map((pw) => ({
             label: path.basename(pw.uri.fsPath),
             description: pw.uri.fsPath,
             project: pw,
         }));
-        const item = await showQuickPick(items, {
+        const item = await showQuickPickWithButtons(items, {
             placeHolder: 'Select a project, folder or script',
             ignoreFocusOut: true,
             canPickMany: true,
+            showBackButton: showBackButton,
         });
         if (Array.isArray(item)) {
             return item.map((p) => p.project);

src/extension.ts

@@ -1,7 +1,7 @@
 import { commands, ExtensionContext, LogOutputChannel } from 'vscode';
 
 import { PythonEnvironmentManagers } from './features/envManagers';
-import { registerLogger } from './common/logging';
+import { registerLogger, traceInfo } from './common/logging';
 import { EnvManagerView } from './features/views/envManagersView';
 import {
     addPythonProject,
@@ -120,18 +120,10 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
             await handlePackagesCommand(packageManager, environment);
         }),
         commands.registerCommand('python-envs.set', async (item) => {
-            const result = await setEnvironmentCommand(item, envManagers, projectManager);
-            if (result) {
-                workspaceView.updateProject();
-                await updateActivateMenuButtonContext(terminalManager, projectManager, envManagers);
-            }
+            await setEnvironmentCommand(item, envManagers, projectManager);
         }),
         commands.registerCommand('python-envs.setEnv', async (item) => {
-            const result = await setEnvironmentCommand(item, envManagers, projectManager);
-            if (result) {
-                workspaceView.updateProject();
-                await updateActivateMenuButtonContext(terminalManager, projectManager, envManagers);
-            }
+            await setEnvironmentCommand(item, envManagers, projectManager);
         }),
         commands.registerCommand('python-envs.reset', async (item) => {
             await resetEnvironmentCommand(item, envManagers, projectManager);
@@ -194,9 +186,19 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
             updateViewsAndStatus(statusBar, workspaceView, managerView, api);
         }),
         envManagers.onDidChangeEnvironment(async () => {
+            await updateActivateMenuButtonContext(terminalManager, projectManager, envManagers);
             updateViewsAndStatus(statusBar, workspaceView, managerView, api);
         }),
         envManagers.onDidChangeEnvironments(async () => {
+            await updateActivateMenuButtonContext(terminalManager, projectManager, envManagers);
+            updateViewsAndStatus(statusBar, workspaceView, managerView, api);
+        }),
+        envManagers.onDidChangeEnvironmentFiltered(async (e) => {
+            const location = e.uri?.fsPath ?? 'global';
+            traceInfo(
+                `Internal: Changed environment from ${e.old?.displayName} to ${e.new?.displayName} for: ${location}`,
+            );
+            await updateActivateMenuButtonContext(terminalManager, projectManager, envManagers);
             updateViewsAndStatus(statusBar, workspaceView, managerView, api);
         }),
     );

src/features/envCommands.ts

@@ -17,8 +17,6 @@ import {
     getDefaultEnvManagerSetting,
     getDefaultPkgManagerSetting,
     EditProjectSettings,
-    setAllManagerSettings,
-    EditAllManagerSettings,
 } from './settings/settingHelpers';
 
 import { getAbsolutePath } from '../common/utils/fileNameUtils';
@@ -168,95 +166,62 @@ export async function handlePackagesCommand(
     }
 }
 
-export interface EnvironmentSetResult {
-    project?: PythonProject;
-    environment: PythonEnvironment;
-}
-
 export async function setEnvironmentCommand(
     context: unknown,
     em: EnvironmentManagers,
     wm: PythonProjectManager,
-): Promise<EnvironmentSetResult[] | undefined> {
+): Promise<void> {
     if (context instanceof PythonEnvTreeItem) {
-        const view = context as PythonEnvTreeItem;
-        const manager = view.parent.manager;
-        const projects = await pickProjectMany(wm.getProjects());
-        if (projects && projects.length > 0) {
-            await Promise.all(projects.map((p) => manager.set(p.uri, view.environment)));
-            await setAllManagerSettings(
-                projects.map((p) => ({
-                    project: p,
-                    envManager: manager.id,
-                    packageManager: manager.preferredPackageManagerId,
-                })),
-            );
-            return projects.map((p) => ({ project: p, environment: view.environment }));
+        try {
+            const view = context as PythonEnvTreeItem;
+            const projects = await pickProjectMany(wm.getProjects());
+            if (projects && projects.length > 0) {
+                const uris = projects.map((p) => p.uri);
+                await em.setEnvironments(uris, view.environment);
+            }
+        } catch (ex) {
+            if (ex === QuickInputButtons.Back) {
+                await setEnvironmentCommand(context, em, wm);
+            }
+            throw ex;
         }
-        return;
     } else if (context instanceof ProjectItem) {
         const view = context as ProjectItem;
-        return setEnvironmentCommand([view.project.uri], em, wm);
+        await setEnvironmentCommand([view.project.uri], em, wm);
     } else if (context instanceof Uri) {
-        return setEnvironmentCommand([context], em, wm);
+        await setEnvironmentCommand([context], em, wm);
     } else if (context === undefined) {
-        const project = await pickProjectMany(wm.getProjects());
-        if (project && project.length > 0) {
-            try {
-                const result = setEnvironmentCommand(project, em, wm);
-                return result;
-            } catch (ex) {
-                if (ex === QuickInputButtons.Back) {
-                    return setEnvironmentCommand(context, em, wm);
-                }
+        try {
+            const projects = await pickProjectMany(wm.getProjects());
+            if (projects && projects.length > 0) {
+                const uris = projects.map((p) => p.uri);
+                await setEnvironmentCommand(uris, em, wm);
+            }
+        } catch (ex) {
+            if (ex === QuickInputButtons.Back) {
+                await setEnvironmentCommand(context, em, wm);
             }
+            throw ex;
         }
-        return;
     } else if (Array.isArray(context) && context.length > 0 && context.every((c) => c instanceof Uri)) {
         const uris = context as Uri[];
-        const projects: PythonProject[] = [];
-        const projectEnvManagers: InternalEnvironmentManager[] = [];
-        uris.forEach((uri) => {
-            const project = wm.get(uri);
-            if (project) {
-                projects.push(project);
-                const manager = em.getEnvironmentManager(uri);
-                if (manager && !projectEnvManagers.includes(manager)) {
-                    projectEnvManagers.push(manager);
-                }
-            }
-        });
-
+        const projects = wm.getProjects(uris).map((p) => p);
+        const projectEnvManagers = em.getProjectEnvManagers(uris);
         const recommended =
             projectEnvManagers.length === 1 && uris.length === 1 ? await projectEnvManagers[0].get(uris[0]) : undefined;
         const selected = await pickEnvironment(em.managers, projectEnvManagers, {
             projects,
             recommended,
             showBackButton: uris.length > 1,
         });
-        const manager = em.managers.find((m) => m.id === selected?.envId.managerId);
-        if (selected && manager) {
-            const promises: Thenable<void>[] = [];
-            const settings: EditAllManagerSettings[] = [];
-            uris.forEach((uri) => {
-                const m = em.getEnvironmentManager(uri);
-                promises.push(manager.set(uri, selected));
-                if (manager.id !== m?.id) {
-                    settings.push({
-                        project: wm.get(uri),
-                        envManager: manager.id,
-                        packageManager: manager.preferredPackageManagerId,
-                    });
-                }
-            });
-            await Promise.all(promises);
-            await setAllManagerSettings(settings);
-            return projects.map((p) => ({ project: p, environment: selected }));
+
+        if (selected) {
+            await em.setEnvironments(uris, selected);
         }
-        return;
+    } else {
+        traceError(`Invalid context for setting environment command: ${context}`);
+        window.showErrorMessage('Invalid context for setting environment');
     }
-    traceError(`Invalid context for setting environment command: ${context}`);
-    window.showErrorMessage('Invalid context for setting environment');
 }
 
 export async function resetEnvironmentCommand(
@@ -338,9 +303,17 @@ export async function addPythonProject(
             return;
         }
 
-        let results = await creator.create();
-        if (results === undefined) {
-            return;
+        let results: PythonProject | PythonProject[] | undefined;
+        try {
+            results = await creator.create();
+            if (results === undefined) {
+                return;
+            }
+        } catch (ex: any) {
+            if (ex === QuickInputButtons.Back) {
+                return addPythonProject(resource, wm, em, pc);
+            }
+            throw ex;
         }
 
         if (!Array.isArray(results)) {
@@ -435,21 +408,21 @@ export async function createTerminalCommand(
         const env = await api.getEnvironment(uri);
         const pw = api.getPythonProject(uri);
         if (env && pw) {
-            return await tm.create(env, pw.uri);
+            return await tm.create(env, { cwd: pw.uri });
         }
     } else if (context instanceof ProjectItem) {
         const view = context as ProjectItem;
         const env = await api.getEnvironment(view.project.uri);
         if (env) {
-            const terminal = await tm.create(env, view.project.uri);
+            const terminal = await tm.create(env, { cwd: view.project.uri });
             terminal.show();
             return terminal;
         }
     } else if (context instanceof PythonEnvTreeItem) {
         const view = context as PythonEnvTreeItem;
         const pw = await pickProject(api.getPythonProjects());
         if (pw) {
-            const terminal = await tm.create(view.environment, pw.uri);
+            const terminal = await tm.create(view.environment, { cwd: pw.uri });
             terminal.show();
             return terminal;
         }