astn 0.110.15 → 1.20.5

package/client/src/extension.ts

@@ -0,0 +1,249 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import * as path from 'path';
+import { workspace, ExtensionContext } from 'vscode';
+
+import * as backend from "../../backend/dist"
+
+import * as fs from "fs"
+
+import {
+	LanguageClient,
+	LanguageClientOptions,
+	ServerOptions,
+	TransportKind
+} from 'vscode-languageclient/node';
+
+import * as vscode from 'vscode'
+
+let client: LanguageClient;
+
+const create_vscode_position = (position: backend.Relative_Location): vscode.Position => {
+	return new vscode.Position(position.line, position.column);
+}
+
+const create_vscode_range = (backend_range: backend.Relative_Range): vscode.Range => {
+	return new vscode.Range(create_vscode_position(backend_range.start), create_vscode_position(backend_range.end));
+}
+
+
+function create_backend_position(document: vscode.TextDocument, offset: number): backend.Relative_Location {
+	const x = document.positionAt(offset)
+	return { line: x.line, column: x.character }
+}
+
+// function create(document: vscode.TextDocument, range: backend.Range) {
+
+// 	//return new vscode.Range(convertLocation(document, range.start), convertLocation(document, atl.init().getEndLocationFromRange(range)))
+// 	return new vscode.Range(create_backend_position(document, range.start), create_backend_position(document, range.end))
+// }
+
+
+export function activate(context: ExtensionContext) {
+
+
+
+	{
+		const disposable = vscode.commands.registerCommand('astn.save_as_json', () => {
+			vscode.window.showInformationMessage('Save as JSON!');
+
+			const editor = vscode.window.activeTextEditor;
+			if (!editor) {
+				vscode.window.showInformationMessage('Open an ASTN file first to convert to JSON');
+				return;
+			}
+
+			const document = editor.document;
+			const text = document.getText();
+
+			const activeUri = vscode.window.activeTextEditor.document.uri;
+
+
+			const result = backend.convert_to_json(text);
+			if (result === null) {
+				vscode.window.showErrorMessage("Cannot save as JSON because the file is not valid ASTN.");
+				return;
+			} else {
+
+				vscode.window.showSaveDialog({}).then(fileInfos => {
+					if (result !== null) {
+						fs.writeFileSync(fileInfos.path, result, 'utf8');
+					}
+				});
+			}
+
+
+		});
+
+		context.subscriptions.push(disposable);
+	}
+	{
+		const disposable = vscode.commands.registerCommand('astn.sort_alphabetically', () => {
+
+			const editor = vscode.window.activeTextEditor;
+			if (!editor) {
+				vscode.window.showInformationMessage('Open an ASTN file first to sort alphabetically');
+				return;
+			}
+
+			const document = editor.document;
+			const text = document.getText();
+			const position = editor.selection.active
+
+			const activeUri = vscode.window.activeTextEditor.document.uri;
+
+
+			const result = backend.sort_alphabetically(text, { 'position': { line: position.line, column: position.character } });
+			result.transform(
+				($) => {
+					editor.edit(editBuilder => {
+						editBuilder.replace(create_vscode_range($.range), $.text);
+					});
+				},
+				() => {
+					vscode.window.showErrorMessage("Sorting failed because the file is not valid ASTN.");
+
+				}
+			)
+		});
+
+		context.subscriptions.push(disposable);
+	}
+	{
+		const disposable = vscode.commands.registerCommand('astn.convert_to_json', () => {
+			vscode.window.showInformationMessage('Convert to JSON!');
+
+			const editor = vscode.window.activeTextEditor;
+			if (!editor) {
+				vscode.window.showInformationMessage('Open an ASTN file first to save as JSON');
+				return;
+			}
+
+			const document = editor.document;
+			const text = document.getText();
+
+
+
+			const result = backend.convert_to_json(text);
+			if (result === null) {
+				vscode.window.showErrorMessage("Conversion to JSON failed because the file is not valid ASTN.");
+				return;
+			} else {
+				editor.edit(($) => {
+					$.replace(
+						new vscode.Range(
+							new vscode.Position(0, 0),
+							editor.document.lineAt(editor.document.lineCount - 1).range.end
+						),
+						result
+					)
+				})
+			}
+
+
+		});
+
+		context.subscriptions.push(disposable);
+	}
+
+
+	// The server is implemented in node
+	const serverModule = context.asAbsolutePath(
+		path.join('server', 'out', 'server.js')
+	);
+
+	// If the extension is launched in debug mode then the debug server options are used
+	// Otherwise the run options are used
+	const serverOptions: ServerOptions = {
+		run: { module: serverModule, transport: TransportKind.ipc },
+		debug: {
+			module: serverModule,
+			transport: TransportKind.ipc,
+		}
+	};
+
+	// Options to control the language client
+	const clientOptions: LanguageClientOptions = {
+		// Register the server for plain text documents
+		documentSelector: [{ scheme: 'file', language: 'astn' }],
+		synchronize: {
+			// Notify the server about file changes to '.clientrc files contained in the workspace
+			fileEvents: workspace.createFileSystemWatcher('**/.clientrc')
+		}
+	};
+
+	// Create the language client and start the client.
+	client = new LanguageClient(
+		'ASNTLanguageServer',
+		'ASTN Language Server',
+		serverOptions,
+		clientOptions
+	);
+
+
+	vscode.languages.registerDocumentFormattingEditProvider('astn', {
+		provideDocumentFormattingEdits(document: vscode.TextDocument, options) {
+			const edits: vscode.TextEdit[] = [];
+			// Read user configuration for formatting
+			const config = vscode.workspace.getConfiguration('astn');
+			console.log("HIER DAN?")
+			const result = backend.format(
+				document.getText(),
+				{
+					'preserve delimiters': config.get<boolean>('format.Preserve Delimiters', false),
+					'indent string': config.get<string>('format.Indentation String', '    '),
+					'preserve final newline state': config.get<boolean>('format.Preserve Final Newline State', true),
+					'preserve commas': config.get<boolean>('format.Preserve Commas', true),
+					'insert spaces': options.insertSpaces,
+				}
+			)
+			switch (result[0]) {
+				case 'failure':
+					console.error("Formatting failed:", result[1].message);
+					vscode.window.showErrorMessage("Formatting failed: " + result[1].message);
+					return [];
+				case 'success':
+					return result[1].__get_raw_copy().map(edit => {
+						switch (edit[0]) {
+							case 'replace':
+								console.log("REPLACE", edit[1].range.start, edit[1].range.end, edit[1].text)
+
+								return vscode.TextEdit.replace(
+									create_vscode_range(edit[1].range),
+									edit[1].text
+								);
+							case 'delete':
+								return vscode.TextEdit.delete(
+									create_vscode_range(edit[1].range)
+								);
+							case 'insert':
+								return vscode.TextEdit.insert(
+									create_vscode_position(edit[1].location),
+									edit[1].text
+								);
+						}
+					})
+				default:
+					throw new Error("Unknown result type: " + result[0]);
+			}
+
+
+		}
+	})
+
+
+	// Start the client. This will also launch the server
+	client.start();
+
+
+}
+
+export function deactivate(): Thenable<void> | undefined {
+	if (!client) {
+		return undefined;
+	}
+	return client.stop();
+}

package/client/src/test/completion.test.ts

@@ -0,0 +1,43 @@
+/* --------------------------------------------------------------------------------------------
+ * 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';
+import * as assert from 'assert';
+import { getDocUri, activate } from './helper';
+
+suite('Should do completion', () => {
+	const docUri = getDocUri('completion.txt');
+
+	test('Completes JS/TS in txt file', async () => {
+		await testCompletion(docUri, new vscode.Position(0, 0), {
+			items: [
+				{ label: 'JavaScript', kind: vscode.CompletionItemKind.Text },
+				{ label: 'TypeScript', kind: vscode.CompletionItemKind.Text }
+			]
+		});
+	});
+});
+
+async function testCompletion(
+	docUri: vscode.Uri,
+	position: vscode.Position,
+	expectedCompletionList: vscode.CompletionList
+) {
+	await activate(docUri);
+
+	// Executing the command `vscode.executeCompletionItemProvider` to simulate triggering completion
+	const actualCompletionList = (await vscode.commands.executeCommand(
+		'vscode.executeCompletionItemProvider',
+		docUri,
+		position
+	)) as vscode.CompletionList;
+
+	assert.ok(actualCompletionList.items.length >= 2);
+	expectedCompletionList.items.forEach((expectedItem, i) => {
+		const actualItem = actualCompletionList.items[i];
+		assert.equal(actualItem.label, expectedItem.label);
+		assert.equal(actualItem.kind, expectedItem.kind);
+	});
+}

package/client/src/test/diagnostics.test.ts

@@ -0,0 +1,41 @@
+/* --------------------------------------------------------------------------------------------
+ * 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';
+import * as assert from 'assert';
+import { getDocUri, activate } from './helper';
+
+suite('Should get diagnostics', () => {
+	const docUri = getDocUri('diagnostics.txt');
+
+	test('Diagnoses uppercase texts', async () => {
+		await testDiagnostics(docUri, [
+			{ message: 'ANY is all uppercase.', range: toRange(0, 0, 0, 3), severity: vscode.DiagnosticSeverity.Warning, source: 'ex' },
+			{ message: 'ANY is all uppercase.', range: toRange(0, 14, 0, 17), severity: vscode.DiagnosticSeverity.Warning, source: 'ex' },
+			{ message: 'OS is all uppercase.', range: toRange(0, 18, 0, 20), severity: vscode.DiagnosticSeverity.Warning, source: 'ex' }
+		]);
+	});
+});
+
+function toRange(sLine: number, sChar: number, eLine: number, eChar: number) {
+	const start = new vscode.Position(sLine, sChar);
+	const end = new vscode.Position(eLine, eChar);
+	return new vscode.Range(start, end);
+}
+
+async function testDiagnostics(docUri: vscode.Uri, expectedDiagnostics: vscode.Diagnostic[]) {
+	await activate(docUri);
+
+	const actualDiagnostics = vscode.languages.getDiagnostics(docUri);
+
+	assert.equal(actualDiagnostics.length, expectedDiagnostics.length);
+
+	expectedDiagnostics.forEach((expectedDiagnostic, i) => {
+		const actualDiagnostic = actualDiagnostics[i];
+		assert.equal(actualDiagnostic.message, expectedDiagnostic.message);
+		assert.deepEqual(actualDiagnostic.range, expectedDiagnostic.range);
+		assert.equal(actualDiagnostic.severity, expectedDiagnostic.severity);
+	});
+}

package/client/src/test/helper.ts

@@ -0,0 +1,47 @@
+/* --------------------------------------------------------------------------------------------
+ * 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';
+import * as path from 'path';
+
+export let doc: vscode.TextDocument;
+export let editor: vscode.TextEditor;
+export let documentEol: string;
+export let platformEol: string;
+
+/**
+ * Activates the vscode.lsp-sample extension
+ */
+export async function activate(docUri: vscode.Uri) {
+	// The extensionId is `publisher.name` from package.json
+	const ext = vscode.extensions.getExtension('vscode-samples.lsp-sample')!;
+	await ext.activate();
+	try {
+		doc = await vscode.workspace.openTextDocument(docUri);
+		editor = await vscode.window.showTextDocument(doc);
+		await sleep(2000); // Wait for server activation
+	} catch (e) {
+		console.error(e);
+	}
+}
+
+async function sleep(ms: number) {
+	return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export const getDocPath = (p: string) => {
+	return path.resolve(__dirname, '../../testFixture', p);
+};
+export const getDocUri = (p: string) => {
+	return vscode.Uri.file(getDocPath(p));
+};
+
+export async function setTestContent(content: string): Promise<boolean> {
+	const all = new vscode.Range(
+		doc.positionAt(0),
+		doc.positionAt(doc.getText().length)
+	);
+	return editor.edit(eb => eb.replace(all, content));
+}

package/client/src/test/index.ts

@@ -0,0 +1,43 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+import * as path from 'path';
+import * as Mocha from 'mocha';
+import * as glob from 'glob';
+
+export function run(): Promise<void> {
+	// Create the mocha test
+	const mocha = new Mocha({
+		ui: 'tdd',
+		color: true
+	});
+	mocha.timeout(100000);
+
+	const testsRoot = __dirname;
+
+	return new Promise((resolve, reject) => {
+		glob('**.test.js', { cwd: testsRoot }, (err, files) => {
+			if (err) {
+				return reject(err);
+			}
+
+			// Add files to the test suite
+			files.forEach(f => mocha.addFile(path.resolve(testsRoot, f)));
+
+			try {
+				// Run the mocha test
+				mocha.run(failures => {
+					if (failures > 0) {
+						reject(new Error(`${failures} tests failed.`));
+					} else {
+						resolve();
+					}
+				});
+			} catch (err) {
+				console.error(err);
+				reject(err);
+			}
+		});
+	});
+}

package/client/src/test/runTest.ts

@@ -0,0 +1,27 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as path from 'path';
+
+import { runTests } from '@vscode/test-electron';
+
+async function sibling(name: string) {
+	try {
+		// The folder containing the Extension Manifest package.json
+		// Passed to `--extensionDevelopmentPath`
+		const extensionDevelopmentPath = path.resolve(__dirname, '../../../');
+
+		// The path to test runner
+		// Passed to --extensionTestsPath
+		const extensionTestsPath = path.resolve(__dirname, './index');
+
+		// Download VS Code, unzip it and run the integration test
+		await runTests({ extensionDevelopmentPath, extensionTestsPath });
+	} catch (err) {
+		console.error('Failed to run tests');
+		process.exit(1);
+	}
+}
+
+sibling("main");

package/client/testFixture/diagnostics.txt

@@ -0,0 +1 @@
+ANY browsers, ANY OS.

package/client/tsconfig.json

@@ -0,0 +1,12 @@
+{
+	"compilerOptions": {
+		"module": "commonjs",
+		"target": "es2020",
+		"lib": ["es2020"],
+		"outDir": "out",
+		"rootDir": "src",
+		"sourceMap": true
+	},
+	"include": ["src"],
+	"exclude": ["node_modules", ".vscode-test"]
+}

package/client/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/extension.ts","./src/test/completion.test.ts","./src/test/diagnostics.test.ts","./src/test/helper.ts","./src/test/index.ts","./src/test/runTest.ts"],"errors":true,"version":"5.6.3"}

package/development.md

@@ -0,0 +1,12 @@
+
+## Running the Sample
+
+- Run `npm install` in this folder. This installs all necessary npm modules in both the client and server folder
+- Open VS Code on this folder.
+- Press Ctrl+Shift+B to start compiling the client and server in [watch mode](https://code.visualstudio.com/docs/editor/tasks#:~:text=The%20first%20entry%20executes,the%20HelloWorld.js%20file.).
+- Switch to the Run and Debug View in the Sidebar (Ctrl+Shift+D).
+- Select `Launch Client` from the drop down (if it is not already).
+- Press ▷ to run the launch config (F5).
+- In the [Extension Development Host](https://code.visualstudio.com/api/get-started/your-first-extension#:~:text=Then%2C%20inside%20the%20editor%2C%20press%20F5.%20This%20will%20compile%20and%20run%20the%20extension%20in%20a%20new%20Extension%20Development%20Host%20window.) instance of VSCode, open a document in 'plain text' language mode.
+  - Type `j` or `t` to see `Javascript` and `TypeScript` completion.
+  - Enter text content such as `AAA aaa BBB`. The extension will emit diagnostics for all words in all-uppercase.

package/language-configuration.json

@@ -0,0 +1,36 @@
+{
+    "comments": {
+        // symbol used for single line comment. Remove this entry if your language does not support line comments
+        "lineComment": "//",
+        // symbols used for start and end a block comment. Remove this entry if your language does not support block comments
+        "blockComment": [ "/*", "*/" ]
+    },
+    // symbols used as brackets
+    "brackets": [
+        ["[", "]"],
+        ["<", ">"],
+        ["{", "}"],
+        ["(", ")"],
+        // ["`", "`"]
+    ],
+    // symbols that are auto closed when typing
+    "autoClosingPairs": [
+        ["[", "]"],
+        ["<", ">"],
+        ["{", "}"],
+        ["(", ")"],
+        ["\"", "\""],
+        ["'", "'"],
+        ["`", "`"]
+    ],
+    // symbols that can be used to surround a selection
+    "surroundingPairs": [
+        ["[", "]"],
+        ["<", ">"],
+        ["{", "}"],
+        ["(", ")"],
+        ["\"", "\""],
+        ["'", "'"],
+        ["`", "`"]
+    ]
+}