Use fuzzy matching for workspace symbol search

CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## 0.4.0-alpha.9 — Unreleased
+- Use fuzzy matching for workspace symbol search.
+
 ## 0.4.0-alpha.8 — October 31, 2023
 - Fix potential catastrophic backtracking in a regular expression.
 - Fix some false positives for link validation.

src/languageFeatures/workspaceSymbols.ts

@@ -10,6 +10,7 @@ import { Disposable } from '../util/dispose';
 import { IWorkspace } from '../workspace';
 import { MdWorkspaceInfoCache } from '../workspaceCache';
 import { MdDocumentSymbolProvider } from './documentSymbols';
+import { fuzzyContains } from '../util/string';
 
 export class MdWorkspaceSymbolProvider extends Disposable {
 
@@ -33,7 +34,9 @@ export class MdWorkspaceSymbolProvider extends Disposable {
 		}
 
 		const normalizedQueryStr = query.toLowerCase();
-		return allSymbols.flat().filter(symbolInformation => symbolInformation.name.toLowerCase().includes(normalizedQueryStr));
+		return allSymbols.flat().filter(symbolInformation => {
+			return fuzzyContains(symbolInformation.name.toLowerCase(), normalizedQueryStr);
+		});
 	}
 
 	public async provideDocumentSymbolInformation(document: ITextDocument, token: CancellationToken): Promise<lsp.SymbolInformation[]> {

src/test/workspaceSymbol.test.ts

@@ -27,6 +27,13 @@ function getWorkspaceSymbols(store: DisposableStore, workspace: IWorkspace, quer
 	return workspaceSymbolProvider.provideWorkspaceSymbols(query, noopToken);
 }
 
+function assertSymbolsMatch(symbols: readonly lsp.WorkspaceSymbol[], expectedNames: readonly string[]): void {
+	assert.strictEqual(symbols.length, expectedNames.length);
+	for (let i = 0; i < symbols.length; i++) {
+		assert.strictEqual(symbols[i].name, expectedNames[i]);
+	}
+}
+
 suite('Workspace symbols', () => {
 	test('Should not return anything for empty workspace', withStore(async (store) => {
 		const workspace = store.add(new InMemoryWorkspace([]));
@@ -38,10 +45,7 @@ suite('Workspace symbols', () => {
 			new InMemoryDocument(workspacePath('test.md'), `# header1\nabc\n## header2`)
 		]));
 
-		const symbols = await getWorkspaceSymbols(store, workspace, '');
-		assert.strictEqual(symbols.length, 2);
-		assert.strictEqual(symbols[0].name, '# header1');
-		assert.strictEqual(symbols[1].name, '## header2');
+		assertSymbolsMatch(await getWorkspaceSymbols(store, workspace, ''), ['# header1', '## header2']);
 	}));
 
 	test('Should return all content basic workspace', withStore(async (store) => {
@@ -68,10 +72,7 @@ suite('Workspace symbols', () => {
 
 		// Update file
 		workspace.updateDocument(new InMemoryDocument(testFileName, `# new header\nabc\n## header2`, 2 /* version */));
-		const newSymbols = await getWorkspaceSymbols(store, workspace, '');
-		assert.strictEqual(newSymbols.length, 2);
-		assert.strictEqual(newSymbols[0].name, '# new header');
-		assert.strictEqual(newSymbols[1].name, '## header2');
+		assertSymbolsMatch(await getWorkspaceSymbols(store, workspace, ''), ['# new header', '## header2']);
 	}));
 
 	test('Should remove results when file is deleted', withStore(async (store) => {
@@ -112,27 +113,27 @@ suite('Workspace symbols', () => {
 			))
 		]));
 
-		const symbols = await getWorkspaceSymbols(store, workspace, '');
-		assert.strictEqual(symbols.length, 1);
-		assert.strictEqual(symbols[0].name, '# header1');
+		assertSymbolsMatch(await getWorkspaceSymbols(store, workspace, ''), ['# header1']);
 	}));
 
 	test('Should match case insensitively', withStore(async (store) => {
 		const workspace = store.add(new InMemoryWorkspace([
 			new InMemoryDocument(workspacePath('test.md'), `# aBc1\nabc\n## ABc2`)
 		]));
 
-		{
-			const symbols = await getWorkspaceSymbols(store, workspace, 'ABC');
-			assert.strictEqual(symbols.length, 2);
-			assert.strictEqual(symbols[0].name, '# aBc1');
-			assert.strictEqual(symbols[1].name, '## ABc2');
-		}
-		{
-			const symbols = await getWorkspaceSymbols(store, workspace, 'abc');
-			assert.strictEqual(symbols.length, 2);
-			assert.strictEqual(symbols[0].name, '# aBc1');
-			assert.strictEqual(symbols[1].name, '## ABc2');
-		}
+		assertSymbolsMatch(await getWorkspaceSymbols(store, workspace, 'ABC'), ['# aBc1', '## ABc2']);
+		assertSymbolsMatch(await getWorkspaceSymbols(store, workspace, 'abc'), ['# aBc1', '## ABc2']);
+	}));
+
+	test('Should match fuzzyily', withStore(async (store) => {
+		const workspace = store.add(new InMemoryWorkspace([
+			new InMemoryDocument(workspacePath('test.md'), `# cat dog fish`)
+		]));
+
+		assertSymbolsMatch(await getWorkspaceSymbols(store, workspace, 'cat'), ['# cat dog fish']);
+		assertSymbolsMatch(await getWorkspaceSymbols(store, workspace, 'cdf'), ['# cat dog fish']);
+		assertSymbolsMatch(await getWorkspaceSymbols(store, workspace, 'catfish'), ['# cat dog fish']);
+		assertSymbolsMatch(await getWorkspaceSymbols(store, workspace, 'fishcat'), []); // wrong order
+		assertSymbolsMatch(await getWorkspaceSymbols(store, workspace, 'ccat'), []); 
 	}));
 });

src/util/string.ts

@@ -8,3 +8,31 @@ export function isEmptyOrWhitespace(str: string): boolean {
 }
 
 export const r = String.raw;
+
+/**
+ * Checks if the characters of the provided query string are included in the
+ * target string. The characters do not have to be contiguous within the string.
+ */
+export function fuzzyContains(target: string, query: string): boolean {
+	if (target.length < query.length) {
+		return false; // impossible for query to be contained in target
+	}
+
+	const queryLen = query.length;
+	const targetLower = target.toLowerCase();
+
+	let index = 0;
+	let lastIndexOf = -1;
+	while (index < queryLen) {
+		const indexOf = targetLower.indexOf(query[index], lastIndexOf + 1);
+		if (indexOf < 0) {
+			return false;
+		}
+
+		lastIndexOf = indexOf;
+
+		index++;
+	}
+
+	return true;
+}