langium-tools 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (61) hide show
  1. package/README.md +1171 -0
  2. package/dist/base/arrays.d.ts +6 -0
  3. package/dist/base/arrays.js +34 -0
  4. package/dist/base/document-errors.d.ts +56 -0
  5. package/dist/base/document-errors.js +198 -0
  6. package/dist/base/document-issues.d.ts +178 -0
  7. package/dist/base/document-issues.js +306 -0
  8. package/dist/base/index.d.ts +4 -0
  9. package/dist/base/index.js +4 -0
  10. package/dist/base/marker-parser.d.ts +36 -0
  11. package/dist/base/marker-parser.js +51 -0
  12. package/dist/base/string.d.ts +89 -0
  13. package/dist/base/string.js +104 -0
  14. package/dist/generator/generated-content-manager.d.ts +207 -0
  15. package/dist/generator/generated-content-manager.js +242 -0
  16. package/dist/generator/index.d.ts +2 -0
  17. package/dist/generator/index.js +2 -0
  18. package/dist/generator/tools.d.ts +9 -0
  19. package/dist/generator/tools.js +12 -0
  20. package/dist/index.d.ts +4 -0
  21. package/dist/index.js +4 -0
  22. package/dist/lang/index.d.ts +1 -0
  23. package/dist/lang/index.js +1 -0
  24. package/dist/lang/java/common.d.ts +1 -0
  25. package/dist/lang/java/common.js +3 -0
  26. package/dist/lang/java/generator-tools.d.ts +37 -0
  27. package/dist/lang/java/generator-tools.js +48 -0
  28. package/dist/lang/java/import-manager.d.ts +61 -0
  29. package/dist/lang/java/import-manager.js +88 -0
  30. package/dist/lang/java/index.d.ts +3 -0
  31. package/dist/lang/java/index.js +3 -0
  32. package/dist/testing/common.d.ts +1 -0
  33. package/dist/testing/common.js +5 -0
  34. package/dist/testing/generator-testing.d.ts +56 -0
  35. package/dist/testing/generator-testing.js +184 -0
  36. package/dist/testing/index.d.ts +4 -0
  37. package/dist/testing/index.js +4 -0
  38. package/dist/testing/matchers.d.ts +209 -0
  39. package/dist/testing/matchers.js +306 -0
  40. package/dist/testing/parser-tools.d.ts +19 -0
  41. package/dist/testing/parser-tools.js +18 -0
  42. package/package.json +59 -0
  43. package/src/base/arrays.ts +40 -0
  44. package/src/base/document-issues.ts +430 -0
  45. package/src/base/index.ts +4 -0
  46. package/src/base/marker-parser.ts +96 -0
  47. package/src/base/string.ts +117 -0
  48. package/src/generator/generated-content-manager.ts +368 -0
  49. package/src/generator/index.ts +2 -0
  50. package/src/generator/tools.ts +14 -0
  51. package/src/index.ts +5 -0
  52. package/src/lang/index.ts +1 -0
  53. package/src/lang/java/common.ts +4 -0
  54. package/src/lang/java/generator-tools.ts +59 -0
  55. package/src/lang/java/import-manager.ts +98 -0
  56. package/src/lang/java/index.ts +3 -0
  57. package/src/testing/common.ts +5 -0
  58. package/src/testing/generator-testing.ts +266 -0
  59. package/src/testing/index.ts +4 -0
  60. package/src/testing/matchers.ts +503 -0
  61. package/src/testing/parser-tools.ts +34 -0
@@ -0,0 +1,266 @@
1
+ import { AstNode, LangiumDocument, URI, WorkspaceFolder } from 'langium';
2
+ import { type DefaultSharedModuleContext, type LangiumSharedServices } from 'langium/lsp';
3
+ import { NodeFileSystem } from 'langium/node';
4
+ import path from 'path';
5
+ import fs from 'fs';
6
+ import { expect, test } from 'vitest';
7
+ import { getDocumentIssueSummary } from '../base/document-issues.js';
8
+ import { GeneratedContent, GeneratorManager, GeneratedContentManager, GeneratorTarget, DEFAULT_TARGET } from '../generator/generated-content-manager.js';
9
+
10
+
11
+ type DslServices<SERVICES, SHARED_SERVICES> = { shared: LangiumSharedServices & SHARED_SERVICES } & SERVICES;
12
+ type ValueOf<T> = T[keyof T];
13
+
14
+ type ExtractServiceType<T> = ValueOf<Omit<T, 'shared'>>;
15
+
16
+ export enum GeneratorMode {
17
+ Generate,
18
+ Verify
19
+ }
20
+
21
+ /**
22
+ * Metadata for generated files.
23
+ * Saved in the output directory of corresponding output directory.
24
+ */
25
+ export interface GeneratorTestOutputDirectoryMetadata {
26
+ generatedFiles:
27
+ {
28
+ filename: string,
29
+ overwrite: boolean
30
+ }[]
31
+ };
32
+
33
+
34
+ export interface GeneratorTestOptions<SERVICES, SHARED_SERVICES, MODEL extends AstNode> {
35
+ generateMode?: GeneratorMode;
36
+
37
+ createServices: (
38
+ context: DefaultSharedModuleContext
39
+ ) => DslServices<SERVICES, SHARED_SERVICES>;
40
+ initWorkspace?: (
41
+ service: DslServices<SERVICES, SHARED_SERVICES>,
42
+ workspaceDir: string
43
+ ) => Promise<WorkspaceFolder>;
44
+ buildDocuments?: (
45
+ service: DslServices<SERVICES, SHARED_SERVICES>,
46
+ workspaceFolder: WorkspaceFolder
47
+ ) => Promise<LangiumDocument<AstNode>[]>;
48
+ validateDocuments?: (
49
+ service: DslServices<SERVICES, SHARED_SERVICES>,
50
+ documents: LangiumDocument<AstNode>[]
51
+ ) => Promise<LangiumDocument<AstNode>[]>;
52
+ generateForWorkspace?: (
53
+ service: DslServices<SERVICES, SHARED_SERVICES>,
54
+ documents: LangiumDocument<AstNode>[],
55
+ workspaceFolder: WorkspaceFolder,
56
+ targets?: GeneratorTarget[]
57
+ ) => Promise<GeneratedContentManager>;
58
+ generateForModel?: (
59
+ services: ExtractServiceType<SERVICES>,
60
+ document: MODEL,
61
+ generatorOutput: GeneratorManager
62
+ ) => Promise<void>;
63
+ }
64
+
65
+ const globalGenerateMode = process.env.GENERATOR_TEST === "generate" ? GeneratorMode.Generate : GeneratorMode.Verify;
66
+
67
+ /**
68
+ * Run generator snapshot tests for all workspaces (subdirectories of the `testSuiteDir` directory).
69
+ * For each workspace there will be a tests added to vitest suite.
70
+ *
71
+ * @param testSuiteDir directory with the workspace directories (as direct subdirectories to `testSuiteDir`)
72
+ * @param options options
73
+ * @param targets optional list of additional target directories (Xtext outlets) to be supported by the generator (generator provided in `options`).
74
+ */
75
+ export function langiumGeneratorSuite<SERVICES, SHARED_SERVICES, MODEL extends AstNode>(testSuiteDir: string, options: GeneratorTestOptions<SERVICES, SHARED_SERVICES, MODEL>, targets?: GeneratorTarget[]): void {
76
+ const { generateMode = globalGenerateMode } = options;
77
+ fs.readdirSync(testSuiteDir, { withFileTypes: true })
78
+ .filter((dirent) => dirent.isDirectory())
79
+ .forEach((dirent) => {
80
+ const testDirName = dirent.name;
81
+
82
+ test(`DSL-Workspace "${testDirName}"${generateMode ? ' (generating)' : ''}`, async () => {
83
+ await langiumGeneratorTest<SERVICES, SHARED_SERVICES, MODEL>(path.join(testSuiteDir, testDirName), options, targets);
84
+ });
85
+ });
86
+ }
87
+
88
+ /**
89
+ * Run generator test for a single DSL workspace.
90
+ *
91
+ * @param testDir The directory containing the DSL workspace.
92
+ * @param options The generator test options.
93
+ * @param targets Optional list of custom generator targets to be used by the generator.
94
+ */
95
+ export async function langiumGeneratorTest<SERVICES, SHARED_SERVICES, MODEL extends AstNode>(testDir: string, options: GeneratorTestOptions<SERVICES, SHARED_SERVICES, MODEL>, targets?: GeneratorTarget[]): Promise<void> {
96
+
97
+ async function defaultGenerateForWorkspace(services: DslServices<SERVICES, SHARED_SERVICES>, documents: LangiumDocument<AstNode>[], workspaceFolder: WorkspaceFolder, targets?: GeneratorTarget[]): Promise<GeneratedContentManager> {
98
+ const optionsGenerator = options.generateForModel;
99
+ if (!optionsGenerator) {
100
+ throw new Error('One of generateForDocument or generateForWorkspace must be defined');
101
+ }
102
+
103
+ const generatedContentManager = new GeneratedContentManager([workspaceFolder.uri]);
104
+ targets?.forEach(target => generatedContentManager.addTarget(target));
105
+ for (const document of documents) {
106
+ const model = document.parseResult.value as MODEL;
107
+
108
+ const nonSharedServices = Object.keys(services as object).filter(key => key !== 'shared');
109
+ if (nonSharedServices.length !== 1) {
110
+ throw new Error('Expected exactly one non-shared service');
111
+ }
112
+ const serviceName = nonSharedServices[0];
113
+ await optionsGenerator(services[serviceName as keyof SERVICES] as ExtractServiceType<SERVICES>, model, generatedContentManager.generatorManagerFor(model));
114
+ }
115
+ return generatedContentManager;
116
+ }
117
+ const {
118
+ initWorkspace = defaultInitWorkspace,
119
+ buildDocuments = defaultBuildDocuments,
120
+ validateDocuments = defaultValidateDocuments,
121
+ generateForWorkspace = defaultGenerateForWorkspace,
122
+ generateMode = globalGenerateMode,
123
+ } = options;
124
+
125
+ const services = options.createServices(NodeFileSystem);
126
+ const workspaceFolder = await initWorkspace(services, testDir);
127
+ const documents = await buildDocuments(services, workspaceFolder);
128
+ await validateDocuments(services, documents);
129
+ const generatedContentManager = await generateForWorkspace(services, documents, workspaceFolder, targets);
130
+
131
+ const outputDir = path.join(testDir, 'generated');
132
+
133
+ const dirsAndTargets = targets?.length ? generatedContentManager.getTargets().map(target => ({
134
+ dir: path.join(outputDir, target.name),
135
+ metadataFile: path.join(testDir, `${target.name}-metadata.json`),
136
+ target,
137
+ })) : [{
138
+ dir: outputDir,
139
+ metadataFile: path.join(testDir, 'generated-metadata.json'),
140
+ target: DEFAULT_TARGET,
141
+ }];
142
+ if (generateMode === GeneratorMode.Generate) {
143
+ cleanDir(outputDir);
144
+ for (const { dir, metadataFile, target } of dirsAndTargets) {
145
+ await generatedContentManager.writeToDisk(dir, target.name);
146
+ writeMetaData(generatedContentManager, metadataFile, target.name);
147
+ }
148
+ } else {
149
+ for (const { dir, metadataFile, target } of dirsAndTargets) {
150
+ verifyFiles(generatedContentManager.getGeneratedContent(target.name), dir, target.name);
151
+ verifyMetaData(generatedContentManager, metadataFile, target.name);
152
+ }
153
+ }
154
+ }
155
+
156
+ export async function defaultInitWorkspace({ shared }: { shared: LangiumSharedServices }, workspaceDir: string): Promise<WorkspaceFolder> {
157
+ const workspaceManager = shared.workspace.WorkspaceManager;
158
+ const workspaceFolder: WorkspaceFolder = {
159
+ name: 'MyDSL Workspace',
160
+ uri: URI.file(workspaceDir).toString()
161
+ };
162
+
163
+ await workspaceManager.initializeWorkspace([workspaceFolder]);
164
+ return workspaceFolder;
165
+ }
166
+
167
+ export async function defaultBuildDocuments({ shared }: { shared: LangiumSharedServices }, workspaceFolder: WorkspaceFolder): Promise<LangiumDocument<AstNode>[]> {
168
+ const LangiumDocuments = shared.workspace.LangiumDocuments;
169
+ const DocumentBuilder = shared.workspace.DocumentBuilder;
170
+ const documents = LangiumDocuments.all.toArray();
171
+ console.log(`Building workspace ${workspaceFolder.uri} with ${documents.length} DSLs`);
172
+ await DocumentBuilder.build(documents, { validation: true });
173
+ return documents;
174
+ }
175
+
176
+ export async function defaultValidateDocuments(_service: object, documents: LangiumDocument<AstNode>[]): Promise<void> {
177
+ documents.forEach(doc => {
178
+ const summary = getDocumentIssueSummary(doc, { skipValidation: true });
179
+ if (summary.countTotal > 0) {
180
+ expect(summary.summary, `DSL file ${doc.uri} has errors:\n${summary.message}`).toBe('No errors');
181
+ }
182
+ });
183
+ }
184
+
185
+ /**
186
+ * Clean output directory.
187
+ *
188
+ * Make sure not to delete files that are not generated by the generator
189
+ * by checking sibling directories. The dsls directory should be present
190
+ * in the same directory as the out directory.
191
+ *
192
+ * @param outputDir
193
+ */
194
+ function cleanDir(outputDir: string) {
195
+ if (!fs.existsSync(outputDir)) {
196
+ return;
197
+ }
198
+
199
+ const siblingDirs = fs.readdirSync(path.join(outputDir, ".."));
200
+ if (!siblingDirs.includes("dsls")) {
201
+ throw new Error(`The out directory ${outputDir} should have a sibling directory named 'dsls'`);
202
+ }
203
+ const files = fs.readdirSync(outputDir);
204
+ files.forEach((file) => {
205
+ fs.rmSync(path.join(outputDir, file), { recursive: true });
206
+ });
207
+ }
208
+
209
+ /**
210
+ * Verify, that generated file structure matches exacly
211
+ * with the existing files in the output directory.
212
+ *
213
+ * @param fileContentMap
214
+ * @param outputDir
215
+ */
216
+ function verifyFiles(generatedContent: GeneratedContent, outputDir: string, target: string) {
217
+ const files = (fs.readdirSync(outputDir, { recursive: true }) as string[])
218
+ .filter(file => fs.statSync(path.join(outputDir, file)).isFile())
219
+ .map(path.normalize);
220
+ const targetDescription = target == DEFAULT_TARGET.name ? "" : ` for target '${target}'`;
221
+ generatedContent.forEach((content, fileName) => {
222
+ const normFileName = path.normalize(fileName);
223
+ expect(
224
+ files,
225
+ `Unexpected generated file${targetDescription}: ${normFileName}`
226
+ ).toContain(normFileName);
227
+ const filePath = path.join(outputDir, normFileName);
228
+ const fileContent = fs.readFileSync(filePath, "utf-8");
229
+ expect(content.content, `File${targetDescription}: ${fileName}`).toBe(fileContent);
230
+ });
231
+ const generatedFiles = Array.from(generatedContent.keys()).map(path.normalize);
232
+ expect(
233
+ files.length,
234
+ `Missing generated file(s)${targetDescription}: ${files.filter((file) => !generatedFiles.includes(file)).join(", ")}`
235
+ ).toBe(generatedContent.size);
236
+ }
237
+
238
+ /**
239
+ * Write metadata from generated content to the output directory.
240
+ */
241
+ function writeMetaData(generatedContent: GeneratedContentManager, metadataJsonFile: string, target: string) {
242
+ const metadata: GeneratorTestOutputDirectoryMetadata = {
243
+ generatedFiles: []
244
+ };
245
+
246
+ generatedContent.getGeneratedContent(target).forEach((contentData, fileName) => {
247
+ metadata.generatedFiles.push({ filename: fileName, overwrite: contentData.overwrite });
248
+ });
249
+ fs.writeFileSync(metadataJsonFile, JSON.stringify(metadata, null, 2));
250
+ }
251
+
252
+ /**
253
+ * Verify metadata from generated content agains metadata file.
254
+ */
255
+ function verifyMetaData(generatedContent: GeneratedContentManager, metadataJsonFile: string, target: string) {
256
+ const metadata: GeneratorTestOutputDirectoryMetadata = JSON.parse(fs.readFileSync(metadataJsonFile, 'utf-8'));
257
+ const generatedFiles = generatedContent.getGeneratedContent(target);
258
+ const targetDescription = target == DEFAULT_TARGET.name ? "" : ` for target '${target}'`;
259
+ metadata.generatedFiles.forEach((metadataFile) => {
260
+ const contentData = generatedFiles.get(metadataFile.filename);
261
+ expect(contentData, `File${targetDescription}: ${metadataFile.filename}`).toBeDefined();
262
+ expect(contentData?.overwrite, `File${targetDescription}: ${metadataFile.filename}. Overwrite flag was changed`).toBe(metadataFile.overwrite);
263
+ });
264
+ expect(metadata.generatedFiles.length, `Missmatch in amount of generated files and metadata${targetDescription}`).toBe(generatedFiles.size);
265
+ }
266
+
@@ -0,0 +1,4 @@
1
+ export * from './common.js';
2
+ export * from './generator-testing.js';
3
+ export * from './matchers.js';
4
+ export * from './parser-tools.js';