POM validator

rascal-lsp/src/main/rascal/lsp/lang/rascal/lsp/Actions.rsc

@@ -48,6 +48,7 @@ data Command
     = visualImportGraphCommand(PathConfig pcfg)
     | sortImportsAndExtends(Header h)
     | upgradeAnnotations(PathConfig pcfg)
+    | addRascalToPom(loc l)
     ;
 
 
@@ -165,3 +166,8 @@ value evaluateRascalCommand(upgradeAnnotations(PathConfig pcfg)) {
     return ("result":true);
 }
 
+value evaluateRascalCommand(addRascalToPom(loc l)) {
+
+    return ("result": true);
+}
+

rascal-lsp/src/main/rascal/lsp/lang/xml/PomAnalyzer.rsc

@@ -0,0 +1,123 @@
+module lang::xml::PomAnalyzer
+
+import lang::xml::DOM;
+import lang::xml::IO;
+import analysis::diff::edits::ExecuteTextEdits;
+import analysis::diff::edits::TextEdits;
+
+import IO;
+import List;
+import Node;
+import String;
+import util::IDEServices;
+import util::Maybe;
+
+bool(node) hasProperty(str tagName, str tagValue) {
+    return bool(node \node) {
+        return "<tagName>"(tagValue) <- getChildren(\node);
+    };
+}
+
+Maybe[&T](node) getProperty(type[&T] _, str tagName) {
+    return Maybe[&T](node \node) {
+        if ("<tagName>"(&T tagValue) <- getChildren(\node)) {
+            return just(tagValue);
+        }
+        return nothing();
+    };
+}
+
+node getChildNode(node n, str name) {
+    if (node child <- getChildren(n), name := getName(child)) {
+        return child;
+    }
+    throw "No child with name \'<name>\' in \'<getName(n)>\': <[getName(c) | node c <- getChildren(n)]>";
+}
+
+bool(node) hasRascalMplGroup = hasProperty("groupid", "org.rascalmpl");
+
+bool(node) isRascalArtifact = hasProperty("artifactid", "rascal");
+
+bool(node) isRascalLspArtifact = hasProperty("artifactid", "rascal-lsp");
+
+Maybe[node] getRascalDependency(list[node] dependencies) {
+    if (dep <- dependencies, hasRascalMplGroup(dep), isRascalArtifact(dep)) {
+        return just(dep);
+    }
+    return nothing();
+}
+
+Maybe[node] getRascalLspDependency(list[node] dependencies) {
+    if (dep <- dependencies, hasRascalMplGroup(dep), isRascalLspArtifact(dep)) {
+        return just(dep);
+    }
+    return nothing();
+}
+
+Maybe[str](node) getVersion = getProperty(#str, "version");
+
+str inferRascalVersion(Maybe[str] rascalLsp = nothing()) {
+    if (just(str lspVersion) := rascalLsp) {
+        // Figure out a compatible version
+        return "0.43.0";
+    }
+
+    // Read Rascal version from LSP dependencies
+    lspPom = |project://rascal-lsp/pom.xml|;
+    if (exists(lspPom), /"dependency"("groupid"("org.rascalmpl"), "artifactid"("rascal"), "version"(str rascalVersion)) := readXML(lspPom)) {
+        return rascalVersion;
+    }
+
+    xml = readXML(lspPom);
+    iprintln(xml);
+    return "0.43.0";
+}
+
+node dependencyTemplate(str artifactId, str version, str groupId="org.rascalmpl")
+    = "dependency"(
+        "groupId"(groupId),
+        "artifactId"(artifactId),
+        "version"(version)
+    );
+
+node dependenciesTemplate(node dependencies...)
+    = makeNode("dependencies", *dependencies);
+
+str prettyXML(node xml) {
+    prettied = xmlPretty(toXML(xml));
+    // `xmlPretty` assumes the node is a document and thus adds an `<?xml ...?>` tag at the start
+    return intercalate("\n", split("\n", prettied)[1..]);
+}
+
+void main(loc pomLoc = |project://rascal-vscode-extension/test-workspace/test-project/pom.xml|) {
+    if (node pom := readXML(pomLoc, trackOrigins = true)) {
+        // list[TextEdit] edits = [];
+        if (project := getChildNode(pom, "project")) {
+            if (dependenciesBlock := getChildNode(project, "dependencies")) {
+                dependencies = getChildren(dependenciesBlock);
+                if (just(rascal) := getRascalDependency(dependencies)) {
+                    println("Found Rascal dependency: <getVersion(rascal)>");
+                    // Check minimal version
+                    ;
+                } else {
+                    // No Rascal dependency; offer to add one
+                    println("No Rascal dependency found!");
+                    rascalLsp = getRascalLspDependency(dependencies);
+                    rascalVersion = inferRascalVersion(rascalLsp=getVersion(rascalLsp));
+                    insertionPoint = getFirstFrom(getChildren(dependenciesBlock));
+                    rascalEdit = insertAfter(dependenciesBlock.src, prettyXML(dependencyTemplate("rascal", rascalVersion)));
+                    iprintln(rascalEdit);
+                    applyFileSystemEdits([changed([rascalEdit])]);
+                }
+            } else {
+                println("No dependencies block found");
+                rascalEdit = insertAfter(getChildNode(project, "version").src, xmlPretty(toXML(dependenciesTemplate(dependencyTemplate("rascal", inferRascalVersion())))));
+                iprintln(rascalEdit);
+                applyFileSystemEdits([changed([rascalEdit])]);
+            }
+        } else {
+            println("Unrecoverably broken POM!");
+            ; // This a very sparse POM. We can probably not recover from this.
+        }
+    }
+}

rascal-vscode-extension/src/extension.ts

@@ -32,6 +32,7 @@ import { RascalExtension } from './RascalExtension';
 import { RascalMFValidator } from './ux/RascalMFValidator';
 import { RascalProjectValidator } from './ux/RascalProjectValidator';
 import { VsCodeSettingsFixer } from './ux/VsCodeSettingsFixer';
+import { PomXmlValidator } from './ux/PomXmlValidator';
 
 const testDeployMode = (process.env['RASCAL_LSP_DEV_DEPLOY'] || "false") === "true";
 const deployMode = (process.env['RASCAL_LSP_DEV'] || "false") !== "true";
@@ -44,6 +45,7 @@ export function activate(context: vscode.ExtensionContext) {
     logger.info(`Starting extension deployMode: ${deployMode} testDeployMode: ${testDeployMode}`);
     context.subscriptions.push(extension);
     context.subscriptions.push(new RascalMFValidator());
+    context.subscriptions.push(new PomXmlValidator(logger));
     context.subscriptions.push(new VsCodeSettingsFixer());
     context.subscriptions.push(new RascalProjectValidator(logger));
     if (!deployMode || testDeployMode) {

rascal-vscode-extension/src/ux/PomXmlValidator.ts

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2018-2025, NWO-I CWI and Swat.engineering
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+import * as vscode from 'vscode';
+import { isRascalProject, MF_DIR } from './RascalMFValidator';
+
+const POM_XML_FILE = "pom.xml";
+
+export class PomXmlValidator implements vscode.Disposable {
+    private readonly diagnostics: vscode.DiagnosticCollection;
+    private readonly disposables: vscode.Disposable[] = [];
+
+    constructor (private readonly logger: vscode.LogOutputChannel) {
+        logger.info("pom.xml validator starting");
+        this.diagnostics = vscode.languages.createDiagnosticCollection("pom.xml diagnostics");
+
+        // new projects should be checked
+        vscode.workspace.onDidChangeWorkspaceFolders(async ws => {
+            for (const added of ws.added) {
+                if (await isRascalProject(added.uri)) {
+                    void this.verifyPomXml(added.uri);
+                }
+            }
+            for (const rem of ws.removed) {
+                // clear messages of projects that are no longer in the workspace
+                this.diagnostics.delete(this.buildPomXmlChildPath(rem.uri));
+            }
+        }, this, this.disposables);
+
+        // check open folders
+        for (const openProject of vscode.workspace.workspaceFolders || []) {
+            const pomXmlUri = this.buildPomXmlChildPath(openProject.uri);
+            void vscode.workspace.fs.stat(pomXmlUri).then(_s => void this.verifyPomXml(pomXmlUri));
+        }
+
+        // watch the file system for changes to pom.xml files
+        const watcher = vscode.workspace.createFileSystemWatcher("**/" + POM_XML_FILE, true, false, false);
+        watcher.onDidCreate(this.verifyPomXml, this, this.disposables);
+        watcher.onDidChange(this.verifyPomXml, this, this.disposables);
+        watcher.onDidDelete(e => this.diagnostics.delete(e), this, this.disposables);
+        this.disposables.push(watcher);
+
+        this.disposables.push(
+            vscode.languages.registerCodeActionsProvider(
+                { pattern: "**/" + POM_XML_FILE },
+                new FixPomXmlIssues()
+            )
+        );
+    }
+
+    dispose() {
+        this.safeDispose(this.diagnostics);
+        for (const d of this.disposables) {
+            this.safeDispose(d);
+        }
+    }
+
+    private safeDispose(d: vscode.Disposable): void {
+        try {
+            d.dispose();
+        } catch (_e) { /* ignore errors */ }
+    }
+
+    private async verifyPomXml(file: vscode.Uri) {
+        try {
+            const pomXmlBody = await vscode.workspace.openTextDocument(file);
+            const diagnostics : vscode.Diagnostic[] = [];
+
+            try {
+                checkRascalDependency(pomXmlBody, diagnostics);
+            } finally {
+                this.diagnostics.set(file, diagnostics);
+            }
+        } catch (_error) {
+            // Ignore errors
+        }
+    }
+
+    private buildPomXmlChildPath(uri: vscode.Uri) {
+        return vscode.Uri.joinPath(uri, MF_DIR, POM_XML_FILE);
+    }
+}
+
+enum FixKind {
+    noRascalDependency = 1,
+    outdatedRascalDependency
+}
+
+class FixPomXmlIssues implements vscode.CodeActionProvider {
+    provideCodeActions(_document: vscode.TextDocument, _range: vscode.Range | vscode.Selection, context: vscode.CodeActionContext, _token: vscode.CancellationToken): vscode.ProviderResult<(vscode.CodeAction | vscode.Command)[]> {
+        const result: vscode.CodeAction[] = [];
+        for (const diag of context.diagnostics) {
+            switch (diag.code) {
+                case FixKind.noRascalDependency: {
+                    const addRascalDependency = new vscode.CodeAction("Add Rascal dependency", vscode.CodeActionKind.Empty);
+                    addRascalDependency.diagnostics = [diag];
+                    addRascalDependency.isPreferred = true;
+                    // addRascalDependency.command = ...
+                    // vscode.window.showErrorMessage("...");
+                    result.push(addRascalDependency);
+                    break;
+                }
+                case FixKind.outdatedRascalDependency: {
+                    // TODO
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+}
+const foo = /<!--([^-]*?|-->)/;
+
+// Pitfall: this regular expression only accepts groupId, artifactId, and version in that particular order, and does not support comments
+const dependencyMatcher = /<dependency>\s*<groupId>([^<]*?)<\/groupId>\s*<artifactId>([^<]*?)<\/artifactId>\s*<version>([^<]*?)<\/version>\s*<\/dependency>/g;
+
+function checkRascalDependency(pomXmlBody: vscode.TextDocument, diagnostics: vscode.Diagnostic[]) {
+    let match: RegExpExecArray | null;
+    const pomXmlText = pomXmlBody.getText();
+    while ((match = dependencyMatcher.exec(pomXmlText))) {
+        if (match[1] === "org.rascalmpl" && match[2] === "rascal") {
+            //TODO: check that version is new enough
+        }
+        return;
+    }
+    const diag = new vscode.Diagnostic(
+        new vscode.Range(0, 0, 0, 0), "Could not detect a Rascal dependency, please add one to this pom.xml"
+    );
+    diag.code = FixKind.noRascalDependency;
+    diagnostics.push(diag);
+}

rascal-vscode-extension/src/ux/RascalMFValidator.ts

@@ -29,7 +29,7 @@ import {posix} from 'path'; // posix path join is always correct, also on window
 
 
 export const MF_FILE = "RASCAL.MF";
-const MF_DIR = "META-INF";
+export const MF_DIR = "META-INF";
 
 /**
  * Check for common errors in RASCAL.MF files, and try and fix them if possible