explorer: read all capabilites like a proper gentlemen

#48258

Author: isidorn

src/vs/workbench/contrib/files/browser/editors/fileEditorTracker.ts

@@ -8,7 +8,7 @@ import { URI } from 'vs/base/common/uri';
 import { IEditorViewState } from 'vs/editor/common/editorCommon';
 import { toResource, SideBySideEditorInput, IWorkbenchEditorConfiguration, SideBySideEditor as SideBySideEditorChoice } from 'vs/workbench/common/editor';
 import { ITextFileService, TextFileModelChangeEvent, ModelState } from 'vs/workbench/services/textfile/common/textfiles';
-import { FileOperationEvent, FileOperation, IFileService, FileChangeType, FileChangesEvent } from 'vs/platform/files/common/files';
+import { FileOperationEvent, FileOperation, IFileService, FileChangeType, FileChangesEvent, FileSystemProviderCapabilities } from 'vs/platform/files/common/files';
 import { FileEditorInput } from 'vs/workbench/contrib/files/common/editors/fileEditorInput';
 import { ILifecycleService } from 'vs/platform/lifecycle/common/lifecycle';
 import { Disposable, IDisposable, dispose } from 'vs/base/common/lifecycle';
@@ -25,7 +25,6 @@ import { timeout } from 'vs/base/common/async';
 import { withNullAsUndefined } from 'vs/base/common/types';
 import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
 import { isEqualOrParent, joinPath } from 'vs/base/common/resources';
-import { IExplorerService } from 'vs/workbench/contrib/files/common/files';
 
 export class FileEditorTracker extends Disposable implements IWorkbenchContribution {
 
@@ -44,7 +43,6 @@ export class FileEditorTracker extends Disposable implements IWorkbenchContribut
 		@IWorkspaceContextService private readonly contextService: IWorkspaceContextService,
 		@IHostService private readonly hostService: IHostService,
 		@ICodeEditorService private readonly codeEditorService: ICodeEditorService,
-		@IExplorerService private readonly explorerService: IExplorerService
 	) {
 		super();
 
@@ -108,7 +106,8 @@ export class FileEditorTracker extends Disposable implements IWorkbenchContribut
 						if (oldResource.toString() === resource.toString()) {
 							reopenFileResource = newResource; // file got moved
 						} else {
-							const index = this.getIndexOfPath(resource.path, oldResource.path, this.explorerService.shouldIgnoreCase(resource));
+							const ignoreCase = !this.fileService.hasCapability(resource, FileSystemProviderCapabilities.PathCaseSensitive);
+							const index = this.getIndexOfPath(resource.path, oldResource.path, ignoreCase);
 							reopenFileResource = joinPath(newResource, resource.path.substr(index + oldResource.path.length + 1)); // parent folder got moved
 						}
 

src/vs/workbench/contrib/files/browser/fileActions.ts

@@ -870,8 +870,9 @@ async function openExplorerAndCreate(accessor: ServicesAccessor, isFolder: boole
 		throw new Error('Parent folder is readonly.');
 	}
 
-	const newStat = new NewExplorerItem(explorerService, folder, isFolder);
-	await folder.fetchChildren(fileService, explorerService);
+	const newStat = new NewExplorerItem(fileService, folder, isFolder);
+	const sortOrder = explorerService.sortOrder;
+	await folder.fetchChildren(sortOrder);
 
 	folder.addChild(newStat);
 

src/vs/workbench/contrib/files/browser/views/explorerViewer.ts

@@ -9,7 +9,7 @@ import * as glob from 'vs/base/common/glob';
 import { IListVirtualDelegate, ListDragOverEffect } from 'vs/base/browser/ui/list/list';
 import { IProgressService, ProgressLocation } from 'vs/platform/progress/common/progress';
 import { INotificationService, Severity } from 'vs/platform/notification/common/notification';
-import { IFileService, FileKind, FileOperationError, FileOperationResult } from 'vs/platform/files/common/files';
+import { IFileService, FileKind, FileOperationError, FileOperationResult, FileSystemProviderCapabilities } from 'vs/platform/files/common/files';
 import { IWorkbenchLayoutService } from 'vs/workbench/services/layout/browser/layoutService';
 import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
 import { IDisposable, Disposable, dispose, toDisposable, DisposableStore } from 'vs/base/common/lifecycle';
@@ -90,12 +90,13 @@ export class ExplorerDataSource implements IAsyncDataSource<ExplorerItem | Explo
 			return Promise.resolve(element);
 		}
 
-		const promise = element.fetchChildren(this.fileService, this.explorerService).then(undefined, e => {
+		const sortOrder = this.explorerService.sortOrder;
+		const promise = element.fetchChildren(sortOrder).then(undefined, e => {
 
 			if (element instanceof ExplorerItem && element.isRoot) {
 				if (this.contextService.getWorkbenchState() === WorkbenchState.FOLDER) {
 					// Single folder create a dummy explorer item to show error
-					const placeholder = new ExplorerItem(element.resource, this.explorerService, undefined, false);
+					const placeholder = new ExplorerItem(element.resource, this.fileService, undefined, false);
 					placeholder.isError = true;
 					return [placeholder];
 				} else {
@@ -921,17 +922,17 @@ export class FileDragAndDrop implements ITreeDragAndDrop<ExplorerItem> {
 
 			// Check for name collisions
 			const targetNames = new Set<string>();
+			const caseSensitive = this.fileService.hasCapability(target.resource, FileSystemProviderCapabilities.PathCaseSensitive);
 			if (targetStat.children) {
-				const ignoreCase = this.explorerService.shouldIgnoreCase(target.resource);
 				targetStat.children.forEach(child => {
-					targetNames.add(ignoreCase ? child.name.toLowerCase() : child.name);
+					targetNames.add(caseSensitive ? child.name : child.name.toLowerCase());
 				});
 			}
 
 			// Run add in sequence
 			const addPromisesFactory: ITask<Promise<void>>[] = [];
 			await Promise.all(resources.map(async resource => {
-				if (targetNames.has(this.explorerService.shouldIgnoreCase(resource) ? basename(resource).toLowerCase() : basename(resource))) {
+				if (targetNames.has(caseSensitive ? basename(resource) : basename(resource).toLowerCase())) {
 					const confirmationResult = await this.dialogService.confirm(getFileOverwriteConfirm(basename(resource)));
 					if (!confirmationResult.confirmed) {
 						return;

src/vs/workbench/contrib/files/common/explorerModel.ts

@@ -14,8 +14,8 @@ import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace
 import { IDisposable, dispose } from 'vs/base/common/lifecycle';
 import { memoize } from 'vs/base/common/decorators';
 import { Emitter, Event } from 'vs/base/common/event';
-import { IExplorerService, SortOrder } from 'vs/workbench/contrib/files/common/files';
 import { joinPath, isEqualOrParent, basenameOrAuthority } from 'vs/base/common/resources';
+import { SortOrder } from 'vs/workbench/contrib/files/common/files';
 
 export class ExplorerModel implements IDisposable {
 
@@ -25,10 +25,10 @@ export class ExplorerModel implements IDisposable {
 
 	constructor(
 		private readonly contextService: IWorkspaceContextService,
-		explorerService: IExplorerService
+		fileService: IFileService
 	) {
 		const setRoots = () => this._roots = this.contextService.getWorkspace().folders
-			.map(folder => new ExplorerItem(folder.uri, explorerService, undefined, true, false, false, folder.name));
+			.map(folder => new ExplorerItem(folder.uri, fileService, undefined, true, false, folder.name));
 		setRoots();
 
 		this._listener = this.contextService.onDidChangeWorkspaceFolders(() => {
@@ -83,11 +83,10 @@ export class ExplorerItem {
 
 	constructor(
 		public resource: URI,
-		private readonly explorerService: IExplorerService,
+		private readonly fileService: IFileService,
 		private _parent: ExplorerItem | undefined,
 		private _isDirectory?: boolean,
 		private _isSymbolicLink?: boolean,
-		private _isReadonly?: boolean,
 		private _name: string = basenameOrAuthority(resource),
 		private _mtime?: number,
 	) {
@@ -112,7 +111,7 @@ export class ExplorerItem {
 	}
 
 	get isReadonly(): boolean {
-		return !!this._isReadonly;
+		return this.fileService.hasCapability(this.resource, FileSystemProviderCapabilities.Readonly);
 	}
 
 	get mtime(): number | undefined {
@@ -158,8 +157,8 @@ export class ExplorerItem {
 		return this === this.root;
 	}
 
-	static create(explorerService: IExplorerService, fileService: IFileService, raw: IFileStat, parent: ExplorerItem | undefined, resolveTo?: readonly URI[]): ExplorerItem {
-		const stat = new ExplorerItem(raw.resource, explorerService, parent, raw.isDirectory, raw.isSymbolicLink, fileService.hasCapability(raw.resource, FileSystemProviderCapabilities.Readonly), raw.name, raw.mtime);
+	static create(fileService: IFileService, raw: IFileStat, parent: ExplorerItem | undefined, resolveTo?: readonly URI[]): ExplorerItem {
+		const stat = new ExplorerItem(raw.resource, fileService, parent, raw.isDirectory, raw.isSymbolicLink, raw.name, raw.mtime);
 
 		// Recursively add children if present
 		if (stat.isDirectory) {
@@ -174,7 +173,7 @@ export class ExplorerItem {
 			// Recurse into children
 			if (raw.children) {
 				for (let i = 0, len = raw.children.length; i < len; i++) {
-					const child = ExplorerItem.create(explorerService, fileService, raw.children[i], stat, resolveTo);
+					const child = ExplorerItem.create(fileService, raw.children[i], stat, resolveTo);
 					stat.addChild(child);
 				}
 			}
@@ -208,7 +207,6 @@ export class ExplorerItem {
 		local._mtime = disk.mtime;
 		local._isDirectoryResolved = disk._isDirectoryResolved;
 		local._isSymbolicLink = disk.isSymbolicLink;
-		local._isReadonly = disk.isReadonly;
 		local.isError = disk.isError;
 
 		// Merge Children if resolved
@@ -259,14 +257,14 @@ export class ExplorerItem {
 		return this.children.get(this.getPlatformAwareName(name));
 	}
 
-	async fetchChildren(fileService: IFileService, explorerService: IExplorerService): Promise<ExplorerItem[]> {
+	async fetchChildren(sortOrder: SortOrder): Promise<ExplorerItem[]> {
 		if (!this._isDirectoryResolved) {
 			// Resolve metadata only when the mtime is needed since this can be expensive
 			// Mtime is only used when the sort order is 'modified'
-			const resolveMetadata = explorerService.sortOrder === SortOrder.Modified;
+			const resolveMetadata = sortOrder === SortOrder.Modified;
 			try {
-				const stat = await fileService.resolve(this.resource, { resolveSingleChildDescendants: true, resolveMetadata });
-				const resolved = ExplorerItem.create(explorerService, fileService, stat, this);
+				const stat = await this.fileService.resolve(this.resource, { resolveSingleChildDescendants: true, resolveMetadata });
+				const resolved = ExplorerItem.create(this.fileService, stat, this);
 				ExplorerItem.mergeLocalWithDisk(resolved, this);
 			} catch (e) {
 				this.isError = true;
@@ -306,7 +304,7 @@ export class ExplorerItem {
 	}
 
 	private getPlatformAwareName(name: string): string {
-		return this.explorerService.shouldIgnoreCase(this.resource) ? name.toLowerCase() : name;
+		return this.fileService.hasCapability(this.resource, FileSystemProviderCapabilities.PathCaseSensitive) ? name : name.toLowerCase();
 	}
 
 	/**
@@ -356,7 +354,7 @@ export class ExplorerItem {
 	find(resource: URI): ExplorerItem | null {
 		// Return if path found
 		// For performance reasons try to do the comparison as fast as possible
-		const ignoreCase = this.explorerService.shouldIgnoreCase(resource);
+		const ignoreCase = !this.fileService.hasCapability(resource, FileSystemProviderCapabilities.PathCaseSensitive);
 		if (resource && this.resource.scheme === resource.scheme && equalsIgnoreCase(this.resource.authority, resource.authority) &&
 			(ignoreCase ? startsWithIgnoreCase(resource.path, this.resource.path) : startsWith(resource.path, this.resource.path))) {
 			return this.findByPath(rtrim(resource.path, posix.sep), this.resource.path.length, ignoreCase);
@@ -397,7 +395,7 @@ export class ExplorerItem {
 }
 
 export class NewExplorerItem extends ExplorerItem {
-	constructor(explorerService: IExplorerService, parent: ExplorerItem, isDirectory: boolean) {
-		super(URI.file(''), explorerService, parent, isDirectory);
+	constructor(fileService: IFileService, parent: ExplorerItem, isDirectory: boolean) {
+		super(URI.file(''), fileService, parent, isDirectory);
 	}
 }

src/vs/workbench/contrib/files/common/explorerService.ts

@@ -9,8 +9,8 @@ import { DisposableStore } from 'vs/base/common/lifecycle';
 import { IExplorerService, IFilesConfiguration, SortOrder, IContextProvider } from 'vs/workbench/contrib/files/common/files';
 import { ExplorerItem, ExplorerModel } from 'vs/workbench/contrib/files/common/explorerModel';
 import { URI } from 'vs/base/common/uri';
-import { FileOperationEvent, FileOperation, IFileStat, IFileService, FileChangesEvent, FILES_EXCLUDE_CONFIG, FileChangeType, IResolveFileOptions, FileSystemProviderCapabilities } from 'vs/platform/files/common/files';
-import { dirname, hasToIgnoreCase } from 'vs/base/common/resources';
+import { FileOperationEvent, FileOperation, IFileStat, IFileService, FileChangesEvent, FILES_EXCLUDE_CONFIG, FileChangeType, IResolveFileOptions } from 'vs/platform/files/common/files';
+import { dirname } from 'vs/base/common/resources';
 import { memoize } from 'vs/base/common/decorators';
 import { ResourceGlobMatcher } from 'vs/workbench/common/resources';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
@@ -42,7 +42,6 @@ export class ExplorerService implements IExplorerService {
 	private _sortOrder: SortOrder;
 	private cutItems: ExplorerItem[] | undefined;
 	private contextProvider: IContextProvider | undefined;
-	private fileSystemProviderCaseSensitivity = new Map<string, boolean>();
 	private model: ExplorerModel;
 
 	constructor(
@@ -55,25 +54,21 @@ export class ExplorerService implements IExplorerService {
 	) {
 		this._sortOrder = this.configurationService.getValue('explorer.sortOrder');
 
-		this.model = new ExplorerModel(this.contextService, this);
+		this.model = new ExplorerModel(this.contextService, this.fileService);
 		this.disposables.add(this.model);
 		this.disposables.add(this.fileService.onAfterOperation(e => this.onFileOperation(e)));
 		this.disposables.add(this.fileService.onFileChanges(e => this.onFileChanges(e)));
 		this.disposables.add(this.configurationService.onDidChangeConfiguration(e => this.onConfigurationUpdated(this.configurationService.getValue<IFilesConfiguration>())));
-		this.disposables.add(this.fileService.onDidChangeFileSystemProviderRegistrations(e => {
-			const provider = e.provider;
-			if (e.added && provider) {
-				const alreadyRegistered = this.fileSystemProviderCaseSensitivity.has(e.scheme);
-				const readCapability = () => this.fileSystemProviderCaseSensitivity.set(e.scheme, !!(provider.capabilities & FileSystemProviderCapabilities.PathCaseSensitive));
-				readCapability();
-
-				if (alreadyRegistered) {
-					// A file system provider got re-registered, we should update all file stats since they might change (got read-only)
-					this.model.roots.forEach(r => r.forgetChildren());
-					this._onDidChangeItem.fire({ recursive: true });
-				} else {
-					this.disposables.add(provider.onDidChangeCapabilities(() => readCapability()));
+		this.disposables.add(Event.any<{ scheme: string }>(this.fileService.onDidChangeFileSystemProviderRegistrations, this.fileService.onDidChangeFileSystemProviderCapabilities)(e => {
+			let affected = false;
+			this.model.roots.forEach(r => {
+				if (r.resource.scheme === e.scheme) {
+					affected = true;
+					r.forgetChildren();
 				}
+			});
+			if (affected) {
+				this._onDidChangeItem.fire({ recursive: true });
 			}
 		}));
 		this.disposables.add(this.model.onDidChangeRoots(() => this._onDidChangeRoots.fire()));
@@ -131,15 +126,6 @@ export class ExplorerService implements IExplorerService {
 		return fileEventsFilter;
 	}
 
-	shouldIgnoreCase(resource: URI): boolean {
-		const caseSensitive = this.fileSystemProviderCaseSensitivity.get(resource.scheme);
-		if (typeof caseSensitive === 'undefined') {
-			return hasToIgnoreCase(resource);
-		}
-
-		return !caseSensitive;
-	}
-
 	// IExplorerService methods
 
 	findClosest(resource: URI): ExplorerItem | null {
@@ -200,7 +186,7 @@ export class ExplorerService implements IExplorerService {
 			const stat = await this.fileService.resolve(rootUri, options);
 
 			// Convert to model
-			const modelStat = ExplorerItem.create(this, this.fileService, stat, undefined, options.resolveTo);
+			const modelStat = ExplorerItem.create(this.fileService, stat, undefined, options.resolveTo);
 			// Update Input with disk Stat
 			ExplorerItem.mergeLocalWithDisk(modelStat, root);
 			const item = root.find(resource);
@@ -244,11 +230,11 @@ export class ExplorerService implements IExplorerService {
 					const thenable: Promise<IFileStat | undefined> = p.isDirectoryResolved ? Promise.resolve(undefined) : this.fileService.resolve(p.resource, { resolveMetadata });
 					thenable.then(stat => {
 						if (stat) {
-							const modelStat = ExplorerItem.create(this, this.fileService, stat, p.parent);
+							const modelStat = ExplorerItem.create(this.fileService, stat, p.parent);
 							ExplorerItem.mergeLocalWithDisk(modelStat, p);
 						}
 
-						const childElement = ExplorerItem.create(this, this.fileService, addedElement, p.parent);
+						const childElement = ExplorerItem.create(this.fileService, addedElement, p.parent);
 						// Make sure to remove any previous version of the file if any
 						p.removeChild(childElement);
 						p.addChild(childElement);

src/vs/workbench/contrib/files/common/files.ts

@@ -55,7 +55,6 @@ export interface IExplorerService {
 	refresh(): void;
 	setToCopy(stats: ExplorerItem[], cut: boolean): void;
 	isCut(stat: ExplorerItem): boolean;
-	shouldIgnoreCase(resource: URI): boolean;
 
 	/**
 	 * Selects and reveal the file element provided by the given resource if its found in the explorer.

src/vs/workbench/contrib/files/test/electron-browser/explorerModel.test.ts

@@ -10,18 +10,11 @@ import { join } from 'vs/base/common/path';
 import { validateFileName } from 'vs/workbench/contrib/files/browser/fileActions';
 import { ExplorerItem } from 'vs/workbench/contrib/files/common/explorerModel';
 import { toResource } from 'vs/base/test/common/utils';
-import { hasToIgnoreCase } from 'vs/base/common/resources';
-import { IExplorerService } from 'vs/workbench/contrib/files/common/files';
-
-class MockExplorerService {
-	shouldIgnoreCase(resource: URI) {
-		return hasToIgnoreCase(resource);
-	}
-}
-const mockExplorerService = new MockExplorerService() as IExplorerService;
+import { TestFileService } from 'vs/workbench/test/workbenchTestServices';
 
+const fileService = new TestFileService();
 function createStat(this: any, path: string, name: string, isFolder: boolean, hasChildren: boolean, size: number, mtime: number): ExplorerItem {
-	return new ExplorerItem(toResource.call(this, path), mockExplorerService, undefined, isFolder, false, false, name, mtime);
+	return new ExplorerItem(toResource.call(this, path), fileService, undefined, isFolder, false, name, mtime);
 }
 
 suite('Files - View Model', function () {
@@ -252,19 +245,19 @@ suite('Files - View Model', function () {
 	});
 
 	test('Merge Local with Disk', function () {
-		const merge1 = new ExplorerItem(URI.file(join('C:\\', '/path/to')), mockExplorerService, undefined, true, false, false, 'to', Date.now());
-		const merge2 = new ExplorerItem(URI.file(join('C:\\', '/path/to')), mockExplorerService, undefined, true, false, false, 'to', Date.now());
+		const merge1 = new ExplorerItem(URI.file(join('C:\\', '/path/to')), fileService, undefined, true, false, 'to', Date.now());
+		const merge2 = new ExplorerItem(URI.file(join('C:\\', '/path/to')), fileService, undefined, true, false, 'to', Date.now());
 
 		// Merge Properties
 		ExplorerItem.mergeLocalWithDisk(merge2, merge1);
 		assert.strictEqual(merge1.mtime, merge2.mtime);
 
 		// Merge Child when isDirectoryResolved=false is a no-op
-		merge2.addChild(new ExplorerItem(URI.file(join('C:\\', '/path/to/foo.html')), mockExplorerService, undefined, true, false, false, 'foo.html', Date.now()));
+		merge2.addChild(new ExplorerItem(URI.file(join('C:\\', '/path/to/foo.html')), fileService, undefined, true, false, 'foo.html', Date.now()));
 		ExplorerItem.mergeLocalWithDisk(merge2, merge1);
 
 		// Merge Child with isDirectoryResolved=true
-		const child = new ExplorerItem(URI.file(join('C:\\', '/path/to/foo.html')), mockExplorerService, undefined, true, false, false, 'foo.html', Date.now());
+		const child = new ExplorerItem(URI.file(join('C:\\', '/path/to/foo.html')), fileService, undefined, true, false, 'foo.html', Date.now());
 		merge2.removeChild(child);
 		merge2.addChild(child);
 		(<any>merge2)._isDirectoryResolved = true;