Adds custom terminal launch settings

src/vs/workbench/parts/execution/electron-browser/terminal.contribution.ts

@@ -19,6 +19,34 @@ import {ITerminalService} from 'vs/workbench/parts/execution/common/execution';
 import {SyncActionDescriptor} from 'vs/platform/actions/common/actions';
 import {IInstantiationService} from 'vs/platform/instantiation/common/instantiation';
 import {KeyMod, KeyCode} from 'vs/base/common/keyCodes';
+import {Extensions, IConfigurationRegistry} from 'vs/platform/configuration/common/configurationRegistry';
+import {DEFAULT_WINDOWS_TERM, DEFAULT_LINUX_TERM} from 'vs/workbench/parts/execution/electron-browser/terminal';
+
+let configurationRegistry = <IConfigurationRegistry>Registry.as(Extensions.Configuration);
+configurationRegistry.registerConfiguration({
+	'id': 'terminal',
+	'order': 100,
+	'title': nls.localize('terminalConfigurationTitle', "Terminal configuration"),
+	'type': 'object',
+	'properties': {
+		'terminal.external': {
+			'description': nls.localize('terminal.external', "External terminal settings."),
+			'type': 'object',
+			'properties': {
+				'windowsExec': {
+					'type': 'string',
+					'description': nls.localize('terminal.external.windowsExec', "Customizes which terminal to run on Windows."),
+					'default': DEFAULT_WINDOWS_TERM
+				},
+				'linuxExec': {
+					'type': 'string',
+					'description': nls.localize('terminal.external.linuxExec', "Customizes which terminal to on Linux."),
+					'default': DEFAULT_LINUX_TERM
+				}
+			}
+		}
+	}
+});
 
 export class OpenConsoleAction extends Action {
 

src/vs/workbench/parts/execution/electron-browser/terminal.ts

@@ -0,0 +1,18 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import fs = require('fs');
+import env = require('vs/base/common/platform');
+
+export let DEFAULT_LINUX_TERM = 'x-terminal-emulator';
+
+// if we're not on debian and using gnome then
+// set default to gnome-terminal
+if (env.isLinux
+	&& fs.existsSync('/etc/debian_version') === false
+	&& process.env.DESKTOP_SESSION === 'gnome') {
+	DEFAULT_LINUX_TERM = 'gnome-terminal';
+}
+
+export const DEFAULT_WINDOWS_TERM = 'cmd';

src/vs/workbench/parts/execution/electron-browser/terminalService.ts

@@ -9,7 +9,7 @@ import uri from 'vs/base/common/uri';
 import {TPromise} from 'vs/base/common/winjs.base';
 import {ITerminalService} from 'vs/workbench/parts/execution/common/execution';
 import {IConfigurationService} from 'vs/platform/configuration/common/configuration';
-import {IMessageService} from 'vs/platform/message/common/message';
+import {DEFAULT_WINDOWS_TERM, DEFAULT_LINUX_TERM} from 'vs/workbench/parts/execution/electron-browser/terminal';
 
 import cp = require('child_process');
 import processes = require('vs/base/node/processes');
@@ -18,13 +18,36 @@ export class WinTerminalService implements ITerminalService {
 	public serviceId = ITerminalService;
 
 	constructor(
-		@IConfigurationService private _configurationService: IConfigurationService,
-		@IMessageService private _messageService: IMessageService
+		@IConfigurationService private _configurationService: IConfigurationService
 	) {
 	}
 
 	public openTerminal(path: string): void {
-		cp.spawn(processes.getWindowsShell(), ['/c', 'start', '/wait'], { cwd: path });
+		this._configurationService.loadConfiguration().done(configuration => {
+			return new Promise((success, failed) => {
+				this.spawnTerminal(
+					cp,
+					configuration,
+					processes.getWindowsShell(),
+					path,
+					success,
+					err => {
+						errors.onUnexpectedError(err);
+						failed(err);
+					}
+				);
+			});
+		}, errors.onUnexpectedError);
+	}
+
+	private spawnTerminal(spawner, configuration, command: string, path: string, onExit, onError) {
+		let terminalConfig = configuration.terminal.external;
+		let exec = terminalConfig.windowsExec || DEFAULT_WINDOWS_TERM;
+		let cmdArgs = ['/c', 'start', '/wait', exec];
+
+		let child = spawner.spawn(command, cmdArgs, { cwd: path });
+		child.on('error', onError);
+		child.on('exit', onExit);
 	}
 }
 
@@ -49,14 +72,41 @@ export class MacTerminalService implements ITerminalService {
 			child.on('exit', (code: number) => {
 				c(code === 0 ? 'iterm.scpt' : 'terminal.scpt');
 			});
-		}).then(name => uri.parse(require.toUrl(`vs/workbench/parts/execution/electron-browser/${ name }`)).fsPath);
+		}).then(name => uri.parse(require.toUrl(`vs/workbench/parts/execution/electron-browser/${name}`)).fsPath);
 	}
 }
 
 export class LinuxTerminalService implements ITerminalService {
 	public serviceId = ITerminalService;
 
+	constructor(
+		@IConfigurationService private _configurationService: IConfigurationService
+	) { }
+
+
 	public openTerminal(path: string): void {
-		cp.spawn('x-terminal-emulator', [], { cwd: path });
+		this._configurationService.loadConfiguration().done(configuration => {
+			return new Promise((success, failed) => {
+				this.spawnTerminal(
+					cp,
+					configuration,
+					path,
+					success,
+					err => {
+						errors.onUnexpectedError(err);
+						failed(err);
+					}
+				);
+			});
+		}, errors.onUnexpectedError);
 	}
+
+	private spawnTerminal(spawner, configuration, path: string, onExit, onError) {
+		let terminalConfig = configuration.terminal.external;
+		let exec = terminalConfig.linuxExec || DEFAULT_LINUX_TERM;
+		const child = spawner.spawn(exec, [], { cwd: path });
+		child.on('error', onError);
+		child.on('exit', onExit);
+	}
+
 }

src/vs/workbench/parts/execution/test/electron-browser/terminalService.test.ts

@@ -0,0 +1,127 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+import {equal} from 'assert';
+import {WinTerminalService, LinuxTerminalService} from 'vs/workbench/parts/execution/electron-browser/terminalService';
+import {DEFAULT_WINDOWS_TERM, DEFAULT_LINUX_TERM} from 'vs/workbench/parts/execution/electron-browser/terminal';
+
+suite('Execution - TerminalService', () => {
+	let mockOnExit;
+	let mockOnError;
+	let mockConfig;
+
+	setup(() => {
+		mockConfig = {
+			terminal: {
+				external: {
+					windowsExec: 'testWindowsShell',
+					linuxExec: 'testLinuxShell'
+				}
+			}
+		};
+		mockOnExit = s => s;
+		mockOnError = e => e;
+	});
+
+	test("WinTerminalService - uses terminal from configuration", done => {
+		let testShell = 'cmd';
+		let testCwd = 'path/to/workspace';
+		let mockSpawner = {
+			spawn: (command, args, opts) => {
+				// assert
+				equal(command, testShell, 'shell should equal expected');
+				equal(args[args.length - 1], mockConfig.terminal.external.windowsExec, 'terminal should equal expected')
+				equal(opts.cwd, testCwd, 'opts.cwd should equal expected');
+				done();
+				return {
+					on: (evt) => evt
+				}
+			}
+		};
+		let testService = new WinTerminalService(mockConfig);
+		(<any>testService).spawnTerminal(
+			mockSpawner,
+			mockConfig,
+			testShell,
+			testCwd,
+			mockOnExit,
+			mockOnError
+		);
+	});
+
+	test("WinTerminalService - uses default terminal when configuration.terminal.external.windowsExec is undefined", done => {
+		let testShell = 'cmd';
+		let testCwd = 'path/to/workspace';
+		let mockSpawner = {
+			spawn: (command, args, opts) => {
+				// assert
+				equal(args[args.length - 1], DEFAULT_WINDOWS_TERM, 'terminal should equal expected')
+				done();
+				return {
+					on: (evt) => evt
+				}
+			}
+		};
+		mockConfig.terminal.external.windowsExec = undefined;
+		let testService = new WinTerminalService(mockConfig);
+		(<any>testService).spawnTerminal(
+			mockSpawner,
+			mockConfig,
+			testShell,
+			testCwd,
+			mockOnExit,
+			mockOnError
+		);
+	});
+
+	test("LinuxTerminalService - uses terminal from configuration", done => {
+		let testCwd = 'path/to/workspace';
+		let mockSpawner = {
+			spawn: (command, args, opts) => {
+				// assert
+				equal(command, mockConfig.terminal.external.linuxExec, 'terminal should equal expected');
+				equal(opts.cwd, testCwd, 'opts.cwd should equal expected');
+				done();
+				return {
+					on: (evt) => evt
+				}
+			}
+		};
+		let testService = new LinuxTerminalService(mockConfig);
+		(<any>testService).spawnTerminal(
+			mockSpawner,
+			mockConfig,
+			testCwd,
+			mockOnExit,
+			mockOnError
+		);
+	});
+
+	test("LinuxTerminalService - uses default terminal when configuration.terminal.external.linuxExec is undefined", done => {
+		let testCwd = 'path/to/workspace';
+		let mockSpawner = {
+			spawn: (command, args, opts) => {
+				// assert
+				equal(command, DEFAULT_LINUX_TERM, 'terminal should equal expected')
+				done();
+				return {
+					on: (evt) => evt
+				}
+			}
+		};
+		mockConfig.terminal.external.linuxExec = undefined;
+		let testService = new LinuxTerminalService(mockConfig);
+		(<any>testService).spawnTerminal(
+			mockSpawner,
+			mockConfig,
+			testCwd,
+			mockOnExit,
+			mockOnError
+		);
+	});
+
+});