labelService: allow to register workspace label formater

src/vs/code/electron-main/app.ts

@@ -229,7 +229,7 @@ export class CodeApplication {
 		});
 
 		ipc.on('vscode:labelRegisterFormater', (event: any, { scheme, formater }) => {
-			this.labelService.registerFormater(scheme, formater);
+			this.labelService.registerFormatter(scheme, formater);
 		});
 
 		ipc.on('vscode:toggleDevTools', (event: Event) => {

src/vs/editor/standalone/browser/simpleServices.ts

@@ -45,7 +45,7 @@ import { WorkspaceEdit, isResourceTextEdit, TextEdit } from 'vs/editor/common/mo
 import { IModelService } from 'vs/editor/common/services/modelService';
 import { EditOperation } from 'vs/editor/common/core/editOperation';
 import { localize } from 'vs/nls';
-import { ILabelService, UriLabelRules } from 'vs/platform/label/common/label';
+import { ILabelService, LabelRules } from 'vs/platform/label/common/label';
 
 export class SimpleModel implements ITextEditorModel {
 
@@ -599,8 +599,8 @@ export class SimpleBulkEditService implements IBulkEditService {
 export class SimpleUriLabelService implements ILabelService {
 	_serviceBrand: any;
 
-	private readonly _onDidRegisterFormater: Emitter<{ scheme: string, formater: UriLabelRules }> = new Emitter<{ scheme: string, formater: UriLabelRules }>();
-	public readonly onDidRegisterFormater: Event<{ scheme: string, formater: UriLabelRules }> = this._onDidRegisterFormater.event;
+	private readonly _onDidRegisterFormatter: Emitter<{ scheme: string, formatter: LabelRules }> = new Emitter<{ scheme: string, formatter: LabelRules }>();
+	public readonly onDidRegisterFormatter: Event<{ scheme: string, formatter: LabelRules }> = this._onDidRegisterFormatter.event;
 
 	public getUriLabel(resource: URI, relative?: boolean): string {
 		if (resource.scheme === 'file') {
@@ -613,7 +613,7 @@ export class SimpleUriLabelService implements ILabelService {
 		return '';
 	}
 
-	public registerFormater(schema: string, formater: UriLabelRules): IDisposable {
+	public registerFormatter(schema: string, formatter: LabelRules): IDisposable {
 		throw new Error('Not implemented');
 	}
 }

src/vs/platform/label/common/label.ts

@@ -22,15 +22,20 @@ export interface ILabelService {
 	_serviceBrand: any;
 	getUriLabel(resource: URI, relative?: boolean, forceNoTildify?: boolean): string;
 	getWorkspaceLabel(workspace: (IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | IWorkspace), options?: { verbose: boolean }): string;
-	registerFormater(schema: string, formater: UriLabelRules): IDisposable;
-	onDidRegisterFormater: Event<{ scheme: string, formater: UriLabelRules }>;
+	registerFormatter(schema: string, formatter: LabelRules): IDisposable;
+	onDidRegisterFormatter: Event<{ scheme: string, formatter: LabelRules }>;
 }
 
-export interface UriLabelRules {
-	label: string; // myLabel:/${path}
-	separator: '/' | '\\' | '';
-	tildify?: boolean;
-	normalizeDriveLetter?: boolean;
+export interface LabelRules {
+	uri: {
+		label: string; // myLabel:/${path}
+		separator: '/' | '\\' | '';
+		tildify?: boolean;
+		normalizeDriveLetter?: boolean;
+	};
+	workspace?: {
+		suffix: string;
+	};
 }
 
 const LABEL_SERVICE_ID = 'label';
@@ -44,24 +49,24 @@ function hasDriveLetter(path: string): boolean {
 export class LabelService implements ILabelService {
 	_serviceBrand: any;
 
-	private readonly formaters = new Map<string, UriLabelRules>();
-	private readonly _onDidRegisterFormater = new Emitter<{ scheme: string, formater: UriLabelRules }>();
+	private readonly formatters = new Map<string, LabelRules>();
+	private readonly _onDidRegisterFormatter = new Emitter<{ scheme: string, formatter: LabelRules }>();
 
 	constructor(
 		@IEnvironmentService private environmentService: IEnvironmentService,
 		@IWorkspaceContextService private contextService: IWorkspaceContextService
 	) { }
 
-	get onDidRegisterFormater(): Event<{ scheme: string, formater: UriLabelRules }> {
-		return this._onDidRegisterFormater.event;
+	get onDidRegisterFormatter(): Event<{ scheme: string, formatter: LabelRules }> {
+		return this._onDidRegisterFormatter.event;
 	}
 
 	getUriLabel(resource: URI, relative?: boolean, forceNoTildify?: boolean): string {
 		if (!resource) {
 			return undefined;
 		}
-		const formater = this.formaters.get(resource.scheme);
-		if (!formater) {
+		const formatter = this.formatters.get(resource.scheme);
+		if (!formatter) {
 			return getPathLabel(resource.path, this.environmentService, relative ? this.contextService : undefined);
 		}
 
@@ -72,8 +77,8 @@ export class LabelService implements ILabelService {
 				if (isEqual(baseResource.uri, resource, !isLinux)) {
 					relativeLabel = ''; // no label if resources are identical
 				} else {
-					const baseResourceLabel = this.formatUri(baseResource.uri, formater, forceNoTildify);
-					relativeLabel = ltrim(this.formatUri(resource, formater, forceNoTildify).substring(baseResourceLabel.length), formater.separator);
+					const baseResourceLabel = this.formatUri(baseResource.uri, formatter, forceNoTildify);
+					relativeLabel = ltrim(this.formatUri(resource, formatter, forceNoTildify).substring(baseResourceLabel.length), formatter.uri.separator);
 				}
 
 				const hasMultipleRoots = this.contextService.getWorkspace().folders.length > 1;
@@ -86,7 +91,7 @@ export class LabelService implements ILabelService {
 			}
 		}
 
-		return this.formatUri(resource, formater, forceNoTildify);
+		return this.formatUri(resource, formatter, forceNoTildify);
 	}
 
 	getWorkspaceLabel(workspace: (IWorkspaceIdentifier | ISingleFolderWorkspaceIdentifier | IWorkspace), options?: { verbose: boolean }): string {
@@ -100,7 +105,9 @@ export class LabelService implements ILabelService {
 		// Workspace: Single Folder
 		if (isSingleFolderWorkspaceIdentifier(workspace)) {
 			// Folder on disk
-			return options && options.verbose ? this.getUriLabel(workspace) : basenameOrAuthority(workspace);
+			const formatter = this.formatters.get(workspace.scheme);
+			const label = options && options.verbose ? this.getUriLabel(workspace) : basenameOrAuthority(workspace);
+			return formatter && formatter.workspace && formatter.workspace.suffix ? `${label} (${formatter.workspace.suffix})` : label;
 		}
 
 		// Workspace: Untitled
@@ -118,17 +125,17 @@ export class LabelService implements ILabelService {
 		return localize('workspaceName', "{0} (Workspace)", workspaceName);
 	}
 
-	registerFormater(scheme: string, formater: UriLabelRules): IDisposable {
-		this.formaters.set(scheme, formater);
-		this._onDidRegisterFormater.fire({ scheme, formater });
+	registerFormatter(scheme: string, formatter: LabelRules): IDisposable {
+		this.formatters.set(scheme, formatter);
+		this._onDidRegisterFormatter.fire({ scheme, formatter });
 
 		return {
-			dispose: () => this.formaters.delete(scheme)
+			dispose: () => this.formatters.delete(scheme)
 		};
 	}
 
-	private formatUri(resource: URI, formater: UriLabelRules, forceNoTildify: boolean): string {
-		let label = formater.label.replace(labelMatchingRegexp, match => {
+	private formatUri(resource: URI, formatter: LabelRules, forceNoTildify: boolean): string {
+		let label = formatter.uri.label.replace(labelMatchingRegexp, match => {
 			switch (match) {
 				case '${scheme}': return resource.scheme;
 				case '${authority}': return resource.authority;
@@ -138,15 +145,15 @@ export class LabelService implements ILabelService {
 		});
 
 		// convert \c:\something => C:\something
-		if (formater.normalizeDriveLetter && hasDriveLetter(label)) {
+		if (formatter.uri.normalizeDriveLetter && hasDriveLetter(label)) {
 			label = label.charAt(1).toUpperCase() + label.substr(2);
 		}
 
-		if (formater.tildify && !forceNoTildify) {
+		if (formatter.uri.tildify && !forceNoTildify) {
 			label = tildify(label, this.environmentService.userHome);
 		}
 
-		return label.replace(sepRegexp, formater.separator);
+		return label.replace(sepRegexp, formatter.uri.separator);
 	}
 }
 

src/vs/platform/label/electron-browser/label.contribution.ts

@@ -16,7 +16,7 @@ import { LifecyclePhase } from 'vs/platform/lifecycle/common/lifecycle';
 class LabelRegistrationContribution implements IWorkbenchContribution {
 
 	constructor(@ILabelService labelService: ILabelService) {
-		labelService.onDidRegisterFormater(data => {
+		labelService.onDidRegisterFormatter(data => {
 			ipc.send('vscode:labelRegisterFormater', data);
 		});
 	}

src/vs/platform/label/test/uriLabel.test.ts → src/vs/platform/label/test/label.test.ts

@@ -21,11 +21,13 @@ suite('URI Label', () => {
 	});
 
 	test('file scheme', function () {
-		labelService.registerFormater(Schemas.file, {
-			label: '${path}',
-			separator: nativeSep,
-			tildify: !isWindows,
-			normalizeDriveLetter: isWindows
+		labelService.registerFormatter(Schemas.file, {
+			uri: {
+				label: '${path}',
+				separator: nativeSep,
+				tildify: !isWindows,
+				normalizeDriveLetter: isWindows
+			}
 		});
 
 		const uri1 = TestWorkspace.folders[0].uri.with({ path: TestWorkspace.folders[0].uri.path.concat('/a/b/c/d') });
@@ -37,11 +39,13 @@ suite('URI Label', () => {
 	});
 
 	test('custom scheme', function () {
-		labelService.registerFormater(Schemas.vscode, {
-			label: 'LABEL/${path}/${authority}/END',
-			separator: '/',
-			tildify: true,
-			normalizeDriveLetter: true
+		labelService.registerFormatter(Schemas.vscode, {
+			uri: {
+				label: 'LABEL/${path}/${authority}/END',
+				separator: '/',
+				tildify: true,
+				normalizeDriveLetter: true
+			}
 		});
 
 		const uri1 = URI.parse('vscode://microsoft.com/1/2/3/4/5');

src/vs/workbench/api/electron-browser/mainThreadFileSystem.ts

@@ -11,7 +11,7 @@ import { TPromise } from 'vs/base/common/winjs.base';
 import { FileWriteOptions, FileSystemProviderCapabilities, IFileChange, IFileService, IFileSystemProvider, IStat, IWatchOptions, FileType, FileOverwriteOptions, FileDeleteOptions } from 'vs/platform/files/common/files';
 import { extHostNamedCustomer } from 'vs/workbench/api/electron-browser/extHostCustomers';
 import { ExtHostContext, ExtHostFileSystemShape, IExtHostContext, IFileChangeDto, MainContext, MainThreadFileSystemShape } from '../node/extHost.protocol';
-import { UriLabelRules, ILabelService } from 'vs/platform/label/common/label';
+import { LabelRules, ILabelService } from 'vs/platform/label/common/label';
 
 @extHostNamedCustomer(MainContext.MainThreadFileSystem)
 export class MainThreadFileSystem implements MainThreadFileSystemShape {
@@ -41,8 +41,8 @@ export class MainThreadFileSystem implements MainThreadFileSystemShape {
 		this._fileProvider.delete(handle);
 	}
 
-	$setUriFormatter(scheme: string, formatter: UriLabelRules): void {
-		this._labelService.registerFormater(scheme, formatter);
+	$setUriFormatter(scheme: string, formatter: LabelRules): void {
+		this._labelService.registerFormatter(scheme, formatter);
 	}
 
 	$onFileSystemChange(handle: number, changes: IFileChangeDto[]): void {

src/vs/workbench/api/node/extHost.protocol.ts

@@ -40,7 +40,7 @@ import { IExtensionDescription } from 'vs/workbench/services/extensions/common/e
 import { createExtHostContextProxyIdentifier as createExtId, createMainContextProxyIdentifier as createMainId, IRPCProtocol, ProxyIdentifier } from 'vs/workbench/services/extensions/node/proxyIdentifier';
 import { IProgressOptions, IProgressStep } from 'vs/workbench/services/progress/common/progress';
 import { SaveReason } from 'vs/workbench/services/textfile/common/textfiles';
-import { UriLabelRules } from 'vs/platform/label/common/label';
+import { LabelRules } from 'vs/platform/label/common/label';
 import * as vscode from 'vscode';
 
 export interface IEnvironment {
@@ -483,7 +483,7 @@ export interface IFileChangeDto {
 export interface MainThreadFileSystemShape extends IDisposable {
 	$registerFileSystemProvider(handle: number, scheme: string, capabilities: FileSystemProviderCapabilities): void;
 	$unregisterProvider(handle: number): void;
-	$setUriFormatter(scheme: string, formatter: UriLabelRules): void;
+	$setUriFormatter(scheme: string, formatter: LabelRules): void;
 	$onFileSystemChange(handle: number, resource: IFileChangeDto[]): void;
 }
 

src/vs/workbench/api/node/extHostFileSystem.ts

@@ -15,7 +15,7 @@ import { values } from 'vs/base/common/map';
 import { Range, FileChangeType } from 'vs/workbench/api/node/extHostTypes';
 import { ExtHostLanguageFeatures } from 'vs/workbench/api/node/extHostLanguageFeatures';
 import { Schemas } from 'vs/base/common/network';
-import { UriLabelRules } from 'vs/platform/label/common/label';
+import { LabelRules } from 'vs/platform/label/common/label';
 
 class FsLinkProvider implements vscode.DocumentLinkProvider {
 
@@ -142,7 +142,7 @@ export class ExtHostFileSystem implements ExtHostFileSystemShape {
 		});
 	}
 
-	setUriFormatter(scheme: string, formatter: UriLabelRules): void {
+	setUriFormatter(scheme: string, formatter: LabelRules): void {
 		this._proxy.$setUriFormatter(scheme, formatter);
 	}
 

src/vs/workbench/parts/files/electron-browser/files.contribution.ts

@@ -56,11 +56,13 @@ export class OpenExplorerViewletAction extends ToggleViewletAction {
 class FileUriLabelContribution implements IWorkbenchContribution {
 
 	constructor(@ILabelService labelService: ILabelService) {
-		labelService.registerFormater(Schemas.file, {
-			label: '${path}',
-			separator: nativeSep,
-			tildify: !platform.isWindows,
-			normalizeDriveLetter: platform.isWindows
+		labelService.registerFormatter(Schemas.file, {
+			uri: {
+				label: '${path}',
+				separator: nativeSep,
+				tildify: !platform.isWindows,
+				normalizeDriveLetter: platform.isWindows
+			}
 		});
 	}
 }