ilib-lint 2.0.0 → 2.0.1

package/docs/ReleaseNotes.md

@@ -1,6 +1,32 @@
 Release Notes
 ============================
 
+### v2.0.1
+- fixed loading of plugins
+    - if a plugin `ilib-lint-x` exists and a different package `x`
+      also exists that is unrelated to ilib-lint, and the config
+      says to load the plugin named simply `x`, it would first attempt
+      to load package `x`, succeed to load it, but then fail to
+      initialize it because `x` is not really an ilib-lint plugin.
+    - Another problem is that if this type of error occurred, it
+      would not attempt to load any other paths or plugins. This means
+      it would not load the perfectly valid plugin that is there
+      just because there was a conflicting package name.
+    - Additionally, if given a path directly to the plugin (absolute
+      or relative), it would not load that specific plugin and just
+      fail completely.
+    - Now, it:
+        - loads the specific plugin given a path to it
+        - if the plugin name is specified with the prefix like
+          `ilib-lint-x` it will attempt to load that package in various
+          locations until it finds one that works
+        - if the name is specified as simply `x`, it will attempt to
+          load the `ilib-lint-x` package first and only if it fails to
+          load or does not initialize properly will it fall back to
+          attempting to load the package just named just `x`
+- updated dependencies
+- fixed to set the formatter which designated from the command line option.
+
 ### v2.0.0
 
 - updated to use ilib-lint-common instead of i18nlint-common. (Same library, new name.)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ilib-lint",
-    "version": "2.0.0",
+    "version": "2.0.1",
     "module": "./src/index.js",
     "type": "module",
     "bin": "./src/index.js",
@@ -61,24 +61,24 @@
     },
     "devDependencies": {
         "@tsconfig/node14": "^14.1.0",
-        "@types/node": "^20.8.5",
+        "@types/node": "^20.11.27",
         "docdash": "^2.0.2",
         "ilib-lint-plugin-test": "file:test/ilib-lint-plugin-test",
         "ilib-lint-plugin-obsolete": "file:test/ilib-lint-plugin-obsolete",
         "i18nlint-plugin-test-old": "file:test/i18nlint-plugin-test-old",
         "jest": "^29.7.0",
         "jsdoc": "^4.0.2",
-        "jsdoc-to-markdown": "^8.0.0",
+        "jsdoc-to-markdown": "^8.0.1",
         "npm-run-all": "^4.1.5",
-        "typescript": "^5.2.2"
+        "typescript": "^5.4.2"
     },
     "dependencies": {
-        "@formatjs/intl": "^2.9.3",
+        "@formatjs/intl": "^2.10.0",
         "ilib-common": "^1.1.3",
         "ilib-lint-common": "^3.0.0",
         "ilib-locale": "^1.2.2",
-        "ilib-localeinfo": "^1.0.5",
-        "ilib-tools-common": "^1.8.1",
+        "ilib-localeinfo": "^1.1.0",
+        "ilib-tools-common": "^1.9.1",
         "intl-messageformat": "^10.5",
         "json5": "^2.2.3",
         "log4js": "^6.9.1",

package/src/PluginManager.js

@@ -40,44 +40,6 @@ function checkVersion(json, name) {
     }
 }
 
-/**
- * @private
- */
-function attemptLoad(name) {
-    logger.trace(`Trying module ${name}`);
-    return import(name);
-};
-
-/**
- * Needed because node does not know how to load ES modules
- * from a path. (Even though that is what it does when you
- * just name the module without a path. Sigh.)
- *
- * @private
- */
-function attemptLoadPath(name) {
-    logger.trace(`Trying directory module ${name}`);
-    let packagePath = name;
-    const packageName = path.join(name, "package.json");
-    if (fs.existsSync(name) && fs.existsSync(packageName)) {
-        const data = fs.readFileSync(packageName, "utf-8");
-        const json = JSON.parse(data);
-        checkVersion(json, name);
-        if (json.type === "module") {
-            let relativePath = json.module;
-            if (!relativePath && json.exports) {
-                const keys = Object.keys(json.exports);
-                relativePath = keys.length && json.exports[keys[0]].import;
-            }
-            if (relativePath) {
-                packagePath = path.join(name, relativePath);
-            }
-        }
-    }
-    logger.trace(`Path to this module is ${packagePath}`);
-    return import(packagePath);
-}
-
 /**
  * @class Represent a plugin manager, which loads a list of plugins
  * and then maintains references to them
@@ -110,69 +72,112 @@ class PluginManager {
         this.resolve = createRequire(import.meta.url).resolve;
     }
 
+    /**
+     * Needed because node does not know how to load ES modules
+     * from a path. (Even though that is what it does when you
+     * just name the module without a path. Sigh.)
+     *
+     * @private
+     */
+    async attemptLoad(name) {
+        logger.trace(`Trying module ${name}`);
+        let packagePath = name;
+        const packageName = this.resolve(path.join(name, "package.json"));
+        if (fs.existsSync(packageName)) {
+            const data = fs.readFileSync(packageName, "utf-8");
+            const json = JSON.parse(data);
+            checkVersion(json, name);
+            if (json.type === "module") {
+                let relativePath = json.module;
+                if (!relativePath && json.exports) {
+                    const keys = Object.keys(json.exports);
+                    relativePath = keys.length && json.exports[keys[0]].import;
+                }
+                if (relativePath) {
+                    packagePath = path.join(name, relativePath);
+                }
+            }
+        }
+        logger.trace(`Path to this module is ${packagePath}`);
+        return import(packagePath);
+    }
+
     /*
-     * Attempt to load the plugin in various places:
+     * Attempt to load the plugin.
+     *
+     * If the name is given with an absolute or relative path,
+     * then it will only try to load from that path, as the caller
+     * meant to load a very specific plugin. If the name is given as
+     * just a package name, it will attemp to load from various places:
      *
-     * - from the node_modules where ilib-lint was loaded
      * - from the current directory's node_modules
+     * - from the node_modules where ilib-lint was loaded
      * - from the plugins directory one directory up
+     * - from the global node_modules
      *
      * Each time it attempts to load it, it will try two ways:
      *
-     * - As-is. Maybe it is a fully specified package name?
-     * - With the "ilib-lint-" prefix. Try again except with
-     * the prefix. This allows the users to configure plugins
-     * in the config file more tersely, similar to the way
-     * babel plugins can be named with only the unique part.
-     * The old "i18nlint-" prefix is no longer accepted in
-     * either the name of the directory or the name of the
-     * package.
+     * - With the "ilib-lint-" prefix. Try with the prefix added to the
+     * name if it was not there already. This allows the users to configure
+     * plugins in the config file more tersely, similar to the way babel
+     * plugins can be named with only the unique part. The old "i18nlint-"
+     * prefix is no longer accepted in either the name of the directory
+     * or the name of the package.
+     * - As-is. Maybe it is a fully specified package name and doesn't have
+     * the prefix?
      *
      * @private
      */
-    loadPlugin(name) {
-        let pkgName = name;
-        return attemptLoad(pkgName).catch(e1 => {
-            logger.trace(e1);
-            pkgName = `ilib-lint-${name}`;
-            return attemptLoad(pkgName).catch(e2 => {
-                logger.trace(e2);
-                pkgName = path.join(process.cwd(), "node_modules", name);
-                return attemptLoadPath(pkgName).catch(e3 => {
-                    logger.trace(e3);
-                    pkgName = path.join(process.cwd(), "node_modules", `ilib-lint-${name}`);
-                    return attemptLoadPath(pkgName).catch(e4 => {
-                        logger.trace(e4);
-                        pkgName = path.join(process.cwd(), "..", "plugins", name + ".js")
-                        return attemptLoad(pkgName).catch(e5 => {
-                            logger.trace(e5);
-                            // on the last attempt, don't catch the exception. Just let it
-                            // go to the overall `catch` clause below.
-                            pkgName = path.join(process.cwd(), "..", "plugins", `ilib-lint-${name}` + ".js")
-                            return attemptLoad(pkgName);
-                        });
-                    });
-                });
-            });
-        }).then((module) => {
-            logger.trace(`Module ${name} loaded with package name ${pkgName}.`);
-            const modulePath = this.resolve(path.join(pkgName, "package.json"));
-            const packageJsonContent = fs.readFileSync(modulePath, 'utf-8');
-            const json = JSON.parse(packageJsonContent);
-            checkVersion(json, name);
+    async loadPlugin(name) {
+        const nameparts = path.parse(name);
 
-            logger.trace(`Module ${name} successfully loaded.`);
-            const Main = module.default;
-            const plugin = new Main({
-                getLogger: log4js.getLogger.bind(log4js)
-            });
-            plugin.init();
-            return plugin;
-        }).catch(e2 => {
-            logger.error(`Could not load plugin ${name}. If you have a plugin, make sure it is upgraded and depends on ilib-lint-common v3.0.0 or greater.`);
-            logger.trace(e2);
+        let pathsToTry;
+        if (nameparts.dir && nameparts.dir !== ".") {
+            // If it's a relative or absolute path, then only try this path. Do not add
+            // any prefixes or try any other directory or anything.
+            pathsToTry = [name];
+        } else if (nameparts.base.startsWith("ilib-lint-")) {
+            pathsToTry = [
+                path.join(process.cwd(), "node_modules", nameparts.base),
+                name,
+                path.join(process.cwd(), "..", "plugins", nameparts.name + ".js")
+            ];
+        } else {
+            const base = `ilib-lint-${nameparts.base}`;
+            // try the paths with the ilib-lint prefix first, and then try the ones
+            // without afterwards
+            pathsToTry = [
+                path.join(process.cwd(), "node_modules", base),
+                base,
+                path.join(process.cwd(), "..", "plugins", `ilib-lint-${nameparts.name}` + ".js"),
+                path.join(process.cwd(), "node_modules", nameparts.base),
+                name,
+                path.join(process.cwd(), "..", "plugins", nameparts.name + ".js"),
+            ];
+        }
+
+        let pkgName, module;
+        while ((pkgName = pathsToTry.shift())) {
+            try {
+                module = await this.attemptLoad(pkgName);
+                break;
+            } catch (e) {
+                logger.trace(e);
+            }
+        }
+
+        if (!module) {
+            logger.error(`Could not load plugin ${name}. If you know that you have a plugin, make sure it is upgraded and depends on ilib-lint-common v3.0.0 or greater.`);
             return undefined;
+        }
+
+        logger.trace(`Module ${name} successfully loaded.`);
+        const Main = module.default;
+        const plugin = new Main({
+            getLogger: log4js.getLogger.bind(log4js)
         });
+        plugin.init();
+        return plugin;
     };
 
     /**

package/src/Project.js

@@ -317,7 +317,7 @@ class Project extends DirItem {
                     }
                 }
             }
-            this.formatter = fmtMgr.get(this.options.formatter || "ansi-console-formatter");
+            this.formatter = fmtMgr.get(this.options?.opt?.formatter || this.options.formatter || "ansi-console-formatter");
             if (!this.formatter) {
                 logger.error(`Could not find formatter ${options.formatter}. Aborting...`);
                 process.exit(3);