Add explorer.autorevealExclude setting

Author: jzyrobert

extensions/configuration-editing/src/settingsDocumentHelper.ts

@@ -28,8 +28,8 @@ export class SettingsDocument {
 			return this.provideFilesAssociationsCompletionItems(location, range);
 		}
 
-		// files.exclude, search.exclude
-		if (location.path[0] === 'files.exclude' || location.path[0] === 'search.exclude') {
+		// files.exclude, search.exclude, explorer.autorevealExclude
+		if (location.path[0] === 'files.exclude' || location.path[0] === 'search.exclude' || location.path[0] === 'explorer.autorevealExclude') {
 			return this.provideExcludeCompletionItems(location, range);
 		}
 

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

@@ -5,7 +5,7 @@
 
 import { Event } from 'vs/base/common/event';
 import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace';
-import { DisposableStore } from 'vs/base/common/lifecycle';
+import { DisposableStore, dispose } from 'vs/base/common/lifecycle';
 import { IFilesConfiguration, ISortOrderConfiguration, SortOrder, LexicographicOptions } from 'vs/workbench/contrib/files/common/files';
 import { ExplorerItem, ExplorerModel } from 'vs/workbench/contrib/files/common/explorerModel';
 import { URI } from 'vs/base/common/uri';
@@ -23,6 +23,12 @@ import { IProgressService, ProgressLocation, IProgressNotificationOptions, IProg
 import { CancellationTokenSource } from 'vs/base/common/cancellation';
 import { RunOnceScheduler } from 'vs/base/common/async';
 import { IHostService } from 'vs/workbench/services/host/browser/host';
+import { IExpression, parse } from 'vs/base/common/glob';
+import { mixin, deepClone, equals } from 'vs/base/common/objects';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { CachedParsedExpression } from 'vs/workbench/contrib/files/browser/views/explorerViewer';
+import { Emitter } from 'vs/base/common/event';
+import { relative } from 'path';
 
 export const UNDO_REDO_SOURCE = new UndoRedoSource();
 
@@ -40,6 +46,7 @@ export class ExplorerService implements IExplorerService {
 	private model: ExplorerModel;
 	private onFileChangesScheduler: RunOnceScheduler;
 	private fileChangeEvents: FileChangesEvent[] = [];
+	private revealExcludeMatcher: RevealFilter;
 
 	constructor(
 		@IFileService private fileService: IFileService,
@@ -128,6 +135,10 @@ export class ExplorerService implements IExplorerService {
 		}));
 		// Refresh explorer when window gets focus to compensate for missing file events #126817
 		this.disposables.add(hostService.onDidChangeFocus(hasFocus => hasFocus ? this.refresh(false) : undefined));
+		this.revealExcludeMatcher = new RevealFilter(
+			contextService, configurationService);
+		this.disposables.add(this.revealExcludeMatcher);
+		this.disposables.add(this.revealExcludeMatcher.onDidChange(() => this.refresh()))
 	}
 
 	get roots(): ExplorerItem[] {
@@ -232,7 +243,7 @@ export class ExplorerService implements IExplorerService {
 		}
 
 		const fileStat = this.findClosest(resource);
-		if (fileStat) {
+		if (fileStat && this.revealExcludeMatcher.shouldReveal(fileStat)) {
 			await this.view.selectResource(fileStat.resource, reveal);
 			return Promise.resolve(undefined);
 		}
@@ -255,6 +266,9 @@ export class ExplorerService implements IExplorerService {
 			await this.view.refresh(true, root);
 
 			// Select and Reveal
+			if (item && reveal && !this.revealExcludeMatcher.shouldReveal(item)) {
+				return;
+			}
 			await this.view.selectResource(item ? item.resource : undefined, reveal);
 		} catch (error) {
 			root.isError = true;
@@ -399,3 +413,95 @@ function doesFileEventAffect(item: ExplorerItem, view: IExplorerView, events: Fi
 
 	return false;
 }
+
+/**
+ * Respects explorer.autoRevealExclude setting in filtering out content from being revealed when opened in the editor.
+ */
+class RevealFilter implements IDisposable {
+	private revealExpressionPerRoot = new Map<string, CachedParsedExpression>();
+	private _onDidChange = new Emitter<void>();
+	private toDispose: IDisposable[] = [];
+
+	constructor(
+		@IWorkspaceContextService private readonly contextService: IWorkspaceContextService,
+		@IConfigurationService private readonly configurationService: IConfigurationService,
+	) {
+		this.toDispose.push(this.contextService.onDidChangeWorkspaceFolders(() => this.updateConfiguration()));
+		this.toDispose.push(this.configurationService.onDidChangeConfiguration((e) => {
+			if (e.affectsConfiguration('explorer.autoRevealExclude')) {
+				this.updateConfiguration();
+			}
+		}));
+		this.updateConfiguration();
+	}
+
+	get onDidChange(): Event<void> {
+		return this._onDidChange.event;
+	}
+
+	private updateConfiguration(): void {
+		let shouldFire = false;
+		this.contextService.getWorkspace().folders.forEach(folder => {
+			const configuration = this.configurationService.getValue<IFilesConfiguration>({ resource: folder.uri });
+			const excludesConfig: IExpression = getRevealExcludes(configuration, true) || Object.create(null)
+
+			if (!shouldFire) {
+				const cached = this.revealExpressionPerRoot.get(folder.uri.toString());
+				shouldFire = !cached || !equals(cached.original, excludesConfig);
+			}
+
+			const excludesConfigCopy = deepClone(excludesConfig); // do not keep the config, as it gets mutated under our hoods
+
+			this.revealExpressionPerRoot.set(folder.uri.toString(), { original: excludesConfigCopy, parsed: parse(excludesConfigCopy) });
+		});
+
+		if (shouldFire) {
+			this._onDidChange.fire();
+		}
+	}
+
+	shouldReveal(item: ExplorerItem): boolean {
+		// Check whether file or parent matches pattern
+		const cached = this.revealExpressionPerRoot.get(item.root.resource.toString());
+		if (!cached) {
+			return true;
+		}
+		const root = item.root;
+		let currentItem = item;
+		// If any parent up to the root matches pattern, do not reveal
+		while (currentItem != root) {
+			if (cached.parsed(relative(currentItem.root.resource.path, currentItem.resource.path), currentItem.name, name => !!(currentItem.parent && currentItem.parent.getChild(name)))) {
+				return false;
+			}
+			if (!currentItem.parent) {
+				return true;
+			};
+			currentItem = currentItem.parent;
+		}
+		return true;
+	}
+
+	dispose(): void {
+		dispose(this.toDispose);
+	}
+}
+
+function getRevealExcludes(configuration: IFilesConfiguration, includeRevealExcludes = true): IExpression | undefined {
+	const fileExcludes = configuration && configuration.files && configuration.files.exclude;
+	const revealExcludes = includeRevealExcludes && configuration && configuration.explorer && configuration.explorer.autoRevealExclude;
+
+	if (!fileExcludes && !revealExcludes) {
+		return undefined;
+	}
+
+	if (!fileExcludes || !revealExcludes) {
+		return fileExcludes || revealExcludes;
+	}
+
+	let allExcludes: IExpression = Object.create(null);
+	// clone the config as it could be frozen
+	allExcludes = mixin(allExcludes, deepClone(fileExcludes));
+	allExcludes = mixin(allExcludes, deepClone(revealExcludes), true);
+
+	return allExcludes;
+}

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

@@ -376,6 +376,30 @@ configurationRegistry.registerConfiguration({
 			],
 			'description': nls.localize('autoReveal', "Controls whether the explorer should automatically reveal and select files when opening them.")
 		},
+		'explorer.autoRevealExclude': {
+			'type': 'object',
+			'markdownDescription': nls.localize('autoRevealExclude', "Configure glob patterns for excluding files and folders from being revealed and selected in the explorer when they are opened. Inherits all glob patterns from the `#files.exclude#` setting. Read more about glob patterns [here](https://code.visualstudio.com/docs/editor/codebasics#_advanced-search-options)."),
+			'default': { '**/node_modules': true, '**/bower_components': true, '**/*.code-search': true },
+			'additionalProperties': {
+				'anyOf': [
+					{
+						'type': 'boolean',
+						'description': nls.localize('explorer.autoRevealExclude.boolean', "The glob pattern to match file paths against. Set to true or false to enable or disable the pattern."),
+					},
+					{
+						type: 'object',
+						properties: {
+							when: {
+								type: 'string', // expression ({ "**/*.js": { "when": "$(basename).js" } })
+								pattern: '\\w*\\$\\(basename\\)\\w*',
+								default: '$(basename).ext',
+								description: nls.localize('explorer.autoRevealExclude.when', 'Additional check on the siblings of a matching file. Use $(basename) as variable for the matching file name.')
+							}
+						}
+					}
+				]
+			}
+		},
 		'explorer.enableDragAndDrop': {
 			'type': 'boolean',
 			'description': nls.localize('enableDragAndDrop', "Controls whether the explorer should allow to move files and folders via drag and drop. This setting only effects drag and drop from inside the explorer."),

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

@@ -680,7 +680,7 @@ export class ExplorerView extends ViewPane {
 	}
 
 	public async selectResource(resource: URI | undefined, reveal = this.autoReveal, retry = 0): Promise<void> {
-		// do no retry more than once to prevent inifinite loops in cases of inconsistent model
+		// do no retry more than once to prevent infinite loops in cases of inconsistent model
 		if (retry === 2) {
 			return;
 		}

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

@@ -528,13 +528,13 @@ export class FilesRenderer implements ICompressibleTreeRenderer<ExplorerItem, Fu
 	}
 }
 
-interface CachedParsedExpression {
+export interface CachedParsedExpression {
 	original: glob.IExpression;
 	parsed: glob.ParsedExpression;
 }
 
 /**
- * Respectes files.exclude setting in filtering out content from the explorer.
+ * Respects files.exclude setting in filtering out content from the explorer.
  * Makes sure that visible editors are always shown in the explorer even if they are filtered out by settings.
  */
 export class FilesFilter implements ITreeFilter<ExplorerItem, FuzzyScore> {

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

@@ -21,6 +21,7 @@ import { once } from 'vs/base/common/functional';
 import { ITextEditorOptions } from 'vs/platform/editor/common/editor';
 import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
 import { localize } from 'vs/nls';
+import { IExpression } from 'vs/base/common/glob';
 
 /**
  * Explorer viewlet id.
@@ -86,6 +87,7 @@ export interface IFilesConfiguration extends PlatformIFilesConfiguration, IWorkb
 			sortOrder: 'editorOrder' | 'alphabetical';
 		};
 		autoReveal: boolean | 'focusNoScroll';
+		autoRevealExclude: IExpression;
 		enableDragAndDrop: boolean;
 		confirmDelete: boolean;
 		expandSingleFolderWorkspaces: boolean;

src/vs/workbench/contrib/preferences/browser/settingsTreeModels.ts

@@ -570,9 +570,8 @@ function trimCategoryForGroup(category: string, groupId: string): string {
 }
 
 export function isExcludeSetting(setting: ISetting): boolean {
-	return setting.key === 'files.exclude' ||
-		setting.key === 'search.exclude' ||
-		setting.key === 'files.watcherExclude';
+	return setting.key in
+		['files.exclude', 'search.exclude', 'files.watcherExclude', 'explorer.autoRevealExclude'];
 }
 
 function isObjectRenderableSchema({ type }: IJSONSchema): boolean {