feat: parse POM deps/java.version

Author: FluoriteCafe-work

package-lock.json

@@ -1091,10 +1091,11 @@
     "fmtr": "^1.1.4",
     "fs-extra": "^10.1.0",
     "globby": "^13.1.3",
+    "htmlparser2": "^8.0.2",
     "lodash": "^4.17.21",
     "minimatch": "^5.1.6",
     "semver": "^7.3.8",
     "vscode-extension-telemetry-wrapper": "^0.14.0",
     "vscode-tas-client": "^0.1.75"
   }
-}
+}

package.json

@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+import { Document, isTag, Node, NodeWithChildren, Element, isText } from "domhandler";
+import * as hp from "htmlparser2";
+
+export type ElementNode = Node;
+export enum XmlTagName {
+    GroupId = "groupId",
+    ArtifactId = "artifactId",
+    Version = "version",
+    Dependencies = "dependencies",
+    DependencyManagement = "dependencyManagement",
+    Exclusions = "exclusions",
+    Plugins = "plugins",
+    Plugin = "plugin",
+    Project = "project",
+    Dependency = "dependency",
+    Properties = "properties",
+    Packaging = "packaging",
+    Module = "module",
+    Modules = "modules",
+    Parent = "parent",
+    RelativePath = "relativePath"
+}
+
+export function parseDocument(text: string): Document {
+    return hp.parseDocument(text, {
+        withEndIndices: true,
+        withStartIndices: true,
+        lowerCaseTags: false,
+        xmlMode: true,
+    });
+}
+
+export function getChildrenByTags(parentElement: NodeWithChildren, tags: string[]): Element[] {
+    const ret: Element[] = [];
+    for (const child of parentElement.children) {
+        if (isTag(child) && tags.includes(child.tagName)) {
+            ret.push(child);
+        }
+    }
+    return ret;
+}
+
+export function getExactlyOneChildByTag(parentElement: NodeWithChildren, tag: string): Element | undefined {
+    const items = getChildrenByTags(parentElement, [tag]);
+    if (items.length !== 1) {
+        return undefined;
+    }
+    return items[0];
+}
+
+export function getTextFromNode(node: Node | undefined | null, fallbackValue = "") {
+    return node && isText(node) ? node.data : fallbackValue;
+}

src/upgrade/lexerUtils.ts

@@ -0,0 +1,104 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import { Range, type TextDocument, Uri, workspace } from "vscode";
+import type { Element } from "domhandler";
+import { getChildrenByTags, getExactlyOneChildByTag, getTextFromNode, parseDocument, XmlTagName } from "./lexerUtils";
+import { buildPackageId, normalizePath } from "./utility";
+import { Dependency } from "./type";
+import { Upgrade } from "../constants";
+
+function getRangeOfNode(node: Element, vscodeDocument: TextDocument): Range | undefined {
+    if (!node.startIndex || !node.endIndex) {
+        return;
+    }
+    return new Range(
+        vscodeDocument.positionAt(node.startIndex),
+        vscodeDocument.positionAt(node.endIndex + 1),
+    )
+}
+
+function readDependencyNode(node: Element, vscodeDocument: TextDocument): Dependency | undefined {
+    const range = getRangeOfNode(node, vscodeDocument);
+    if (!range) {
+        return undefined;
+    }
+    const groupId = getExactlyOneChildByTag(node, XmlTagName.GroupId);
+    const artifactId = getExactlyOneChildByTag(node, XmlTagName.ArtifactId);
+    const version = getExactlyOneChildByTag(node, XmlTagName.Version);
+    if (!groupId || !artifactId) {
+        return undefined;
+    }
+    const groupIdText = getTextFromNode(groupId.children[0]);
+    const artifactIdText = getTextFromNode(artifactId.children[0]);
+    const versionText = version ? getTextFromNode(version.children[0]) : undefined;
+    return {
+        packageId: buildPackageId(groupIdText, artifactIdText),
+        version: versionText,
+        location: range,
+    }
+}
+
+
+
+class PomDataManager {
+    private pomMap: Record< /* pomPath */ string, Record<string /* packageId */, Range>> = {};
+
+    public async parsePom(pomPath: string) {
+        const normalizedPath = normalizePath(pomPath);
+        const pomDocument = await workspace.openTextDocument(Uri.parse(normalizedPath));
+        const documentText = pomDocument.getText();
+        const xmlDocument = await parseDocument(documentText);
+        this.pomMap[normalizedPath] = {};
+
+        const projectNode = getExactlyOneChildByTag(xmlDocument, XmlTagName.Project);
+        if (!projectNode) {
+            return;
+        }
+
+        const dependenciesNode = getExactlyOneChildByTag(projectNode, XmlTagName.Dependencies);
+        const dependencyManagementNode = getExactlyOneChildByTag(projectNode, XmlTagName.DependencyManagement);
+        const pomMap: Record<string /* packageId */, Range> = {};
+
+        if (dependencyManagementNode) {
+            const deps = getChildrenByTags(dependencyManagementNode, [XmlTagName.Dependency]);
+            deps.forEach((item) => {
+                const dep = readDependencyNode(item, pomDocument);
+                if (dep && (!pomMap[dep.packageId] || dep.version)) {
+                    pomMap[dep.packageId] = dep.location;
+                }
+            })
+        }
+        if (dependenciesNode) {
+            const deps = getChildrenByTags(dependenciesNode, [XmlTagName.Dependency]);
+            deps.forEach((item) => {
+                const dep = readDependencyNode(item, pomDocument);
+                if (dep && (!pomMap[dep.packageId] || dep.version)) {
+                    pomMap[dep.packageId] = dep.location;
+                }
+            })
+        }
+
+        const propertiesNode = getExactlyOneChildByTag(projectNode, XmlTagName.Properties);
+        if (propertiesNode) {
+            const javaVersionNode = getExactlyOneChildByTag(propertiesNode, "java.version");
+            if (javaVersionNode) {
+                const range = getRangeOfNode(javaVersionNode, pomDocument);
+                if (range) {
+                    pomMap[buildPackageId(Upgrade.DIAGNOSTICS_GROUP_ID_FOR_JAVA_ENGINE, "*")] = range;
+                }
+            }
+        }
+
+        this.pomMap[normalizedPath] = pomMap;
+    }
+
+    public getPomRange(pomPath: string, packageId: string): Range | undefined {
+        return this.pomMap[pomPath]?.[packageId];
+    }
+
+
+}
+
+const pomDataManager = new PomDataManager();
+export default pomDataManager;

src/upgrade/pomDataManager.ts

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
+import type { Range } from "vscode";
+
 export type MementoItem<T> = {
     lastUpdatedTs: number;
     data: T;
@@ -24,4 +26,10 @@ export type UpgradeIssue = {
     suggestedVersion?: string;
 }
 
+export type Dependency = {
+    packageId: string;
+    location: Range;
+    version?: string;
+}
+
 export type FileIssues = Record</* packageId */string, UpgradeIssue>;