java-caller 3.0.0 → 3.1.0

package/lib/java-caller.js

@@ -6,6 +6,7 @@ const path = require("path");
 const { spawn } = require("child_process");
 const util = require("util");
 const execPromise = util.promisify(require("child_process").exec);
+const semver = require("semver");
 
 class JavaCaller {
     "use strict";
@@ -213,8 +214,10 @@ class JavaCaller {
         if (await this.getInstallInCache()) {
             return;
         }
+        const semverRule = `>=${this.minimumJavaVersion}.0.0` + (this.maximumJavaVersion ? ` <${this.maximumJavaVersion}.0.0` : '');
         const javaVersion = await this.getJavaVersion();
-        if (javaVersion === false || javaVersion < this.minimumJavaVersion || (this.maximumJavaVersion && javaVersion > this.maximumJavaVersion)) {
+        const requiresInstall = javaVersion === false ? true : !semver.satisfies(javaVersion, semverRule)
+        if (requiresInstall) {
             // Check if the appropriate version has already been installed
             const { javaVersionHome = null, javaVersionBin = null } = await this.findJavaVersionHome();
             if (javaVersionHome) {
@@ -254,7 +257,7 @@ class JavaCaller {
             const njreOptions = { type: javaTypeToInstall };
             const prevRequireMainFilename = require.main.filename; // hack require.main.filename to njre installs java where we want
             require.main.filename = packageJson;
-            const installDir = await njre.install(this.maximumJavaVersion || this.minimumJavaVersion, njreOptions);
+            const installDir = await njre.install(javaVersionToInstall, njreOptions);
             require.main.filename = prevRequireMainFilename; // unhack require.main.filename
             console.log(`Installed Java ${javaTypeToInstall} ${javaVersionToInstall} in ${installDir}...`);
 
@@ -283,24 +286,16 @@ class JavaCaller {
         try {
             const { stderr } = await execPromise("java -version");
             const match = /version "(.*?)"/.exec(stderr);
-            const parts = match[1].split(".");
-            let join = ".";
-            let versionStr = "";
-            for (const v of parts) {
-                versionStr += v;
-                if (join !== null) {
-                    versionStr += join;
-                    join = null;
-                }
-            }
-            versionStr = versionStr.replace("_", "");
-            let versionNb = parseFloat(versionStr);
-            if (versionNb < 2) {
-                versionStr = versionStr.substring(2);
-                versionNb = parseFloat(versionStr[0] + "." + versionStr.substring(2));
+
+            // see https://openjdk.org/jeps/223
+            // semver.coerce does awfully good job of parsing anything Java throws our way
+            const version = semver.valid(semver.coerce(match[1]))
+            if (version === null) {
+                throw new Error(`unparsable java version: ${match[1]}`)
             }
-            debug(`Found default java version ${versionNb}`);
-            return versionNb;
+
+            debug(`Found default java version ${version}`);
+            return version;
         } catch (e) {
             debug(`Java not found: ${e.message}`);
             return false;
@@ -310,41 +305,44 @@ class JavaCaller {
     // Browse locally installed java versions
     // check if one matches with javaType , minimumJavaVersion and maximumJavaVersion
     async findJavaVersionHome() {
-        let javaInstallsTopDir = this.javaCallerSupportDir + path.sep + "jre";
-        if (fse.existsSync(javaInstallsTopDir)) {
-            const dirContent = await fse.readdir(javaInstallsTopDir);
-            let cacheFutureItem;
-            let isFirst = true;
-            const dirContentFiltered = dirContent.filter((file) => {
-                if (!fse.statSync(path.join(javaInstallsTopDir, file)).isDirectory()) {
-                    return false;
-                }
-                const versionMatches = file.includes("u")
-                    ? file.substring(0, file.indexOf("u")).match(/(\d+)/)
-                    : file.substring(0, file.indexOf(".")).match(/(\d+)/);
-                const versionFound = parseInt(versionMatches[0], 10);
-                const isMatching = this.checkMatchingJavaVersion(versionFound, file);
-                if (isMatching && isFirst) {
-                    cacheFutureItem = { versionFound, file };
-                    isFirst = false;
-                }
-                return isMatching;
-            });
-            if (dirContentFiltered[0]) {
-                const javaVersionHome = javaInstallsTopDir + path.sep + dirContentFiltered[0];
-                const javaVersionBin = javaVersionHome + path.sep + this.getPlatformBinPath();
-                if (fse.existsSync(javaVersionBin)) {
-                    debug(
-                        `Found matching java bin: ${javaVersionBin} for ${this.javaType ? this.javaType : "jre or jdk"} ${this.minimumJavaVersion}${
-                            this.maximumJavaVersion && this.maximumJavaVersion !== this.minimumJavaVersion ? " -> " + this.maximumJavaVersion : "+"
-                        }`
-                    );
-                    this.addInCache(cacheFutureItem.versionFound, cacheFutureItem.file, javaVersionHome, javaVersionBin);
-                    return { javaVersionHome, javaVersionBin };
-                }
-            }
+        const javaInstallsTopDir = path.join(this.javaCallerSupportDir, "jre");
+        if (!fse.existsSync(javaInstallsTopDir)) {
+            return {};
         }
-        return {};
+
+        return await fse.readdir(javaInstallsTopDir)
+            .then((items) =>
+                items
+                .filter((item) => fse.statSync(path.join(javaInstallsTopDir, item)).isDirectory())
+                .map((folder) => {
+                    const version = semver.coerce(folder)
+                    return { version, folder }
+                })
+                .filter(({ version, folder }) => this.checkMatchingJavaVersion(version.major, folder))
+                .map(({ version, folder }) => {
+                    const home = path.join(javaInstallsTopDir, folder);
+                    const bin = path.join(home, this.getPlatformBinPath());
+                    return { version, folder, home, bin }
+                })
+                .find(({ bin }) => fse.existsSync(bin))
+            )
+            .then((match) => {
+                if (!match) return {};
+                const { version, folder, home, bin } = match
+
+                debug(
+                    `Found matching java bin: ${bin} for ${this.javaType ? this.javaType : "jre or jdk"} ${this.minimumJavaVersion}${
+                        this.maximumJavaVersion && this.maximumJavaVersion !== this.minimumJavaVersion ? " -> " + this.maximumJavaVersion : "+"
+                    }`
+                );
+                this.addInCache(version.major, folder, home, bin);
+
+                return { javaVersionHome: home, javaVersionBin: bin };
+            })
+            .catch((e) => {
+                debug(`findJavaVersionHome failed: ${e}`)
+                return {}
+            })
     }
 
     checkMatchingJavaVersion(versionFound, file) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "java-caller",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "Library to easily call java from node sources. Automatically installs java if not present",
   "main": "./lib/index.js",
   "files": [
@@ -37,10 +37,11 @@
   "dependencies": {
     "debug": "^4.3.4",
     "fs-extra": "^11.1.1",
-    "njre": "^1.0.0"
+    "njre": "^1.0.0",
+    "semver": "^7.5.4"
   },
   "devDependencies": {
-    "@babel/eslint-parser": "^7.19.1",
+    "@babel/eslint-parser": "^7.22.15",
     "eslint": "^8.27.0",
     "mocha": "^10.1.0",
     "nyc": "^15.1.0",