[add] files

server/src/server.ts

@@ -0,0 +1,279 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+import {
+	createConnection,
+	TextDocuments,
+	Diagnostic,
+	DiagnosticSeverity,
+	ProposedFeatures,
+	InitializeParams,
+	DidChangeConfigurationNotification,
+	CompletionItem,
+	CompletionItemKind,
+	TextDocumentPositionParams,
+	TextDocumentSyncKind,
+	InitializeResult,
+	Position,
+} from 'vscode-languageserver';
+
+// import * as path from 'path';
+
+import { TextDocument } from 'vscode-languageserver-textdocument';
+
+// Create a connection for the server. The connection uses Node's IPC as a transport.
+// Also include all preview / proposed LSP features.
+let connection = createConnection(ProposedFeatures.all);
+
+
+// Create a simple text document manager. The text document manager
+// supports full document sync only
+let documents: TextDocuments<TextDocument> = new TextDocuments(TextDocument);
+
+let hasConfigurationCapability: boolean = false;
+let hasWorkspaceFolderCapability: boolean = false;
+let hasDiagnosticRelatedInformationCapability: boolean = false;
+
+connection.onInitialize((params: InitializeParams) => {
+	let capabilities = params.capabilities;
+
+	// Does the client support the `workspace/configuration` request?
+	// If not, we will fall back using global settings
+	hasConfigurationCapability = !!(
+		capabilities.workspace && !!capabilities.workspace.configuration
+	);
+	hasWorkspaceFolderCapability = !!(
+		capabilities.workspace && !!capabilities.workspace.workspaceFolders
+	);
+	hasDiagnosticRelatedInformationCapability = !!(
+		capabilities.textDocument &&
+		capabilities.textDocument.publishDiagnostics &&
+		capabilities.textDocument.publishDiagnostics.relatedInformation
+	);
+
+	const result: InitializeResult = {
+		capabilities: {
+			textDocumentSync: TextDocumentSyncKind.Incremental,
+			// Tell the client that the server supports code completion
+			completionProvider: {
+				resolveProvider: false,
+				triggerCharacters: ['.'],
+			},
+		},
+	};
+	if (hasWorkspaceFolderCapability) {
+		result.capabilities.workspace = {
+			workspaceFolders: {
+				supported: true,
+			},
+		};
+	}
+	return result;
+});
+
+connection.onInitialized(() => {
+	if (hasConfigurationCapability) {
+		// Register for all configuration changes.
+		connection.client.register(
+			DidChangeConfigurationNotification.type,
+			undefined
+		);
+	}
+	if (hasWorkspaceFolderCapability) {
+		connection.workspace.onDidChangeWorkspaceFolders(_event => {
+			connection.console.log('Workspace folder change event received.');
+		});
+	}
+});
+
+// The example settings
+interface ExampleSettings {
+	maxNumberOfProblems: number;
+}
+
+// The global settings, used when the `workspace/configuration` request is not supported by the client.
+// Please note that this is not the case when using this server with the client provided in this example
+// but could happen with other clients.
+const defaultSettings: ExampleSettings = { maxNumberOfProblems: 5 };
+let globalSettings: ExampleSettings = defaultSettings;
+
+// Cache the settings of all open documents
+let documentSettings: Map<string, Thenable<ExampleSettings>> = new Map();
+
+connection.onDidChangeConfiguration(change => {
+	if (hasConfigurationCapability) {
+		// Reset all cached document settings
+		documentSettings.clear();
+	} else {
+		globalSettings = <ExampleSettings>(
+			(change.settings.languageServerExample || defaultSettings)
+		);
+	}
+
+	// Revalidate all open text documents
+	documents.all().forEach(validateTextDocument);
+});
+
+function getDocumentSettings(resource: string): Thenable<ExampleSettings> {
+	if (!hasConfigurationCapability) {
+		return Promise.resolve(globalSettings);
+	}
+	let result = documentSettings.get(resource);
+	if (!result) {
+		result = connection.workspace.getConfiguration({
+			scopeUri: resource,
+			section: 'languageServerExample',
+		});
+		documentSettings.set(resource, result);
+	}
+	return result;
+}
+
+// Only keep settings for open documents
+documents.onDidClose(e => {
+	documentSettings.delete(e.document.uri);
+});
+
+// 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 => {
+	//change.contentChanges;
+	validateTextDocument(change.document);
+});
+
+//Run when saved
+documents.onDidSave(change => {
+	validateTextDocument(change.document);
+});
+
+const validateBrackets = (text: string) => {
+	let count = 0, lp: number[] = [],issues:number[]=[];
+	const textsplit = text.split(``);
+	textsplit.forEach((x, i) => {
+		if (x == '(' || x == ')') {
+			
+			if (x == '(') lp.push(i);
+			if (x == ')') {if(lp.length==0) issues.push(i);lp.pop();}
+
+			
+		}
+
+	});
+
+	return [...lp,...issues]
+};
+
+async function validateTextDocument(textDocument: TextDocument): Promise<void> {
+	// In this simple example we get the settings for every validate run.
+	let settings = await getDocumentSettings(textDocument.uri);
+	// The validator creates diagnostics for all uppercase words length 2 and more
+	const text = textDocument.getText();
+
+	let problems = 0;
+	let diagnostics: Diagnostic[] = [];
+	const issues = validateBrackets(text);
+	
+		diagnostics.push(...issues.map<Diagnostic>(e => ({
+			message: 'Brackets unmatched',
+			range:{
+				start: textDocument.positionAt(e),
+				end: textDocument.positionAt(e+1),
+			},
+			severity:DiagnosticSeverity.Error,
+			code:'( and )',
+		})));
+	
+	// diagnostics.push({
+	// 	message: 'Brackets not matched',
+	// 	range: {
+	// 		start: { line: 0, character: 0 },
+	// 		end: { line: 0, character: 0 },
+	// 	},
+	// });
+
+	// diagnostics.push(<Diagnostic>{
+	// 	severity: DiagnosticSeverity.Information,
+	// 	range: {
+	// 		start: textDocument.positionAt(0),
+	// 		end: textDocument.positionAt(1),
+	// 	},
+	// 	// message:`HI:(${text})(${result.hasErrors()},${result.hasWarnings()})`,
+	// 	message: `Parsing Failed`,
+	// 	source: 'test',
+	// });
+
+	// Send the computed diagnostics to VSCode.
+	connection.sendDiagnostics({ uri: textDocument.uri, diagnostics });
+}
+
+connection.onDidChangeWatchedFiles(_change => {
+	// Monitored files have change in VSCode
+	connection.console.log('We received an file change event');
+});
+
+// This handler provides the initial list of the completion items.
+connection.onCompletion(
+	(_textDocumentPosition: TextDocumentPositionParams): CompletionItem[] => {
+		const completions: CompletionItem[] = [
+			{
+				label: '+',
+				detail: 'Addition',
+				documentation: 'Add one to cell',
+			},
+			{
+				label: '-',
+				detail: 'Subtraction',
+				documentation: 'Subtract one from cell',
+			},
+			{
+				label: ',',
+				detail: 'Input',
+				documentation: 'Ask for input (Stored in the ASCII format)',
+			},
+			{
+				label: '.',
+				detail: 'Output',
+				documentation: 'Output the equivalent ASCII character',
+			},
+			{
+				label: '>',
+				detail: 'Right Shift',
+				documentation: 'Shift the pointer one cell to the right',
+			},
+			{
+				label: '<',
+				detail: 'Left Shift',
+				documentation: 'Shift the pointer one cell to the Left',
+			},
+		];
+		return completions.map(e => {
+			e.kind = CompletionItemKind.Operator;
+			return e;
+		});
+	}
+);
+
+//TODOF Implement further
+// This handler resolves additional information for the item selected in
+// the completion list.
+// connection.onCompletionResolve(
+// 	(item: CompletionItem): CompletionItem => {
+// 		if (item.data === 1) {
+// 			item.detail = 'Addition';
+// 			item.documentation = 'Add 1 to the cell';
+
+// 		} else if (item.data === 2) {
+// 			item.detail = 'Subtraction';
+// 			item.documentation = 'Subtract 1 from the cell';
+// 		}
+// 		return item;
+// 	}
+// );
+
+// Make the text document manager listen on the connection
+// for open, change and close text document events
+documents.listen(connection);
+
+// Listen on the connection
+connection.listen();