Rename markdown to markdown-language-features

extensions/markdown-language-features/src/test/foldingProvider.test.ts

@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+import 'mocha';
+
+import { MarkdownEngine } from '../markdownEngine';
+import { MarkdownContributions } from '../markdownExtensions';
+import MarkdownFoldingProvider from '../features/foldingProvider';
+import { InMemoryDocument } from './inMemoryDocument';
+
+const testFileName = vscode.Uri.parse('test.md');
+
+suite('markdown.FoldingProvider', () => {
+	test('Should not return anything for empty document', async () => {
+		const folds = await getFoldsForDocument(``);
+		assert.strictEqual(folds.ranges.length, 0);
+	});
+
+	test('Should not return anything for document without headers', async () => {
+		const folds = await getFoldsForDocument(`a
+**b** afas
+a#b
+a`);
+		assert.strictEqual(folds.ranges.length, 0);
+	});
+
+	test('Should fold from header to end of document', async () => {
+		const folds = await getFoldsForDocument(`a
+# b
+c
+d`);
+		assert.strictEqual(folds.ranges.length, 1);
+		const firstFold = folds.ranges[0];
+		assert.strictEqual(firstFold.startLine, 1);
+		assert.strictEqual(firstFold.endLine, 3);
+	});
+
+	test('Should leave single newline before next header', async () => {
+		const folds = await getFoldsForDocument(`
+# a
+x
+
+# b
+y`);
+		assert.strictEqual(folds.ranges.length, 2);
+		const firstFold = folds.ranges[0];
+		assert.strictEqual(firstFold.startLine, 1);
+		assert.strictEqual(firstFold.endLine, 3);
+	});
+
+	test('Should collapse multuple newlines to single newline before next header', async () => {
+		const folds = await getFoldsForDocument(`
+# a
+x
+
+
+
+# b
+y`);
+		assert.strictEqual(folds.ranges.length, 2);
+		const firstFold = folds.ranges[0];
+		assert.strictEqual(firstFold.startLine, 1);
+		assert.strictEqual(firstFold.endLine, 5);
+	});
+
+	test('Should not collapse if there is no newline before next header', async () => {
+		const folds = await getFoldsForDocument(`
+# a
+x
+# b
+y`);
+		assert.strictEqual(folds.ranges.length, 2);
+		const firstFold = folds.ranges[0];
+		assert.strictEqual(firstFold.startLine, 1);
+		assert.strictEqual(firstFold.endLine, 2);
+	});
+
+});
+
+
+async function getFoldsForDocument(contents: string) {
+	const doc = new InMemoryDocument(testFileName, contents);
+	const provider = new MarkdownFoldingProvider(newEngine());
+	return await provider.provideFoldingRanges(doc, {}, new vscode.CancellationTokenSource().token);
+}
+
+function newEngine(): MarkdownEngine {
+	return new MarkdownEngine(new class implements MarkdownContributions {
+		readonly previewScripts: vscode.Uri[] = [];
+		readonly previewStyles: vscode.Uri[] = [];
+		readonly previewResourceRoots: vscode.Uri[] = [];
+		readonly markdownItPlugins: Promise<(md: any) => any>[]  = [];
+	});
+}
+

extensions/markdown-language-features/src/test/inMemoryDocument.ts

@@ -0,0 +1,61 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+
+export class InMemoryDocument implements vscode.TextDocument {
+	private readonly _lines: string[];
+
+	constructor(
+		public readonly uri: vscode.Uri,
+		private readonly _contents: string
+	) {
+		this._lines = this._contents.split(/\n/g);
+	}
+
+	fileName: string = '';
+	isUntitled: boolean = false;
+	languageId: string = '';
+	version: number = 1;
+	isDirty: boolean = false;
+	isClosed: boolean = false;
+	eol: vscode.EndOfLine = vscode.EndOfLine.LF;
+
+	get lineCount(): number {
+		return this._lines.length;
+	}
+
+	lineAt(line: any): vscode.TextLine {
+		return {
+			lineNumber: line,
+			text: this._lines[line],
+			range: new vscode.Range(0, 0, 0, 0),
+			firstNonWhitespaceCharacterIndex: 0,
+			rangeIncludingLineBreak: new vscode.Range(0, 0, 0, 0),
+			isEmptyOrWhitespace: false
+		};
+	}
+	offsetAt(_position: vscode.Position): never {
+		throw new Error('Method not implemented.');
+	}
+	positionAt(_offset: number): never {
+		throw new Error('Method not implemented.');
+	}
+	getText(_range?: vscode.Range | undefined): string {
+		return this._contents;
+	}
+	getWordRangeAtPosition(_position: vscode.Position, _regex?: RegExp | undefined): never {
+		throw new Error('Method not implemented.');
+	}
+	validateRange(_range: vscode.Range): never {
+		throw new Error('Method not implemented.');
+	}
+	validatePosition(_position: vscode.Position): never {
+		throw new Error('Method not implemented.');
+	}
+	save(): never {
+		throw new Error('Method not implemented.');
+	}
+}

extensions/markdown-language-features/src/test/index.ts

@@ -0,0 +1,28 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+//
+// PLEASE DO NOT MODIFY / DELETE UNLESS YOU KNOW WHAT YOU ARE DOING
+//
+// This file is providing the test runner to use when running extension tests.
+// By default the test runner in use is Mocha based.
+//
+// You can provide your own test runner if you want to override it by exporting
+// a function run(testRoot: string, clb: (error:Error) => void) that the extension
+// host can call to run the tests. The test runner is expected to use console.log
+// to report the results back to the caller. When the tests are finished, return
+// a possible error to the callback or null if none.
+
+const testRunner = require('vscode/lib/testrunner');
+
+// You can directly control Mocha options by uncommenting the following lines
+// See https://github.com/mochajs/mocha/wiki/Using-mocha-programmatically#set-options for more info
+testRunner.configure({
+	ui: 'tdd', 		// the TDD UI is being used in extension.test.ts (suite, test, etc.)
+	useColors: process.platform !== 'win32', // colored output from test results (only windows cannot handle)
+	timeout: 60000
+});
+
+export = testRunner;

extensions/markdown-language-features/src/test/tableOfContentsProvider.test.ts

@@ -0,0 +1,96 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+import 'mocha';
+
+import { TableOfContentsProvider } from '../tableOfContentsProvider';
+import { MarkdownEngine } from '../markdownEngine';
+import { MarkdownContributions } from '../markdownExtensions';
+import { InMemoryDocument } from './inMemoryDocument';
+
+const testFileName = vscode.Uri.parse('test.md');
+
+suite('markdown.TableOfContentsProvider', () => {
+	test('Lookup should not return anything for empty document', async () => {
+		const doc = new InMemoryDocument(testFileName, '');
+		const provider = new TableOfContentsProvider(newEngine(), doc);
+
+		assert.strictEqual(await provider.lookup(''), undefined);
+		assert.strictEqual(await provider.lookup('foo'), undefined);
+	});
+
+	test('Lookup should not return anything for document with no headers', async () => {
+		const doc = new InMemoryDocument(testFileName, 'a *b*\nc');
+		const provider = new TableOfContentsProvider(newEngine(), doc);
+
+		assert.strictEqual(await provider.lookup(''), undefined);
+		assert.strictEqual(await provider.lookup('foo'), undefined);
+		assert.strictEqual(await provider.lookup('a'), undefined);
+		assert.strictEqual(await provider.lookup('b'), undefined);
+	});
+
+	test('Lookup should return basic #header', async () => {
+		const doc = new InMemoryDocument(testFileName, `# a\nx\n# c`);
+		const provider = new TableOfContentsProvider(newEngine(), doc);
+
+		{
+			const entry = await provider.lookup('a');
+			assert.ok(entry);
+			assert.strictEqual(entry!.line, 0);
+		}
+		{
+			assert.strictEqual(await provider.lookup('x'), undefined);
+		}
+		{
+			const entry = await provider.lookup('c');
+			assert.ok(entry);
+			assert.strictEqual(entry!.line, 2);
+		}
+	});
+
+	test('Lookups should be case in-sensitive', async () => {
+		const doc = new InMemoryDocument(testFileName, `# fOo\n`);
+		const provider = new TableOfContentsProvider(newEngine(), doc);
+
+		assert.strictEqual((await provider.lookup('fOo'))!.line, 0);
+		assert.strictEqual((await provider.lookup('foo'))!.line, 0);
+		assert.strictEqual((await provider.lookup('FOO'))!.line, 0);
+	});
+
+	test('Lookups should ignore leading and trailing white-space, and collapse internal whitespace', async () => {
+		const doc = new InMemoryDocument(testFileName, `#      f o  o    \n`);
+		const provider = new TableOfContentsProvider(newEngine(), doc);
+
+		assert.strictEqual((await provider.lookup('f o  o'))!.line, 0);
+		assert.strictEqual((await provider.lookup('  f o  o'))!.line, 0);
+		assert.strictEqual((await provider.lookup('  f o  o  '))!.line, 0);
+		assert.strictEqual((await provider.lookup('f o o'))!.line, 0);
+		assert.strictEqual((await provider.lookup('f o       o'))!.line, 0);
+
+		assert.strictEqual(await provider.lookup('f'), undefined);
+		assert.strictEqual(await provider.lookup('foo'), undefined);
+		assert.strictEqual(await provider.lookup('fo o'), undefined);
+	});
+
+	test('should normalize special characters #44779', async () => {
+		const doc = new InMemoryDocument(testFileName, `# Indentação\n`);
+		const provider = new TableOfContentsProvider(newEngine(), doc);
+
+		assert.strictEqual((await provider.lookup('indentacao'))!.line, 0);
+	});
+});
+
+function newEngine(): MarkdownEngine {
+	return new MarkdownEngine(new class implements MarkdownContributions {
+		readonly previewScripts: vscode.Uri[] = [];
+		readonly previewStyles: vscode.Uri[] = [];
+		readonly previewResourceRoots: vscode.Uri[] = [];
+		readonly markdownItPlugins: Promise<(md: any) => any>[]  = [];
+
+	});
+}
+