feat: Add copy path to Project and Environments (#170)

Closes
#166

Author: karthiknadig

package.json

@@ -218,6 +218,18 @@
                 "title": "%python-envs.uninstallPackage.title%",
                 "category": "Python Envs",
                 "icon": "$(trash)"
+            },
+            {
+                "command": "python-envs.copyEnvPath",
+                "title": "%python-envs.copyEnvPath.title%",
+                "category": "Python Envs",
+                "icon": "$(copy)"
+            },
+            {
+                "command": "python-envs.copyProjectPath",
+                "title": "%python-envs.copyProjectPath.title%",
+                "category": "Python Envs",
+                "icon": "$(copy)"
             }
         ],
         "menus": {
@@ -285,6 +297,14 @@
                 {
                     "command": "python-envs.uninstallPackage",
                     "when": "false"
+                },
+                {
+                    "command": "python-envs.copyEnvPath",
+                    "when": "false"
+                },
+                {
+                    "command": "python-envs.copyProjectPath",
+                    "when": "false"
                 }
             ],
             "view/item/context": [
@@ -322,6 +342,11 @@
                     "group": "inline",
                     "when": "view == env-managers && viewItem =~ /.*pythonEnvironment.*/"
                 },
+                {
+                    "command": "python-envs.copyEnvPath",
+                    "group": "inline",
+                    "when": "view == env-managers && viewItem =~ /.*pythonEnvironment.*/"
+                },
                 {
                     "command": "python-envs.uninstallPackage",
                     "group": "inline",
@@ -332,6 +357,11 @@
                     "group": "inline",
                     "when": "view == python-projects && viewItem == python-env"
                 },
+                {
+                    "command": "python-envs.copyEnvPath",
+                    "group": "inline",
+                    "when": "view == python-projects && viewItem == python-env"
+                },
                 {
                     "command": "python-envs.refreshPackages",
                     "group": "inline",
@@ -355,6 +385,11 @@
                     "group": "inline",
                     "when": "view == python-projects && viewItem =~ /.*python-workspace.*/"
                 },
+                {
+                    "command": "python-envs.copyProjectPath",
+                    "group": "inline",
+                    "when": "view == python-projects && viewItem =~ /.*python-workspace.*/"
+                },
                 {
                     "command": "python-envs.uninstallPackage",
                     "group": "inline",

package.nls.json

@@ -10,6 +10,8 @@
     "python-envs.setPkgManager.title": "Set Package Manager",
     "python-envs.addPythonProject.title": "Add Python Project",
     "python-envs.removePythonProject.title": "Remove Python Project",
+    "python-envs.copyEnvPath.title": "Copy Environment Path",
+    "python-envs.copyProjectPath.title": "Copy Project Path",
     "python-envs.create.title": "Create Environment",
     "python-envs.createAny.title": "Create Environment",
     "python-envs.set.title": "Set Workspace Environment",

src/common/env.apis.ts

@@ -3,3 +3,7 @@ import { env, Uri } from 'vscode';
 export function launchBrowser(uri: string | Uri): Thenable<boolean> {
     return env.openExternal(uri instanceof Uri ? uri : Uri.parse(uri));
 }
+
+export function clipboardWriteText(text: string): Thenable<void> {
+    return env.clipboard.writeText(text);
+}

src/extension.ts

@@ -22,6 +22,7 @@ import {
     createAnyEnvironmentCommand,
     runInDedicatedTerminalCommand,
     handlePackageUninstall,
+    copyPathToClipboard,
 } from './features/envCommands';
 import { registerCondaFeatures } from './managers/conda/main';
 import { registerSystemPythonFeatures } from './managers/builtin/main';
@@ -179,6 +180,12 @@ export async function activate(context: ExtensionContext): Promise<PythonEnviron
         commands.registerCommand('python-envs.createTerminal', (item) => {
             return createTerminalCommand(item, api, terminalManager);
         }),
+        commands.registerCommand('python-envs.copyEnvPath', async (item) => {
+            await copyPathToClipboard(item);
+        }),
+        commands.registerCommand('python-envs.copyProjectPath', async (item) => {
+            await copyPathToClipboard(item);
+        }),
         commands.registerCommand('python-envs.terminal.activate', async () => {
             const terminal = activeTerminal();
             if (terminal) {

src/features/envCommands.ts

@@ -1,4 +1,4 @@
-import { QuickInputButtons, TaskExecution, TaskRevealKind, Terminal, Uri, window } from 'vscode';
+import { QuickInputButtons, TaskExecution, TaskRevealKind, Terminal, Uri } from 'vscode';
 import {
     EnvironmentManagers,
     InternalEnvironmentManager,
@@ -40,6 +40,10 @@ import { pickPackageOptions } from '../common/pickers/packages';
 import { pickProject, pickProjectMany } from '../common/pickers/projects';
 import { TerminalManager } from './terminal/terminalManager';
 import { runInTerminal } from './terminal/runInTerminal';
+import { quoteArgs } from './execution/execUtils';
+import { showErrorMessage } from '../common/errors/utils';
+import { activeTextEditor } from '../common/window.apis';
+import { clipboardWriteText } from '../common/env.apis';
 
 export async function refreshManagerCommand(context: unknown): Promise<void> {
     if (context instanceof EnvManagerTreeItem) {
@@ -278,7 +282,7 @@ export async function setEnvironmentCommand(
         }
     } else {
         traceError(`Invalid context for setting environment command: ${context}`);
-        window.showErrorMessage('Invalid context for setting environment');
+        showErrorMessage('Invalid context for setting environment');
     }
 }
 
@@ -296,7 +300,7 @@ export async function resetEnvironmentCommand(
         if (manager) {
             manager.set(uri, undefined);
         } else {
-            window.showErrorMessage(`No environment manager found for: ${uri.fsPath}`);
+            showErrorMessage(`No environment manager found for: ${uri.fsPath}`);
             traceError(`No environment manager found for ${uri.fsPath}`);
         }
         return;
@@ -308,7 +312,7 @@ export async function resetEnvironmentCommand(
         return;
     }
     traceError(`Invalid context for unset environment command: ${context}`);
-    window.showErrorMessage('Invalid context for unset environment');
+    showErrorMessage('Invalid context for unset environment');
 }
 
 export async function setEnvManagerCommand(em: EnvironmentManagers, wm: PythonProjectManager): Promise<void> {
@@ -338,7 +342,7 @@ export async function addPythonProject(
     pc: ProjectCreators,
 ): Promise<PythonProject | PythonProject[] | undefined> {
     if (wm.getProjects().length === 0) {
-        window.showErrorMessage('Please open a folder/project before adding a workspace');
+        showErrorMessage('Please open a folder/project before adding a workspace');
         return;
     }
 
@@ -554,9 +558,24 @@ export async function runAsTaskCommand(item: unknown, api: PythonEnvironmentApi)
             );
         }
     } else if (item === undefined) {
-        const uri = window.activeTextEditor?.document.uri;
+        const uri = activeTextEditor()?.document.uri;
         if (uri) {
             return runAsTaskCommand(uri, api);
         }
     }
 }
+
+export async function copyPathToClipboard(item: unknown): Promise<void> {
+    if (item instanceof ProjectItem) {
+        const projectPath = item.project.uri.fsPath;
+        await clipboardWriteText(projectPath);
+        traceInfo(`Copied project path to clipboard: ${projectPath}`);
+    } else if (item instanceof ProjectEnvironment || item instanceof PythonEnvTreeItem) {
+        const run = item.environment.execInfo.activatedRun ?? item.environment.execInfo.run;
+        const envPath = quoteArgs([run.executable, ...(run.args ?? [])]).join(' ');
+        await clipboardWriteText(envPath);
+        traceInfo(`Copied environment path to clipboard: ${envPath}`);
+    } else {
+        traceVerbose(`Invalid context for copy path to clipboard: ${item}`);
+    }
+}

src/test/features/commands/copyPathToClipboard.unit.test.ts

@@ -0,0 +1,68 @@
+import * as sinon from 'sinon';
+import * as envApis from '../../../common/env.apis';
+import { copyPathToClipboard } from '../../../features/envCommands';
+import {
+    ProjectItem,
+    ProjectEnvironment,
+    PythonEnvTreeItem,
+    EnvManagerTreeItem,
+} from '../../../features/views/treeViewItems';
+import { Uri } from 'vscode';
+import { PythonEnvironment } from '../../../api';
+import { InternalEnvironmentManager } from '../../../internal.api';
+
+suite('Copy Path To Clipboard', () => {
+    let clipboardWriteTextStub: sinon.SinonStub;
+
+    setup(() => {
+        clipboardWriteTextStub = sinon.stub(envApis, 'clipboardWriteText');
+        clipboardWriteTextStub.resolves();
+    });
+
+    teardown(() => {
+        sinon.restore();
+    });
+
+    test('Copy project path to clipboard', async () => {
+        const uri = Uri.file('/test');
+        const item = new ProjectItem({ name: 'test', uri });
+        await copyPathToClipboard(item);
+
+        sinon.assert.calledOnce(clipboardWriteTextStub);
+        sinon.assert.calledWith(clipboardWriteTextStub, uri.fsPath);
+    });
+
+    test('Copy env path to clipboard: project view', async () => {
+        const uri = Uri.file('/test');
+        const item = new ProjectEnvironment(new ProjectItem({ name: 'test', uri }), {
+            envId: { managerId: 'test-manager', id: 'env1' },
+            name: 'env1',
+            displayName: 'Environment 1',
+            displayPath: '/test-env',
+            execInfo: { run: { executable: '/test-env/bin/test', args: ['-m', 'env'] } },
+        } as PythonEnvironment);
+
+        await copyPathToClipboard(item);
+
+        sinon.assert.calledOnce(clipboardWriteTextStub);
+        sinon.assert.calledWith(clipboardWriteTextStub, '/test-env/bin/test -m env');
+    });
+
+    test('Copy env path to clipboard: env manager view', async () => {
+        const item = new PythonEnvTreeItem(
+            {
+                envId: { managerId: 'test-manager', id: 'env1' },
+                name: 'env1',
+                displayName: 'Environment 1',
+                displayPath: '/test-env',
+                execInfo: { run: { executable: '/test-env/bin/test', args: ['-m', 'env'] } },
+            } as PythonEnvironment,
+            new EnvManagerTreeItem({ name: 'test-manager', id: 'test-manager' } as InternalEnvironmentManager),
+        );
+
+        await copyPathToClipboard(item);
+
+        sinon.assert.calledOnce(clipboardWriteTextStub);
+        sinon.assert.calledWith(clipboardWriteTextStub, '/test-env/bin/test -m env');
+    });
+});