Auto activation of environment in new terminals

news/1 Enhancements/1387.md

@@ -0,0 +1 @@
+Auto activate Python Environment in terminals.

src/client/common/application/terminalManager.ts

@@ -10,6 +10,9 @@ export class TerminalManager implements ITerminalManager {
     public get onDidCloseTerminal(): Event<Terminal> {
         return window.onDidCloseTerminal;
     }
+    public get onDidOpenTerminal(): Event<Terminal> {
+        return window.onDidOpenTerminal;
+    }
     public createTerminal(options: TerminalOptions): Terminal {
         return window.createTerminal(options);
     }

src/client/common/application/types.ts

@@ -571,6 +571,11 @@ export interface ITerminalManager {
      * An [event](#Event) which fires when a terminal is disposed.
      */
     readonly onDidCloseTerminal: Event<Terminal>;
+    /**
+     * An [event](#Event) which fires when a terminal has been created, either through the
+     * [createTerminal](#window.createTerminal) API or commands.
+     */
+    readonly onDidOpenTerminal: Event<Terminal>;
     /**
      * Creates a [Terminal](#Terminal). The cwd of the terminal will be the workspace directory
      * if it exists, regardless of whether an explicit customStartPath setting exists.

src/client/common/terminal/factory.ts

@@ -12,7 +12,7 @@ import { ITerminalService, ITerminalServiceFactory } from './types';
 export class TerminalServiceFactory implements ITerminalServiceFactory {
     private terminalServices: Map<string, ITerminalService>;
 
-    constructor( @inject(IServiceContainer) private serviceContainer: IServiceContainer) {
+    constructor(@inject(IServiceContainer) private serviceContainer: IServiceContainer) {
 
         this.terminalServices = new Map<string, ITerminalService>();
     }

src/client/common/terminal/helper.ts

@@ -3,6 +3,7 @@
 
 import { inject, injectable } from 'inversify';
 import { Terminal, Uri } from 'vscode';
+import { sleep } from '../../../utils/async';
 import { ICondaService } from '../../interpreter/contracts';
 import { IServiceContainer } from '../../ioc/types';
 import { ITerminalManager, IWorkspaceService } from '../application/types';
@@ -29,9 +30,11 @@ const IS_TCSHELL = /(tcsh$)/i;
 @injectable()
 export class TerminalHelper implements ITerminalHelper {
     private readonly detectableShells: Map<TerminalShellType, RegExp>;
+    private readonly activatedTerminals: Set<Terminal>;
     constructor(@inject(IServiceContainer) private serviceContainer: IServiceContainer) {
 
         this.detectableShells = new Map<TerminalShellType, RegExp>();
+        this.activatedTerminals = new Set<Terminal>();
         this.detectableShells.set(TerminalShellType.powershell, IS_POWERSHELL);
         this.detectableShells.set(TerminalShellType.gitbash, IS_GITBASH);
         this.detectableShells.set(TerminalShellType.bash, IS_BASH);
@@ -108,4 +111,26 @@ export class TerminalHelper implements ITerminalHelper {
             }
         }
     }
+
+    public async activateEnvironmentInTerminal(terminal: Terminal, preserveFocus: boolean = true, resource?: Uri) {
+        if (this.activatedTerminals.has(terminal)) {
+            return;
+        }
+        this.activatedTerminals.add(terminal);
+        const shellPath = this.getTerminalShellPath();
+        const terminalShellType = !shellPath || shellPath.length === 0 ? TerminalShellType.other : this.identifyTerminalShell(shellPath);
+
+        const activationCommamnds = await this.getEnvironmentActivationCommands(terminalShellType, resource);
+        if (activationCommamnds) {
+            for (const command of activationCommamnds!) {
+                terminal.show(preserveFocus);
+                terminal.sendText(command);
+
+                // Give the command some time to complete.
+                // Its been observed that sending commands too early will strip some text off in VS Terminal.
+                const delay = (terminalShellType === TerminalShellType.powershell || TerminalShellType.powershellCore) ? 1000 : 500;
+                await sleep(delay);
+            }
+        }
+    }
 }

src/client/common/terminal/service.ts

@@ -3,7 +3,6 @@
 
 import { inject, injectable } from 'inversify';
 import { Disposable, Event, EventEmitter, Terminal, Uri } from 'vscode';
-import { sleep } from '../../../utils/async';
 import '../../common/extensions';
 import { IInterpreterService } from '../../interpreter/contracts';
 import { IServiceContainer } from '../../ioc/types';
@@ -21,7 +20,7 @@ export class TerminalService implements ITerminalService, Disposable {
     private terminalManager: ITerminalManager;
     private terminalHelper: ITerminalHelper;
     public get onDidCloseTerminal(): Event<void> {
-        return this.terminalClosed.event;
+        return this.terminalClosed.event.bind(this.terminalClosed);
     }
     constructor(@inject(IServiceContainer) private serviceContainer: IServiceContainer,
         private resource?: Uri,
@@ -64,18 +63,7 @@ export class TerminalService implements ITerminalService, Disposable {
         // Sometimes the terminal takes some time to start up before it can start accepting input.
         await new Promise(resolve => setTimeout(resolve, 100));
 
-        const activationCommamnds = await this.terminalHelper.getEnvironmentActivationCommands(this.terminalShellType, this.resource);
-        if (activationCommamnds) {
-            for (const command of activationCommamnds!) {
-                this.terminal!.show(preserveFocus);
-                this.terminal!.sendText(command);
-
-                // Give the command some time to complete.
-                // Its been observed that sending commands too early will strip some text off.
-                const delay = (this.terminalShellType === TerminalShellType.powershell || TerminalShellType.powershellCore) ? 1000 : 500;
-                await sleep(delay);
-            }
-        }
+        await this.terminalHelper.activateEnvironmentInTerminal(this.terminal!, preserveFocus, this.resource);
 
         this.terminal!.show(preserveFocus);
 

src/client/common/terminal/types.ts

@@ -49,6 +49,7 @@ export interface ITerminalHelper {
     getTerminalShellPath(): string;
     buildCommandForTerminal(terminalShellType: TerminalShellType, command: string, args: string[]): string;
     getEnvironmentActivationCommands(terminalShellType: TerminalShellType, resource?: Uri): Promise<string[] | undefined>;
+    activateEnvironmentInTerminal(terminal: Terminal, preserveFocus?: boolean, resource?: Uri): Promise<void>;
 }
 
 export const ITerminalActivationCommandProvider = Symbol('ITerminalActivationCommandProvider');

src/client/extension.ts

@@ -59,7 +59,7 @@ import { activateUpdateSparkLibraryProvider } from './providers/updateSparkLibra
 import { sendTelemetryEvent } from './telemetry';
 import { EDITOR_LOAD } from './telemetry/constants';
 import { registerTypes as commonRegisterTerminalTypes } from './terminals/serviceRegistry';
-import { ICodeExecutionManager } from './terminals/types';
+import { ICodeExecutionManager, ITerminalAutoActivation } from './terminals/types';
 import { BlockFormatProviders } from './typeFormatters/blockFormatProvider';
 import { OnEnterFormatter } from './typeFormatters/onEnterFormatter';
 import { TEST_OUTPUT_CHANNEL } from './unittests/common/constants';
@@ -83,6 +83,7 @@ export async function activate(context: ExtensionContext) {
     interpreterManager.initialize();
     await interpreterManager.autoSetInterpreter();
 
+    serviceManager.get<ITerminalAutoActivation>(ITerminalAutoActivation).register();
     const configuration = serviceManager.get<IConfigurationService>(IConfigurationService);
     const pythonSettings = configuration.getSettings();
 

src/client/terminals/activation.ts

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+import { inject, injectable } from 'inversify';
+import { Disposable, Terminal } from 'vscode';
+import { ITerminalManager } from '../common/application/types';
+import { ITerminalHelper } from '../common/terminal/types';
+import { IDisposableRegistry } from '../common/types';
+import { IServiceContainer } from '../ioc/types';
+import { ITerminalAutoActivation } from './types';
+
+@injectable()
+export class TerminalAutoActivation implements ITerminalAutoActivation {
+    private readonly helper: ITerminalHelper;
+    constructor(@inject(IServiceContainer) private container: IServiceContainer) {
+        this.helper = container.get<ITerminalHelper>(ITerminalHelper);
+    }
+    public register() {
+        const manager = this.container.get<ITerminalManager>(ITerminalManager);
+        const disposables = this.container.get<Disposable[]>(IDisposableRegistry);
+        const disposable = manager.onDidOpenTerminal(this.activateTerminal, this);
+        disposables.push(disposable);
+    }
+    private activateTerminal(terminal: Terminal): Promise<void> {
+        return this.helper.activateEnvironmentInTerminal(terminal);
+    }
+}

src/client/terminals/serviceRegistry.ts

@@ -2,17 +2,19 @@
 // Licensed under the MIT License.
 
 import { IServiceManager } from '../ioc/types';
+import { TerminalAutoActivation } from './activation';
 import { CodeExecutionManager } from './codeExecution/codeExecutionManager';
 import { DjangoShellCodeExecutionProvider } from './codeExecution/djangoShellCodeExecution';
 import { CodeExecutionHelper } from './codeExecution/helper';
 import { ReplProvider } from './codeExecution/repl';
 import { TerminalCodeExecutionProvider } from './codeExecution/terminalCodeExecution';
-import { ICodeExecutionHelper, ICodeExecutionManager, ICodeExecutionService } from './types';
+import { ICodeExecutionHelper, ICodeExecutionManager, ICodeExecutionService, ITerminalAutoActivation } from './types';
 
 export function registerTypes(serviceManager: IServiceManager) {
     serviceManager.addSingleton<ICodeExecutionHelper>(ICodeExecutionHelper, CodeExecutionHelper);
     serviceManager.addSingleton<ICodeExecutionManager>(ICodeExecutionManager, CodeExecutionManager);
     serviceManager.addSingleton<ICodeExecutionService>(ICodeExecutionService, DjangoShellCodeExecutionProvider, 'djangoShell');
     serviceManager.addSingleton<ICodeExecutionService>(ICodeExecutionService, TerminalCodeExecutionProvider, 'standard');
     serviceManager.addSingleton<ICodeExecutionService>(ICodeExecutionService, ReplProvider, 'repl');
+    serviceManager.addSingleton<ITerminalAutoActivation>(ITerminalAutoActivation, TerminalAutoActivation);
 }

src/client/terminals/types.ts

@@ -25,3 +25,8 @@ export const ICodeExecutionManager = Symbol('ICodeExecutionManager');
 export interface ICodeExecutionManager {
     registerCommands(): void;
 }
+
+export const ITerminalAutoActivation = Symbol('ITerminalAutoActivation');
+export interface ITerminalAutoActivation {
+    register(): void;
+}

src/test/common/terminals/activation.unit.test.ts

@@ -0,0 +1,61 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+import { expect } from 'chai';
+import * as TypeMoq from 'typemoq';
+import { Terminal } from 'vscode';
+import { ITerminalManager } from '../../../client/common/application/types';
+import { ITerminalHelper } from '../../../client/common/terminal/types';
+import { IDisposableRegistry } from '../../../client/common/types';
+import { IServiceContainer } from '../../../client/ioc/types';
+import { TerminalAutoActivation } from '../../../client/terminals/activation';
+import { ITerminalAutoActivation } from '../../../client/terminals/types';
+import { noop } from '../../../utils/misc';
+
+suite('Terminal Auto Activation', () => {
+    let helper: TypeMoq.IMock<ITerminalHelper>;
+    let terminalManager: TypeMoq.IMock<ITerminalManager>;
+    let terminalAutoActivation: ITerminalAutoActivation;
+
+    setup(() => {
+        terminalManager = TypeMoq.Mock.ofType<ITerminalManager>();
+        helper = TypeMoq.Mock.ofType<ITerminalHelper>();
+        const disposables = [];
+
+        const serviceContainer = TypeMoq.Mock.ofType<IServiceContainer>();
+        serviceContainer
+            .setup(c => c.get(TypeMoq.It.isValue(ITerminalManager), TypeMoq.It.isAny()))
+            .returns(() => terminalManager.object);
+        serviceContainer
+            .setup(c => c.get(TypeMoq.It.isValue(ITerminalHelper), TypeMoq.It.isAny()))
+            .returns(() => helper.object);
+        serviceContainer
+            .setup(c => c.get(TypeMoq.It.isValue(IDisposableRegistry), TypeMoq.It.isAny()))
+            .returns(() => disposables);
+
+        terminalAutoActivation = new TerminalAutoActivation(serviceContainer.object);
+    });
+
+    test('New Terminals should be activated', async () => {
+        let eventHandler: undefined | ((e: Terminal) => void);
+        const terminal = TypeMoq.Mock.ofType<Terminal>();
+        terminalManager
+            .setup(m => m.onDidOpenTerminal(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()))
+            .returns(handler => {
+                eventHandler = handler;
+                return { dispose: noop };
+            });
+        helper
+            .setup(h => h.activateEnvironmentInTerminal(TypeMoq.It.isAny(), TypeMoq.It.isAny(), TypeMoq.It.isAny()))
+            .verifiable(TypeMoq.Times.once());
+
+        terminalAutoActivation.register();
+
+        expect(eventHandler).not.to.be.an('undefined', 'event handler not initialized');
+
+        eventHandler!.bind(terminalAutoActivation)(terminal.object);
+
+        helper.verifyAll();
+    });
+});

src/test/common/terminals/helper.activation.test.ts → src/test/common/terminals/helper.activation.unit.test.ts

@@ -3,7 +3,7 @@
 
 import { expect } from 'chai';
 import * as TypeMoq from 'typemoq';
-import { Disposable } from 'vscode';
+import { Disposable, Terminal } from 'vscode';
 import { ITerminalManager, IWorkspaceService } from '../../../client/common/application/types';
 import { IPlatformService } from '../../../client/common/platform/types';
 import { Bash } from '../../../client/common/terminal/environmentActivationProviders/bash';
@@ -74,6 +74,61 @@ suite('Terminal Service helpers', () => {
 
         expect(commands).to.equal(undefined, 'Activation command should be undefined if terminal type cannot be determined');
     });
+    [
+        { commandCount: 1, preserveFocus: false },
+        { commandCount: 2, preserveFocus: false },
+        { commandCount: 1, preserveFocus: true },
+        { commandCount: 1, preserveFocus: true }
+    ].forEach(item => {
+        const titleSuffix = `(${item.commandCount} activation command, and preserve focus in terminal is ${item.preserveFocus})`;
+        const activationCommands = item.commandCount === 1 ? ['CMD1'] : ['CMD1', 'CMD2'];
+        test(`Terminal is activated ${titleSuffix}`, async function () {
+            // tslint:disable-next-line:no-invalid-this
+            this.timeout(10000); // We have delays in place to account for issues with VSC Terminal.
+            helper.getEnvironmentActivationCommands = (_shellType, _resource) => Promise.resolve(activationCommands);
+            helper.getTerminalShellPath = () => '';
+            const terminal = TypeMoq.Mock.ofType<Terminal>();
+
+            terminal
+                .setup(t => t.show(TypeMoq.It.isValue(item.preserveFocus)))
+                .returns(() => undefined)
+                .verifiable(TypeMoq.Times.exactly(activationCommands.length));
+            activationCommands.forEach(cmd => {
+                terminal
+                    .setup(t => t.sendText(TypeMoq.It.isValue(cmd)))
+                    .returns(() => undefined)
+                    .verifiable(TypeMoq.Times.exactly(1));
+            });
+
+            await helper.activateEnvironmentInTerminal(terminal.object, item.preserveFocus);
+
+            terminal.verifyAll();
+        });
+        test(`Terminal is activated only once ${titleSuffix}`, async function () {
+            // tslint:disable-next-line:no-invalid-this
+            this.timeout(10000); // We have delays in place to account for issues with VSC Terminal.
+            helper.getEnvironmentActivationCommands = (_shellType, _resource) => Promise.resolve(activationCommands);
+            helper.getTerminalShellPath = () => '';
+            const terminal = TypeMoq.Mock.ofType<Terminal>();
+
+            terminal
+                .setup(t => t.show(TypeMoq.It.isValue(item.preserveFocus)))
+                .returns(() => undefined)
+                .verifiable(TypeMoq.Times.exactly(activationCommands.length));
+            activationCommands.forEach(cmd => {
+                terminal
+                    .setup(t => t.sendText(TypeMoq.It.isValue(cmd)))
+                    .returns(() => undefined)
+                    .verifiable(TypeMoq.Times.exactly(1));
+            });
+
+            await helper.activateEnvironmentInTerminal(terminal.object, item.preserveFocus);
+            await helper.activateEnvironmentInTerminal(terminal.object, item.preserveFocus);
+            await helper.activateEnvironmentInTerminal(terminal.object, item.preserveFocus);
+
+            terminal.verifyAll();
+        });
+    });
 });
 
 getNamesAndValues<TerminalShellType>(TerminalShellType).forEach(terminalShell => {