aurora-langium 0.0.1

package/out/language/main.d.ts

@@ -0,0 +1 @@
+export {};

package/out/language/main.js

@@ -0,0 +1,11 @@
+import { startLanguageServer } from 'langium/lsp';
+import { NodeFileSystem } from 'langium/node';
+import { createConnection, ProposedFeatures } from 'vscode-languageserver/node.js';
+import { createAuroraServices } from './aurora-module.js';
+// Create a connection to the client
+const connection = createConnection(ProposedFeatures.all);
+// Inject the shared services and language-specific services
+const { shared } = createAuroraServices(Object.assign({ connection }, NodeFileSystem));
+// Start the language server with the shared services
+startLanguageServer(shared);
+//# sourceMappingURL=main.js.map

package/out/language/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","sourceRoot":"","sources":["../../src/language/main.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE1D,oCAAoC;AACpC,MAAM,UAAU,GAAG,gBAAgB,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;AAE1D,4DAA4D;AAC5D,MAAM,EAAE,MAAM,EAAE,GAAG,oBAAoB,iBAAG,UAAU,IAAK,cAAc,EAAG,CAAC;AAE3E,qDAAqD;AACrD,mBAAmB,CAAC,MAAM,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,81 @@
+{
+    "name": "aurora-langium",
+    "description": "It containes the DSL named Aurora",
+    "version": "0.0.1",
+    "files": [
+        "bin",
+        "out",
+        "src"
+    ],
+    "type": "module",
+    "scripts": {
+        "build": "tsc -b tsconfig.src.json && node esbuild.mjs",
+        "watch": "concurrently -n tsc,esbuild -c blue,yellow \"tsc -b tsconfig.src.json --watch\" \"node esbuild.mjs --watch\"",
+        "lint": "eslint src --ext ts",
+        "langium:generate": "langium generate",
+        "langium:watch": "langium generate --watch",
+        "vscode:prepublish": "npm run build && npm run lint",
+        "test": "vitest run"
+    },
+    "dependencies": {
+        "langium": "~3.2.0",
+        "vscode-languageclient": "~9.0.1",
+        "vscode-languageserver": "~9.0.1",
+        "chalk": "~5.3.0",
+        "commander": "~11.0.0"
+    },
+    "devDependencies": {
+        "@types/node": "^18.0.0",
+        "@typescript-eslint/parser": "~7.3.1",
+        "@typescript-eslint/eslint-plugin": "~7.3.1",
+        "eslint": "~8.57.0",
+        "langium-cli": "~3.2.0",
+        "typescript": "~5.1.6",
+        "@types/vscode": "~1.67.0",
+        "concurrently": "~8.2.1",
+        "esbuild": "~0.20.2",
+        "vitest": "~1.4.0"
+    },
+    "volta": {
+        "node": "18.19.1",
+        "npm": "10.2.4"
+    },
+    "displayName": "aurora-langium",
+    "engines": {
+        "vscode": "^1.67.0",
+        "node": ">=18.0.0"
+    },
+    "categories": [
+        "Programming Languages"
+    ],
+    "contributes": {
+        "languages": [
+            {
+                "id": "aurora",
+                "aliases": [
+                    "Aurora",
+                    "aurora"
+                ],
+                "extensions": [".aurora"],
+                "configuration": "./language-configuration.json"
+            }
+        ],
+        "grammars": [
+            {
+                "language": "aurora",
+                "scopeName": "source.aurora",
+                "path": "syntaxes/aurora.tmLanguage.json"
+            }
+        ]
+    },
+    "activationEvents": [
+        "onLanguage:aurora"
+    ],
+    "main": "./out/extension/main.cjs",
+    "bin": {
+        "aurora-cli": "./bin/cli.js"
+    },
+    "author": {
+        "name": "Aurora Constellations"
+    }
+}

package/src/cli/cli-util.ts

@@ -0,0 +1,51 @@
+import type { AstNode, LangiumCoreServices, LangiumDocument } from 'langium';
+import chalk from 'chalk';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { URI } from 'langium';
+
+export async function extractDocument(fileName: string, services: LangiumCoreServices): Promise<LangiumDocument> {
+    const extensions = services.LanguageMetaData.fileExtensions;
+    if (!extensions.includes(path.extname(fileName))) {
+        console.error(chalk.yellow(`Please choose a file with one of these extensions: ${extensions}.`));
+        process.exit(1);
+    }
+
+    if (!fs.existsSync(fileName)) {
+        console.error(chalk.red(`File ${fileName} does not exist.`));
+        process.exit(1);
+    }
+
+    const document = await services.shared.workspace.LangiumDocuments.getOrCreateDocument(URI.file(path.resolve(fileName)));
+    await services.shared.workspace.DocumentBuilder.build([document], { validation: true });
+
+    const validationErrors = (document.diagnostics ?? []).filter(e => e.severity === 1);
+    if (validationErrors.length > 0) {
+        console.error(chalk.red('There are validation errors:'));
+        for (const validationError of validationErrors) {
+            console.error(chalk.red(
+                `line ${validationError.range.start.line + 1}: ${validationError.message} [${document.textDocument.getText(validationError.range)}]`
+            ));
+        }
+        process.exit(1);
+    }
+
+    return document;
+}
+
+export async function extractAstNode<T extends AstNode>(fileName: string, services: LangiumCoreServices): Promise<T> {
+    return (await extractDocument(fileName, services)).parseResult?.value as T;
+}
+
+interface FilePathData {
+    destination: string,
+    name: string
+}
+
+export function extractDestinationAndName(filePath: string, destination: string | undefined): FilePathData {
+    filePath = path.basename(filePath, path.extname(filePath)).replace(/[.-]/g, '');
+    return {
+        destination: destination ?? path.join(path.dirname(filePath), 'generated'),
+        name: path.basename(filePath)
+    };
+}

package/src/cli/generator.ts

@@ -0,0 +1,22 @@
+import type { PCM } from '../language/generated/ast.js';
+import { expandToNode, joinToNode, toString } from 'langium/generate';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { extractDestinationAndName } from './cli-util.js';
+
+export function generateJavaScript(model: PCM, filePath: string, destination: string | undefined): string {
+    const data = extractDestinationAndName(filePath, destination);
+    const generatedFilePath = `${path.join(data.destination, data.name)}.js`;
+
+    const fileNode = expandToNode`
+        "use strict";
+
+        ${joinToNode(model.imports, greeting => `console.log('Hello, ${greeting.importedNamespace}!');`, { appendNewLineIfNotEmpty: true })}
+    `.appendNewLineIfNotEmpty();
+
+    if (!fs.existsSync(data.destination)) {
+        fs.mkdirSync(data.destination, { recursive: true });
+    }
+    fs.writeFileSync(generatedFilePath, toString(fileNode));
+    return generatedFilePath;
+}

package/src/cli/main.ts

@@ -0,0 +1,42 @@
+import type { PCM } from '../language/generated/ast.js';
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { AuroraLanguageMetaData } from '../language/generated/module.js';
+import { createAuroraServices } from '../language/aurora-module.js';
+import { extractAstNode } from './cli-util.js';
+import { generateJavaScript } from './generator.js';
+import { NodeFileSystem } from 'langium/node';
+import * as url from 'node:url';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+
+const packagePath = path.resolve(__dirname, '..', '..', 'package.json');
+const packageContent = await fs.readFile(packagePath, 'utf-8');
+
+export const generateAction = async (fileName: string, opts: GenerateOptions): Promise<void> => {
+    const services = createAuroraServices(NodeFileSystem).Aurora;
+    const PCM = await extractAstNode<PCM>(fileName, services);
+    const generatedFilePath = generateJavaScript(PCM, fileName, opts.destination);
+    console.log(chalk.green(`JavaScript code generated successfully: ${generatedFilePath}`));
+};
+
+export type GenerateOptions = {
+    destination?: string;
+}
+
+export default function(): void {
+    const program = new Command();
+
+    program.version(JSON.parse(packageContent).version);
+
+    const fileExtensions = AuroraLanguageMetaData.fileExtensions.join(', ');
+    program
+        .command('generate')
+        .argument('<file>', `source file (possible file extensions: ${fileExtensions})`)
+        .option('-d, --destination <dir>', 'destination directory of generating')
+        .description('generates JavaScript code that prints "Hello, {name}!" for each greeting in a source file')
+        .action(generateAction);
+
+    program.parse(process.argv);
+}

package/src/extension/main.ts

@@ -0,0 +1,51 @@
+import type { LanguageClientOptions, ServerOptions} from 'vscode-languageclient/node.js';
+import type * as vscode from 'vscode';
+import * as path from 'node:path';
+import { LanguageClient, TransportKind } from 'vscode-languageclient/node.js';
+
+let client: LanguageClient;
+
+// This function is called when the extension is activated.
+export function activate(context: vscode.ExtensionContext): void {
+    client = startLanguageClient(context);
+}
+
+// This function is called when the extension is deactivated.
+export function deactivate(): Thenable<void> | undefined {
+    if (client) {
+        return client.stop();
+    }
+    return undefined;
+}
+
+function startLanguageClient(context: vscode.ExtensionContext): LanguageClient {
+    const serverModule = context.asAbsolutePath(path.join('out', 'language', 'main.cjs'));
+    // The debug options for the server
+    // --inspect=6009: runs the server in Node's Inspector mode so VS Code can attach to the server for debugging.
+    // By setting `process.env.DEBUG_BREAK` to a truthy value, the language server will wait until a debugger is attached.
+    const debugOptions = { execArgv: ['--nolazy', `--inspect${process.env.DEBUG_BREAK ? '-brk' : ''}=${process.env.DEBUG_SOCKET || '6009'}`] };
+
+    // 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: debugOptions }
+    };
+
+    // Options to control the language client
+    const clientOptions: LanguageClientOptions = {
+        documentSelector: [{ scheme: '*', language: 'aurora' }]
+    };
+
+    // Create the language client and start the client.
+    const client = new LanguageClient(
+        'aurora',
+        'Aurora',
+        serverOptions,
+        clientOptions
+    );
+
+    // Start the client. This will also launch the server
+    client.start();
+    return client;
+}

package/src/language/aurora-module.ts

@@ -0,0 +1,68 @@
+import { type Module, inject } from 'langium';
+import { createDefaultModule, createDefaultSharedModule, type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type PartialLangiumServices } from 'langium/lsp';
+import { AuroraGeneratedModule, AuroraGeneratedSharedModule } from './generated/module.js';
+import { AuroraValidator, registerValidationChecks } from './aurora-validator.js';
+
+/**
+ * Declaration of custom services - add your own service classes here.
+ */
+export type AuroraAddedServices = {
+    validation: {
+        AuroraValidator: AuroraValidator
+    }
+}
+
+/**
+ * Union of Langium default services and your custom services - use this as constructor parameter
+ * of custom service classes.
+ */
+export type AuroraServices = LangiumServices & AuroraAddedServices
+
+/**
+ * Dependency injection module that overrides Langium default services and contributes the
+ * declared custom services. The Langium defaults can be partially specified to override only
+ * selected services, while the custom services must be fully specified.
+ */
+export const AuroraModule: Module<AuroraServices, PartialLangiumServices & AuroraAddedServices> = {
+    validation: {
+        AuroraValidator: () => new AuroraValidator()
+    }
+};
+
+/**
+ * Create the full set of services required by Langium.
+ *
+ * First inject the shared services by merging two modules:
+ *  - Langium default shared services
+ *  - Services generated by langium-cli
+ *
+ * Then inject the language-specific services by merging three modules:
+ *  - Langium default language-specific services
+ *  - Services generated by langium-cli
+ *  - Services specified in this file
+ *
+ * @param context Optional module context with the LSP connection
+ * @returns An object wrapping the shared services and the language-specific services
+ */
+export function createAuroraServices(context: DefaultSharedModuleContext): {
+    shared: LangiumSharedServices,
+    Aurora: AuroraServices
+} {
+    const shared = inject(
+        createDefaultSharedModule(context),
+        AuroraGeneratedSharedModule
+    );
+    const Aurora = inject(
+        createDefaultModule({ shared }),
+        AuroraGeneratedModule,
+        AuroraModule
+    );
+    shared.ServiceRegistry.register(Aurora);
+    registerValidationChecks(Aurora);
+    if (!context.connection) {
+        // We don't run inside a language server
+        // Therefore, initialize the configuration provider instantly
+        shared.workspace.ConfigurationProvider.initialized({});
+    }
+    return { shared, Aurora };
+}

package/src/language/aurora-validator.ts

@@ -0,0 +1,31 @@
+import type { ValidationAcceptor, ValidationChecks } from 'langium';
+import type { AuroraAstType, IssueCoordinate } from './generated/ast.js';
+import type { AuroraServices } from './aurora-module.js';
+
+/**
+ * Register custom validation checks.
+ */
+export function registerValidationChecks(services: AuroraServices) {
+    const registry = services.validation.ValidationRegistry;
+    const validator = services.validation.AuroraValidator;
+    const checks: ValidationChecks<AuroraAstType> = {
+        IssueCoordinate: validator.checkIssueCoordinateStartsWithCapital
+    };
+    registry.register(checks, validator);
+}
+
+/**
+ * Implementation of custom validations.
+ */
+export class AuroraValidator {
+
+    checkIssueCoordinateStartsWithCapital(issueCoordinate: IssueCoordinate, accept: ValidationAcceptor): void {
+        if (issueCoordinate.name) {
+            const firstChar = issueCoordinate.name.substring(0, 1);
+            if (firstChar.toUpperCase() !== firstChar) {
+                accept('warning', 'IssueCoordinate should start with a capital.', { node: issueCoordinate, property: 'name' });
+            }
+        }
+    }
+
+}

package/src/language/aurora.langium

@@ -0,0 +1,130 @@
+grammar Aurora
+
+entry PCM:
+    package=PACKAGE ?
+    imports+=Import *
+    module=MODULE ?
+    template=TEMPLATE ?
+    elements+=(Issues |  Orders | Clinical)*
+;
+
+/* Package and Import */
+PACKAGE:'package' name=QualifiedName  ';';
+Import: 'import' importedNamespace=QualifiedNameWithWildcard  ';';
+QualifiedNameWithWildcard returns string: QualifiedName '.*'?;
+QualifiedName returns string: ID ('.' ID )*;
+NL_STATEMENT:
+    name=( NL_STATEMENTMULTI | SINGLENL  );
+Clinical:
+'Clinical:'
+narrative+=NL_STATEMENT*
+namedGroups+=NamedGroupClinical*;
+
+NamedGroupClinical:
+    name=ID_WITH_COLON
+    timestamp=TimeStamp ?
+    ('('refs+=[ReferenceCoordinate:ID] (',' refs+=[ReferenceCoordinate:ID])* ')')?
+    narrative+=NL_STATEMENT *
+    coord+=(ClinicalCoordinate | ClinicalValue  )*
+;
+
+ClinicalCoordinate:
+    qu+=QU *
+    timestamp=TimeStamp ?
+    name=ID
+    ('('refs+=[ReferenceCoordinate:ID] (',' refs+=[ReferenceCoordinate:ID])* ')')?
+    narrative+=NL_STATEMENT *
+;
+
+ClinicalValue:
+    qu+=QU *
+    timestamp=TimeStamp ?
+    name=ID
+    '['
+    values+=SingleValueUnit
+    (',' values+=SingleValueUnit  )*
+    ']'
+    ('('refs+=[ReferenceCoordinate:ID] (',' refs+=[ReferenceCoordinate:ID])* ')')?
+    narrative+=NL_STATEMENT *
+;
+
+/* Value Unit */
+SingleValueUnit :
+    negative='(-)' ?
+    value=(ID | INT | Float | Fraction | Boolean  )
+    unit=(ID | INT | Float | Fraction | Boolean | '_'  )
+;
+
+Fraction returns string: INT '/' INT;
+Boolean returns string: 'y' | 'n' ;
+Float returns string: INT '.' INT ;
+
+TimeStamp:
+    '@' ((empty="time" ) | (date=AuroraDate  | time=Time  )| (date=AuroraDate  time=Time  ) )
+;
+
+Issues:
+'Issues:'
+narrative+=NL_STATEMENT*
+coord+=IssueCoordinate*;
+
+IssueCoordinate:
+    comment+= ML_COMMENT*
+    qu += QU*
+    name=ID
+    ('('refs+=[ReferenceCoordinate:ID] (',' refs+=[ReferenceCoordinate:ID])* ')')?
+    (':' snomed=Snomed)?
+    ('from' mods+=[MODULE:ID] (',' mods+=[MODULE:ID])*
+            ('with' temps+=[TEMPLATE: ID] (',' temps+=[TEMPLATE:ID])*)? )?
+    narrative+=NL_STATEMENT*
+;
+
+ReferenceCoordinate: (IssueCoordinate | OrderCoordinate | ClinicalCoordinate);
+
+Orders:
+'Orders:'
+narrative+=NL_STATEMENT*
+(namedGroups+=NamedGroupOrder)*;
+
+NamedGroupOrder:
+    comment+= ML_COMMENT*
+    qu += QU*
+    name=ID_WITH_COLON
+    ('('refs+=[ReferenceCoordinate:ID] (',' refs+=[ReferenceCoordinate:ID])* ')')?
+    narrative+=NL_STATEMENT *
+    (orders+=(OrderCoordinate | MutuallyExclusive))*;
+
+OrderCoordinate:
+    comment+= ML_COMMENT*
+    qu += QU*
+    name=ID
+    ('('refs+=[ReferenceCoordinate:ID] (',' refs+=[ReferenceCoordinate:ID])* ')')?
+    narrative+= NL_STATEMENT* ;
+
+MutuallyExclusive:
+    comment+= ML_COMMENT*
+    order1=OrderCoordinate 'or' order2=OrderCoordinate;
+
+/* Template and Module */
+TEMPLATE: "template" name=ID  elements+=(Clinical |  Orders)*;
+MODULE:   "module:"  name=ID  elements+=(Issues |  Orders)*;
+
+AuroraDate returns string:INT '/' INT '/' INT  | INT | INT '/' INT;
+Time returns string: INT ':' INT ;
+QU: query=QUTERMINAL;
+
+Snomed:name=ID;
+
+terminal PREFIXSINGLE : ('-') ('?' | '!' | '.' | 'x' )? ;
+terminal PREFIXMULTI :('--' | '??' | '!!' | '..' | 'xx' );
+
+
+terminal NL_STATEMENTMULTI returns string: PREFIXMULTI  -> ';'  ;
+terminal ID_WITH_COLON: /[a-zA-Z0-9_]+:/;
+terminal ID: /[a-zA-Z0-9_]+/;
+terminal SINGLENL returns string: /-(\??|\.\?|!|x)?([^\n]*)/;
+terminal INT: /[0-9]+/;
+terminal ML_COMMENT returns string:'/*'  -> '*/'  ;
+terminal SL_COMMENT returns string:'//'  !('\n' | '\r' )('\r'? '\n' )?  ;
+hidden terminal WS: /\s+/;
+terminal QUTERMINAL returns string:('?' | '!' | '*' | '~' );