metalint 0.13.0 → 0.15.0

package/src/core/formatter/formatter.js

@@ -12,20 +12,6 @@ import { fileURLToPath } from "node:url";
  * @typedef {import("../../type/index.js").Notice} Notice
  */
 
-if (undefined === import.meta.resolve) {
-    /**
-     * Résous un chemin relatif à partir du module.
-     *
-     * @param {string} specifier Le chemin relatif vers un fichier ou un
-     *                           répertoire.
-     * @returns {string} L'URL absolue vers le fichier ou le répertoire.
-     * @see https://nodejs.org/api/esm.html#importmetaresolvespecifier-parent
-     */
-    import.meta.resolve = (specifier) => {
-        return new URL(specifier, import.meta.url).href;
-    };
-}
-
 /**
  * La liste des fichiers JavaScript des formateurs.
  *
@@ -39,10 +25,11 @@ const scripts = await fs.readdir(fileURLToPath(import.meta.resolve("./")));
  * @constant {string[]} FORMATTERS
  */
 export const FORMATTERS = scripts
-    // Enlever l'extension du fichier.
-    .map((f) => f.slice(0, -3))
-    // Enlever ce fichier qui n'est pas un vrai formateur.
-    .filter((f) => "formatter" !== f);
+    // Garder seulement les fichiers JavaScript et enlever le fichier
+    // "formatter.js" qui n'est pas un vrai formateur.
+    .filter((f) => f.endsWith(".js") && "formatter.js" !== f)
+    // Enlever l'extension des fichiers.
+    .map((f) => f.slice(0, -3));
 
 /**
  * Le formateur parent.

package/src/core/formatter/github.js

@@ -9,7 +9,7 @@ import Severities from "../severities.js";
 import Formatter from "./formatter.js";
 
 /**
- * @typedef {NodeJS.WritableStream} WritableStream
+ * @typedef {import("node:stream").Writable} Writable
  * @typedef {import("../../type/index.js").Level} Level
  * @typedef {import("../../type/index.js").Notice} Notice
  */
@@ -23,17 +23,17 @@ export default class GitHubFormatter extends Formatter {
     /**
      * Le flux où écrire les résultats.
      *
-     * @type {WritableStream}
+     * @type {Writable}
      */
     #writer;
 
     /**
      * Crée un formateur.
      *
-     * @param {Level}          level            Le niveau de sévérité minimum
-     *                                          des notifications affichées.
-     * @param {Object}         options          Les options du formateur.
-     * @param {WritableStream} [options.writer] Le flux où écrire les résultats.
+     * @param {Level}    level            Le niveau de sévérité minimum des
+     *                                    notifications affichées.
+     * @param {Object}   options          Les options du formateur.
+     * @param {Writable} [options.writer] Le flux où écrire les résultats.
      */
     constructor(level, options) {
         super(level);

package/src/core/formatter/json.js

@@ -8,13 +8,13 @@ import process from "node:process";
 import Formatter from "./formatter.js";
 
 /**
- * @typedef {NodeJS.WritableStream} WritableStream
+ * @typedef {import("node:stream").Writable} Writable
  * @typedef {import("../../type/index.js").Level} Level
  * @typedef {import("../../type/index.js").Notice} Notice
  */
 
 /**
- * Le formateur qui écrit les résultats brut (au format JSON). La seul
+ * Le formateur qui écrit les résultats bruts (au format JSON). La seule
  * altération des résultats est le remplacement des <code>undefined</code> par
  * des <code>null</code>.
  *
@@ -24,7 +24,7 @@ export default class JSONFormatter extends Formatter {
     /**
      * Le flux où écrire les résultats.
      *
-     * @type {WritableStream}
+     * @type {Writable}
      */
     #writer;
 
@@ -46,12 +46,12 @@ export default class JSONFormatter extends Formatter {
     /**
      * Crée un formateur.
      *
-     * @param {Level}          level            Le niveau de sévérité minimum
-     *                                          des notifications affichées.
-     * @param {Object}         options          Les options du formateur.
-     * @param {WritableStream} [options.writer] Le flux où écrire les résultats.
-     * @param {number}         [options.indent] La taille des indentations (en
-     *                                          espace).
+     * @param {Level}    level            Le niveau de sévérité minimum des
+     *                                    notifications affichées.
+     * @param {Object}   options          Les options du formateur.
+     * @param {Writable} [options.writer] Le flux où écrire les résultats.
+     * @param {number}   [options.indent] La taille des indentations (en
+     *                                    espace).
      */
     constructor(level, options) {
         super(level);

package/src/core/formatter/unix.js

@@ -8,7 +8,7 @@ import process from "node:process";
 import Formatter from "./formatter.js";
 
 /**
- * @typedef {NodeJS.WritableStream} WritableStream
+ * @typedef {import("node:stream").Writable} Writable
  * @typedef {import("../../type/index.js").Level} Level
  * @typedef {import("../../type/index.js").Notice} Notice
  */
@@ -21,7 +21,7 @@ export default class UnixFormatter extends Formatter {
     /**
      * Le flux où écrire les résultats.
      *
-     * @type {WritableStream}
+     * @type {Writable}
      */
     #writer;
 
@@ -35,10 +35,10 @@ export default class UnixFormatter extends Formatter {
     /**
      * Crée un formateur.
      *
-     * @param {Level}          level            Le niveau de sévérité minimum
-     *                                          des notifications affichées.
-     * @param {Object}         options          Les options du formateur.
-     * @param {WritableStream} [options.writer] Le flux où écrire les résultats.
+     * @param {Level}    level            Le niveau de sévérité minimum des
+     *                                    notifications affichées.
+     * @param {Object}   options          Les options du formateur.
+     * @param {Writable} [options.writer] Le flux où écrire les résultats.
      */
     constructor(level, options) {
         super(level);

package/src/core/index.js

@@ -4,8 +4,14 @@
  * @author Sébastien Règne
  */
 
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import flatten from "./configuration/flatten.js";
+import normalize from "./configuration/normalize.js";
 import { mergeLinters } from "./configuration/override.js";
-import Severities from "./severities.js";
+import Results from "./results.js";
+import { exists } from "./utils/file.js";
 import Glob from "./utils/glob.js";
 
 /**
@@ -13,140 +19,144 @@ import Glob from "./utils/glob.js";
  * @typedef {import("../type/index.d.ts").Notice} Notice
  */
 
-/**
- * Compare deux notifications. En commençant par le numéro de la ligne, puis
- * celui de la colonne.
- *
- * @param {Notice} notice1 La première notification.
- * @param {Notice} notice2 La seconde notification.
- * @returns {number} Un nombre négatif si la 1<sup>re</sup> notification est
- *                   inférieure à la 2<sup>de</sup> ; <code>0</code> si elles
- *                   sont égales ; sinon un nombre positif.
- */
-const compare = function (notice1, notice2) {
-    for (
-        let i = 0;
-        i < notice1.locations.length && i < notice2.locations.length;
-        ++i
-    ) {
-        const locations1 = notice1.locations[i];
-        const locations2 = notice2.locations[i];
-
-        let diff = locations1.line - locations2.line;
-        if (0 !== diff) {
-            return diff;
-        }
+export default class Metalint {
+    #root;
+    #glob;
+    #checkers;
+    #formatters;
+    #cache = new Map();
+
+    static async fromFileSystem(options = {}) {
+        const config = options.config ?? ".metalint/metalint.config.js";
 
-        diff = (locations1.column ?? -1) - (locations2.column ?? -1);
-        if (0 !== diff) {
-            return diff;
+        // Rechercher le fichier de configuration dans le répertoire courant,
+        // puis dans les parents, grands-parents...
+        let root = process.cwd();
+        while (!(await exists(path.join(root, config)))) {
+            // Si on est remonté à la racine.
+            if (path.join(root, "..") === root) {
+                throw new Error("No such config file.");
+            }
+            root = path.join(root, "..");
         }
+
+        // eslint-disable-next-line no-unsanitized/method
+        const { default: configuration } = await import(
+            pathToFileURL(path.join(root, config))
+        );
+        const { patterns, reporters, checkers } = flatten(
+            await normalize(configuration, {
+                dir: path.dirname(path.join(root, config)),
+            }),
+            {
+                fix: options.fix,
+                formatter: options.formatter,
+                level: options.level,
+            },
+        );
+        return new Metalint({ root, patterns, reporters, checkers });
     }
-    return notice1.locations.length - notice2.locations.length;
-};
 
-const Results = class {
-    /**
-     * Les données des résultats.
-     *
-     * @type {Record<string, Notice[]|undefined>}
-     */
-    #data;
+    constructor(config) {
+        this.#root = config.root;
+        this.#glob = new Glob(config.patterns, { root: config.root });
 
-    constructor(files) {
-        this.#data = Object.fromEntries(files.map((f) => [f, undefined]));
+        this.#formatters = config.reporters.map((reporter) => {
+            // eslint-disable-next-line new-cap
+            return new reporter.formatter(reporter.level, reporter.options);
+        });
+
+        this.#checkers = config.checkers.map((checker) => ({
+            ...checker,
+            glob: new Glob(checker.patterns, { root: this.#root }),
+            overrides: checker.overrides.map((override) => ({
+                ...override,
+                glob: new Glob(override.patterns, { root: this.#root }),
+            })),
+        }));
     }
 
-    add(file, notices) {
-        // Ajouter un tableau vide dans les données pour indiquer que le fichier
-        // a été analysé par au moins un linter.
-        if (undefined === this.#data[file]) {
-            this.#data[file] = [];
+    /**
+     * Vérifie (en appelant des linters) des répertoires et des fichiers.
+     *
+     * @param {string[]} bases Les répertoires et les fichiers.
+     * @returns {Promise<Record<string, Notice[]|undefined>>} Une promesse
+     *                                                        retournant la
+     *                                                        liste des
+     *                                                        notifications
+     *                                                        regroupées par
+     *                                                        fichier.
+     */
+    async lintFiles(bases) {
+        const files = [];
+        for (const base of bases) {
+            files.push(...(await this.#glob.walk(base)));
         }
-        for (const notice of notices) {
-            // Vérifier aussi le fichier de la notification car il peut être
-            // différent du fichier d'origine (qui est peut être un répertoire
-            // ou une archive).
-            if (undefined === this.#data[notice.file]) {
-                this.#data[notice.file] = [];
+        const results = new Results(files);
+        for (const file of files) {
+            for (const checker of this.#checkers) {
+                if (checker.glob.test(file)) {
+                    let key = checker.patterns.join();
+                    const values = [checker.linters];
+                    for (const override of checker.overrides) {
+                        if (override.glob.test(file)) {
+                            key += "|" + override.patterns.join();
+                            values.push(override.linters);
+                        }
+                    }
+
+                    let wrappers = [];
+                    if (this.#cache.has(key)) {
+                        wrappers = this.#cache.get(key);
+                    } else {
+                        const linters = values.reduce(mergeLinters);
+                        for (const linter of linters) {
+                            wrappers.push(
+                                // eslint-disable-next-line new-cap
+                                new linter.wrapper(
+                                    {
+                                        fix: linter.fix,
+                                        level: linter.level,
+                                        root: this.#root,
+                                        files,
+                                    },
+                                    linter.options,
+                                ),
+                            );
+                        }
+                        this.#cache.set(key, wrappers);
+                    }
+                    for (const wrapper of wrappers) {
+                        results.add(file, await wrapper.lint(file));
+                    }
+                }
             }
-            this.#data[notice.file].push({
-                rule: undefined,
-                severity: Severities.ERROR,
-                locations: [],
-                ...notice,
-            });
         }
-    }
 
-    toObject() {
-        // Trier les notifications.
-        Object.values(this.#data)
-            .filter((r) => undefined !== r)
-            .forEach((r) => r.sort(compare));
-        return this.#data;
+        return results.toObject();
     }
-};
 
-/**
- * Vérifie (en appelant des linters) une liste de fichiers.
- *
- * @param {string[]}                 files    La liste des fichiers.
- * @param {FlattenedConfigChecker[]} checkers La liste des vérifications faites
- *                                            sur les fichiers.
- * @param {string}                   root     L'adresse du répertoire où se
- *                                            trouve le répertoire
- *                                            <code>.metalint/</code>.
- * @returns {Promise<Record<string, Notice[]|undefined>>} Une promesse
- *                                                        retournant la liste
- *                                                        des notifications
- *                                                        regroupées par
- *                                                        fichier.
- */
-export default async function metalint(files, checkers, root) {
-    const cache = new Map();
-    const results = new Results(files);
-    for (const file of files) {
-        for (const checker of checkers) {
-            const glob = new Glob(checker.patterns, { root });
-            if (glob.test(file)) {
-                const key = [glob];
-                const values = [checker.linters];
-                for (const override of checker.overrides) {
-                    const subglob = new Glob(override.patterns, { root });
-                    if (subglob.test(file)) {
-                        key.push(subglob);
-                        values.push(override.linters);
-                    }
-                }
+    async report(results) {
+        let severity;
 
-                let wrappers = [];
-                if (cache.has(key)) {
-                    wrappers = cache.get(key);
-                } else {
-                    const linters = values.reduce(mergeLinters);
-                    for (const linter of linters) {
-                        wrappers.push(
-                            // eslint-disable-next-line new-cap
-                            new linter.wrapper(
-                                {
-                                    fix: linter.fix,
-                                    level: linter.level,
-                                    root,
-                                    files,
-                                },
-                                linter.options,
-                            ),
-                        );
+        for (const [file, notices] of Object.entries(results)) {
+            // Déterminer la sévérité la plus élevée des résultats.
+            if (undefined !== notices) {
+                for (const notice of notices) {
+                    if (undefined === severity || severity > notice.severity) {
+                        severity = notice.severity;
                     }
-                    cache.set(key, wrappers);
-                }
-                for (const wrapper of wrappers) {
-                    results.add(file, await wrapper.lint(file));
                 }
             }
+
+            // Afficher les notifications avec chaque rapporteur.
+            for (const formatter of this.#formatters) {
+                await formatter.notify(file, notices);
+            }
         }
-    }
 
-    return results.toObject();
+        // Attendre tous les rapporteurs.
+        await Promise.all(this.#formatters.map((f) => f.finalize()));
+        return severity;
+    }
 }

package/src/core/results.js

@@ -0,0 +1,86 @@
+/**
+ * @module
+ * @license MIT
+ * @author Sébastien Règne
+ */
+
+import Severities from "./severities.js";
+
+/**
+ * @typedef {import("../type/index.d.ts").Notice} Notice
+ */
+
+/**
+ * Compare deux notifications. En commençant par le numéro de la ligne, puis
+ * celui de la colonne.
+ *
+ * @param {Notice} notice1 La première notification.
+ * @param {Notice} notice2 La seconde notification.
+ * @returns {number} Un nombre négatif si la 1<sup>re</sup> notification est
+ *                   inférieure à la 2<sup>de</sup> ; <code>0</code> si elles
+ *                   sont égales ; sinon un nombre positif.
+ */
+const compare = function (notice1, notice2) {
+    for (
+        let i = 0;
+        i < notice1.locations.length && i < notice2.locations.length;
+        ++i
+    ) {
+        const locations1 = notice1.locations[i];
+        const locations2 = notice2.locations[i];
+
+        let diff = locations1.line - locations2.line;
+        if (0 !== diff) {
+            return diff;
+        }
+
+        diff = (locations1.column ?? -1) - (locations2.column ?? -1);
+        if (0 !== diff) {
+            return diff;
+        }
+    }
+    return notice1.locations.length - notice2.locations.length;
+};
+
+export default class Results {
+    /**
+     * Les données des résultats.
+     *
+     * @type {Record<string, Notice[]|undefined>}
+     */
+    #data;
+
+    constructor(files) {
+        this.#data = Object.fromEntries(files.map((f) => [f, undefined]));
+    }
+
+    add(file, notices) {
+        // Ajouter un tableau vide dans les données pour indiquer que le fichier
+        // a été analysé par au moins un linter.
+        if (undefined === this.#data[file]) {
+            this.#data[file] = [];
+        }
+        for (const notice of notices) {
+            // Vérifier aussi le fichier de la notification, car il peut être
+            // différent du fichier d'origine (qui est peut-être un répertoire
+            // ou une archive).
+            if (undefined === this.#data[notice.file]) {
+                this.#data[notice.file] = [];
+            }
+            this.#data[notice.file].push({
+                rule: undefined,
+                severity: Severities.ERROR,
+                locations: [],
+                ...notice,
+            });
+        }
+    }
+
+    toObject() {
+        // Trier les notifications.
+        Object.values(this.#data)
+            .filter((r) => undefined !== r)
+            .forEach((r) => r.sort(compare));
+        return this.#data;
+    }
+}

package/src/core/utils/array.js

@@ -9,7 +9,7 @@
  *
  * @template T
  * @param {T|T[]} value L'élément.
- * @returns {T[]} Un avec seulement l'élément d'entré ou l'élément.
+ * @returns {T[]} Un tableau avec seulement l'élément d'entrée ou l'élément.
  */
 export const wrap = function (value) {
     return Array.isArray(value) ? value : [value];

package/src/core/utils/glob.js

@@ -180,7 +180,7 @@ export default class Glob {
     /**
      * Teste si un fichier / répertoire respecte les patrons.
      *
-     * @param {string} file Le chemin du fichier / répertoire  qui sera vérifié.
+     * @param {string} file Le chemin du fichier / répertoire qui sera vérifié.
      * @returns {string} <code>"DEEP_NEGATIVE"</code> pour un répertoire ne
      *                   respectant pas un patron qui exclue aussi ses
      *                   fichiers ; <code>"NEGATIVE"</code> si le fichier /

package/src/core/wrapper/addons-linter.js

@@ -47,13 +47,10 @@ export default class AddonsLinterWrapper extends Wrapper {
     constructor(context, options) {
         super(context);
         this.#options = {
-            logLevel: "error",
-            stack: false,
-            metadata: false,
+            logLevel: "silent",
+            // Ne rien afficher dans la console.
             output: "none",
-            boring: false,
-            selfHosted: false,
-            shouldScanFile: () => true,
+            shouldScanFile: (_fileOrDirName, _isDir) => true,
             ...options,
         };
     }

package/src/core/wrapper/ajv.js

@@ -0,0 +1,122 @@
+/**
+ * @module
+ * @license MIT
+ * @author Sébastien Règne
+ */
+
+import fs from "node:fs/promises";
+import Ajv from "ajv";
+import Levels from "../levels.js";
+import Severities from "../severities.js";
+import Wrapper from "./wrapper.js";
+
+/**
+ * @typedef {import("../../type/index.d.ts").Level} Level
+ * @typedef {import("../../type/index.d.ts").PartialNotice} PartialNotice
+ */
+
+/**
+ * L'enrobage du linter <strong>Ajv</strong>.
+ *
+ * @see https://www.npmjs.com/package/ajv
+ */
+export default class AjvWrapper extends Wrapper {
+    /**
+     * Les options du linter.
+     *
+     * @type {Record<string, any>}
+     * @see https://ajv.js.org/options.html#ajv-options
+     */
+    #options;
+
+    /**
+     * L'éventuelle fonction pour ajouter des formats.
+     *
+     * @type {Function|undefined}
+     * @see https://ajv.js.org/guide/formats.html
+     */
+    #addFormats;
+
+    /**
+     * Le schéma du fichier JSON.
+     *
+     * @type {Record<string, any>}
+     */
+    #schema;
+
+    /**
+     * Crée un enrobage pour le linter <strong>Ajv</strong>.
+     *
+     * @param {Object}              context       Le contexte de l'enrobage.
+     * @param {Level}               context.level Le niveau de sévérité minimum
+     *                                            des notifications retournées.
+     * @param {boolean}             context.fix   La marque indiquant s'il faut
+     *                                            corriger le fichier.
+     * @param {string}              context.root  L'adresse du répertoire où se
+     *                                            trouve le répertoire
+     *                                            <code>.metalint/</code>.
+     * @param {string[]}            context.files La liste de tous les fichiers
+     *                                            analysés.
+     * @param {Record<string, any>} options       Les options du linter.
+     */
+    constructor(context, options) {
+        super(context);
+        const { addFormats, schema, ...others } = options;
+        this.#options = {
+            loadSchema: (uri) =>
+                Promise.reject(
+                    new Error(
+                        `loadSchema() must be implemented to load ${uri}`,
+                    ),
+                ),
+            ...others,
+        };
+        this.#addFormats = addFormats;
+        this.#schema = schema;
+    }
+
+    /**
+     * Vérifie un fichier.
+     *
+     * @param {string} file Le fichier qui sera vérifié.
+     * @returns {Promise<PartialNotice[]>} Une promesse retournant la liste des
+     *                                     notifications.
+     */
+    async lint(file) {
+        if (Levels.FATAL > this.level) {
+            return [];
+        }
+
+        try {
+            const source = await fs.readFile(file, "utf8");
+            const ajv = new Ajv(this.#options);
+            if (undefined !== this.#addFormats) {
+                this.#addFormats(ajv);
+            }
+            const validate = await ajv.compileAsync(this.#schema);
+            validate(JSON.parse(source));
+            if (null === validate.errors) {
+                return [];
+            }
+
+            return validate.errors
+                .map((result) => ({
+                    file,
+                    linter: "ajv",
+                    rule: result.keyword,
+                    severity: Severities.ERROR,
+                    message: ajv.errorsText([result], { dataVar: "" }),
+                }))
+                .filter((n) => this.level >= n.severity);
+        } catch (err) {
+            return [
+                {
+                    file,
+                    linter: "ajv",
+                    severity: Severities.FATAL,
+                    message: err.message,
+                },
+            ];
+        }
+    }
+}