TypeScript TextDocument.create方法代码示例

function assertStyleSheet(input: string, ...rules: Rule[]): void {
	let p = new Parser();
	let document = TextDocument.create('test://test/test.css', 'css', 0, input);
	let node = p.parseStylesheet(document);

	assertEntries(node, rules);
}

	function getOutline(value: string): Promise<SymbolInformation[]> {
		var uri = 'test://test.json';

		var symbolProvider = new JSONDocumentSymbols();

		var document = TextDocument.create(uri, 'json', 0, value);
		var jsonDoc = Parser.parse(value);
		return symbolProvider.findDocumentSymbols(document, jsonDoc);
	}

export function assertColor(parser: Parser, text: string, selection: string, isColor: boolean): void {
	let document = TextDocument.create('test://test/test.css', 'css', 0, text);
	let stylesheet = parser.parseStylesheet(document);
	assert.equal(0, nodes.ParseErrorCollector.entries(stylesheet).length, 'compile errors');

	let node = nodes.getNodeAtOffset(stylesheet, text.indexOf(selection));

	assert.equal(isColor, languageFacts.isColorValue(node));
}

export function parseSelector(p: Parser, input: string, selectorName: string, expected: string): void {
	let document = TextDocument.create('test://test/test.css', 'css', 0, input);
	let styleSheet = p.parseStylesheet(document);

	let node = nodes.getNodeAtOffset(styleSheet, input.indexOf(selectorName));
	let selector = node.findParent(nodes.NodeType.Selector);

	let element = selectorPrinter.selectorToElement(selector);
	assert.equal(elementToString(element), expected);
}

function createScope(p: Parser, input: string): Scope {
	let document = TextDocument.create('test://test/test.css', 'css', 0, input);

	let styleSheet = p.parseStylesheet(document),
		global = new GlobalScope(),
		builder = new ScopeBuilder(global);

	assertNoErrors(styleSheet);
	styleSheet.accept(builder);
	return global;
}

function assertRanges(lines: string[], expected: ExpectedIndentRange[], nRanges?: number): void {
	let document = TextDocument.create('test://foo/bar.json', 'json', 1, lines.join('\n'));
	let actual = getFoldingRegions(document, nRanges, null)!.ranges;

	let actualRanges = [];
	for (let i = 0; i < actual.length; i++) {
		actualRanges[i] = r(actual[i].startLine, actual[i].endLine, actual[i].type);
	}
	actualRanges = actualRanges.sort((r1, r2) => r1.startLine - r2.startLine);
	assert.deepEqual(actualRanges, expected);
}

 it('should return the info of the symbol at the position', () => {
     let ghcModOutput = ['Symbol', 'Info'];
     let position = Position.create(0, 5);
     let logger: ILogger = new TestLogger();
     let ghcMod: IGhcMod = new TestGhcMod(ghcModOutput);
     let provider: IGhcModProvider = new GhcModProvider(ghcMod,  '', logger );
     let document: TextDocument = TextDocument.create('uri', 'languageId', 1, 'Any text');
     return provider.getInfo(document, null, position, false).then((info) => {
         assert.equal(info, 'Symbol\nInfo');
     });
 });

	function format(unformatted: string, expected: string, insertSpaces = true) {
		let range: Range = null;
		let uri = 'test://test.json';

		let rangeStart = unformatted.indexOf('|');
		let rangeEnd = unformatted.lastIndexOf('|');
		if (rangeStart !== -1 && rangeEnd !== -1) {
			// remove '|'
			var unformattedDoc = TextDocument.create(uri, 'json', 0, unformatted);
			unformatted = unformatted.substring(0, rangeStart) + unformatted.substring(rangeStart + 1, rangeEnd) + unformatted.substring(rangeEnd + 1);
			let startPos = unformattedDoc.positionAt(rangeStart);
			let endPos = unformattedDoc.positionAt(rangeEnd);
			range = Range.create(startPos, endPos);
		}

		var document = TextDocument.create(uri, 'json', 0, unformatted);
		let edits = Formatter.format(document, range, { tabSize: 2, insertSpaces: insertSpaces });
		let formatted  = applyEdits(document, edits);
		assert.equal(formatted, expected);
	}

	function testComputeInfo(value: string, schema: JsonSchema.IJSONSchema, position: Position): Thenable<Hover> {
		var uri = 'test://test.json';

		var schemaService = new SchemaService.JSONSchemaService(requestService);
		var hoverProvider = new JSONHover(schemaService);
		var id = "http://myschemastore/test1";
		schemaService.registerExternalSchema(id, ["*.json"], schema);

		var document = TextDocument.create(uri, 'json', 0, value);
		var jsonDoc = Parser.parse(value);
		return hoverProvider.doHover(document, position, jsonDoc);
	}

function assertRanges(lines: string[], expected: ExpectedIndentRange[], message?: string, nRanges?: number): void {
	let document = TextDocument.create('test://foo/bar.json', 'json', 1, lines.join('\n'));
	let workspace = {
		settings: {},
		folders: [{ name: 'foo', uri: 'test://foo' }]
	};
	let languageModes = getLanguageModes({ css: true, javascript: true }, workspace);
	let actual = getFoldingRanges(languageModes, document, nRanges, null);

	let actualRanges = [];
	for (let i = 0; i < actual.length; i++) {
		actualRanges[i] = r(actual[i].startLine, actual[i].endLine, actual[i].kind);
	}
	actualRanges = actualRanges.sort((r1, r2) => r1.startLine - r2.startLine);
	assert.deepEqual(actualRanges, expected, message);
}