[json] language server & client as extension

extensions/json/server/src/server.ts

@@ -0,0 +1,237 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+'use strict';
+
+import {
+	IPCMessageReader, IPCMessageWriter,
+	createConnection, IConnection, TextDocumentSyncKind,
+	TextDocuments, ITextDocument, Diagnostic, DiagnosticSeverity,
+	InitializeParams, InitializeResult, TextDocumentIdentifier, TextDocumentPosition,
+	CompletionItem, CompletionItemKind, Files, Hover, SymbolInformation, TextEdit, DocumentFormattingParams,
+	DocumentRangeFormattingParams, NotificationType
+} from 'vscode-languageserver';
+
+import {xhr, IXHROptions, IXHRResponse} from './utils/httpRequest';
+import path = require('path');
+import fs = require('fs');
+import URI from './utils/uri';
+import Strings = require('./utils/strings');
+import {create as createLinesModel, LinesModel} from './utils/lines';
+import {IWorkspaceContextService, ITelemetryService, JSONSchemaService, ISchemaContributions} from './jsonSchemaService';
+import {parse as parseJSON, ObjectASTNode, JSONDocument} from './jsonParser';
+import {JSONCompletion} from './jsonCompletion';
+import {JSONHover} from './jsonHover';
+import {JSONDocumentSymbols} from './jsonDocumentSymbols';
+import {format as formatJSON} from './jsonFormatter';
+import {schemaContributions} from './configuration';
+
+namespace TelemetryNotification {
+	export const type: NotificationType<{ key: string, data: any }> = { get method() { return 'telemetry'; } };
+}
+
+// Create a connection for the server. The connection uses for
+// stdin / stdout for message passing
+let connection: IConnection = createConnection(new IPCMessageReader(process), new IPCMessageWriter(process));
+
+// Create a simple text document manager. The text document manager
+// supports full document sync only
+let documents: TextDocuments = new TextDocuments();
+// Make the text document manager listen on the connection
+// for open, change and close text document events
+documents.listen(connection);
+
+
+// After the server has started the client sends an initilize request. The server receives
+// in the passed params the rootPath of the workspace plus the client capabilites.
+let workspaceRoot: URI;
+connection.onInitialize((params): InitializeResult => {
+	workspaceRoot = URI.parse(params.rootPath);
+	return {
+		capabilities: {
+			// Tell the client that the server works in FULL text document sync mode
+			textDocumentSync: documents.syncKind,
+			completionProvider: { resolveProvider: false },
+			hoverProvider: true,
+			documentSymbolProvider: true,
+			documentRangeFormattingProvider: true,
+			documentFormattingProvider: true
+		}
+	}
+});
+
+let workspaceContext = {
+	toResource: (workspaceRelativePath: string) => {
+		if (typeof workspaceRelativePath === 'string' && workspaceRoot) {
+			return URI.file(path.join(workspaceRoot.fsPath, workspaceRelativePath)).toString();
+		}
+		return workspaceRelativePath;
+	}
+}
+
+let telemetry = {
+	log: (key: string, data: any) => {
+		connection.sendNotification(TelemetryNotification.type, { key, data });
+	}
+}
+
+let request = (options: IXHROptions): Promise<IXHRResponse>  => {
+	if (options.url.indexOf('file://') === 0) {
+		let fsPath = URI.parse(options.url).fsPath;
+		return new Promise<IXHRResponse>((c, e) => {
+			fs.readFile(fsPath, 'UTF-8', (err, result) => {
+				err ? e({ responseText: '', status: 404 }) : c({ responseText: result.toString(), status: 200 })
+			});
+		});
+	}
+	return xhr(options);
+}
+
+let jsonSchemaService = new JSONSchemaService(request, workspaceContext, telemetry);
+jsonSchemaService.setSchemaContributions(schemaContributions);
+
+let jsonCompletion = new JSONCompletion(jsonSchemaService);
+let jsonHover = new JSONHover(jsonSchemaService);
+let jsonDocumentSymbols = new JSONDocumentSymbols();
+
+// The content of a text document has changed. This event is emitted
+// when the text document first opened or when its content has changed.
+documents.onDidChangeContent((change) => {
+	validateTextDocument(change.document);
+});
+
+// The settings interface describe the server relevant settings part
+interface Settings {
+	json: JSONSettings;
+}
+
+interface JSONSettings {
+	schemas: [{ fileMatch: string[], url: string, schema: any }];
+}
+
+// The settings have changed. Is send on server activation as well.
+connection.onDidChangeConfiguration((change) => {
+	let jsonSettings = (<Settings>change.settings).json;
+
+	if (jsonSettings && jsonSettings.schemas) {
+		jsonSchemaService.clearExternalSchemas();
+		jsonSettings.schemas.forEach((schema) => {
+			if (schema.url && (schema.fileMatch || schema.schema)) {
+				let url = schema.url;
+				if (!Strings.startsWith(url, 'http://') && !Strings.startsWith(url, 'https://') && !Strings.startsWith(url, 'file://')) {
+					let resourceURL = workspaceContext.toResource(url);
+					if (resourceURL) {
+						url = resourceURL.toString();
+					}
+				}
+				if (url) {
+					jsonSchemaService.registerExternalSchema(url, schema.fileMatch, schema.schema);
+				}
+			}
+		});
+	}
+
+	// Revalidate any open text documents
+	documents.all().forEach(validateTextDocument);
+});
+
+function validateTextDocument(textDocument: ITextDocument): void {
+	let jsonDocument = getJSONDocument(textDocument);
+	jsonSchemaService.getSchemaForResource(textDocument.uri, jsonDocument).then(schema => {
+		if (schema) {
+			if (schema.errors.length && jsonDocument.root) {
+				let astRoot = jsonDocument.root;
+				let property = astRoot.type === 'object' ? (<ObjectASTNode>astRoot).getFirstProperty('$schema') : null;
+				if (property) {
+					let node = property.value || property;
+					jsonDocument.warnings.push({ location: { start: node.start, end: node.end }, message: schema.errors[0] });
+				} else {
+					jsonDocument.warnings.push({ location: { start: astRoot.start, end: astRoot.start + 1 }, message: schema.errors[0] });
+				}
+			} else {
+				jsonDocument.validate(schema.schema);
+			}
+		}
+
+		let diagnostics: Diagnostic[] = [];
+		let lineModel = getLinesModel(textDocument);
+		let added: { [signature: string]: boolean } = {};
+		jsonDocument.errors.concat(jsonDocument.warnings).forEach((error, idx) => {
+			// remove duplicated messages
+			let signature = error.location.start + ' ' + error.location.end + ' ' + error.message;
+			if (!added[signature]) {
+				added[signature] = true;
+				let range = {
+					start: lineModel.positionAt(error.location.start),
+					end: lineModel.positionAt(error.location.end)
+				};
+				diagnostics.push({
+					severity: idx >= jsonDocument.errors.length ? DiagnosticSeverity.Warning : DiagnosticSeverity.Error,
+					range: range,
+					message: error.message
+				});
+			}
+		});
+		// Send the computed diagnostics to VSCode.
+		connection.sendDiagnostics({ uri: textDocument.uri, diagnostics });
+	});
+}
+
+connection.onDidChangeWatchedFiles((change) => {
+	// Monitored files have change in VSCode
+	let hasChanges = false;
+	change.changes.forEach(c => {
+		if (jsonSchemaService.onResourceChange(c.uri)) {
+			hasChanges = true;
+		}
+	});
+	if (hasChanges) {
+		documents.all().forEach(validateTextDocument);
+	}
+});
+
+
+function getLinesModel(document: ITextDocument): LinesModel {
+	return createLinesModel(document.getText());
+}
+
+function getJSONDocument(document: ITextDocument): JSONDocument {
+	return parseJSON(document.getText());
+}
+
+connection.onCompletion((textDocumentPosition: TextDocumentPosition): Thenable<CompletionItem[]> => {
+	let document = documents.get(textDocumentPosition.uri);
+	let lines = getLinesModel(document);
+	let jsonDocument = getJSONDocument(document);
+	return jsonCompletion.doSuggest(document, textDocumentPosition, lines, jsonDocument);
+});
+
+connection.onHover((textDocumentPosition: TextDocumentPosition): Thenable<Hover> => {
+	let document = documents.get(textDocumentPosition.uri);
+	let lines = getLinesModel(document);
+	let jsonDocument = getJSONDocument(document);
+	return jsonHover.doHover(document, textDocumentPosition, lines, jsonDocument);
+});
+
+connection.onDocumentSymbol((textDocumentIdentifier: TextDocumentIdentifier): Thenable<SymbolInformation[]> => {
+	let document = documents.get(textDocumentIdentifier.uri);
+	let lines = getLinesModel(document);
+	let jsonDocument = getJSONDocument(document);
+	return jsonDocumentSymbols.compute(document, lines, jsonDocument);
+});
+
+connection.onDocumentFormatting((formatParams: DocumentFormattingParams) => {
+	let document = documents.get(formatParams.textDocument.uri);
+	let lines = getLinesModel(document);
+	return formatJSON(document, lines, null, formatParams.options);
+});
+
+connection.onDocumentRangeFormatting((formatParams: DocumentRangeFormattingParams) => {
+	let document = documents.get(formatParams.textDocument.uri);
+	let lines = getLinesModel(document);
+	return formatJSON(document, lines, formatParams.range, formatParams.options);
+});
+
+// Listen on the connection
+connection.listen();