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.
- package/README.md +1171 -0
- package/dist/base/arrays.d.ts +6 -0
- package/dist/base/arrays.js +34 -0
- package/dist/base/document-errors.d.ts +56 -0
- package/dist/base/document-errors.js +198 -0
- package/dist/base/document-issues.d.ts +178 -0
- package/dist/base/document-issues.js +306 -0
- package/dist/base/index.d.ts +4 -0
- package/dist/base/index.js +4 -0
- package/dist/base/marker-parser.d.ts +36 -0
- package/dist/base/marker-parser.js +51 -0
- package/dist/base/string.d.ts +89 -0
- package/dist/base/string.js +104 -0
- package/dist/generator/generated-content-manager.d.ts +207 -0
- package/dist/generator/generated-content-manager.js +242 -0
- package/dist/generator/index.d.ts +2 -0
- package/dist/generator/index.js +2 -0
- package/dist/generator/tools.d.ts +9 -0
- package/dist/generator/tools.js +12 -0
- package/dist/index.d.ts +4 -0
- package/dist/index.js +4 -0
- package/dist/lang/index.d.ts +1 -0
- package/dist/lang/index.js +1 -0
- package/dist/lang/java/common.d.ts +1 -0
- package/dist/lang/java/common.js +3 -0
- package/dist/lang/java/generator-tools.d.ts +37 -0
- package/dist/lang/java/generator-tools.js +48 -0
- package/dist/lang/java/import-manager.d.ts +61 -0
- package/dist/lang/java/import-manager.js +88 -0
- package/dist/lang/java/index.d.ts +3 -0
- package/dist/lang/java/index.js +3 -0
- package/dist/testing/common.d.ts +1 -0
- package/dist/testing/common.js +5 -0
- package/dist/testing/generator-testing.d.ts +56 -0
- package/dist/testing/generator-testing.js +184 -0
- package/dist/testing/index.d.ts +4 -0
- package/dist/testing/index.js +4 -0
- package/dist/testing/matchers.d.ts +209 -0
- package/dist/testing/matchers.js +306 -0
- package/dist/testing/parser-tools.d.ts +19 -0
- package/dist/testing/parser-tools.js +18 -0
- package/package.json +59 -0
- package/src/base/arrays.ts +40 -0
- package/src/base/document-issues.ts +430 -0
- package/src/base/index.ts +4 -0
- package/src/base/marker-parser.ts +96 -0
- package/src/base/string.ts +117 -0
- package/src/generator/generated-content-manager.ts +368 -0
- package/src/generator/index.ts +2 -0
- package/src/generator/tools.ts +14 -0
- package/src/index.ts +5 -0
- package/src/lang/index.ts +1 -0
- package/src/lang/java/common.ts +4 -0
- package/src/lang/java/generator-tools.ts +59 -0
- package/src/lang/java/import-manager.ts +98 -0
- package/src/lang/java/index.ts +3 -0
- package/src/testing/common.ts +5 -0
- package/src/testing/generator-testing.ts +266 -0
- package/src/testing/index.ts +4 -0
- package/src/testing/matchers.ts +503 -0
- 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
|
+
|