metalint 0.14.1 → 0.16.0

package/src/core/configuration/normalize.js

@@ -11,24 +11,26 @@ import Levels from "../levels.js";
 import Wrapper, { WRAPPERS } from "../wrapper/wrapper.js";
 
 /**
- * @typedef {import("../../type/index.d.ts").Level} Level
- * @typedef {import("../../type/index.d.ts").NormalizedConfig} NormalizedConfig
- * @typedef {import("../../type/index.d.ts").NormalizedConfigChecker} NormalizedConfigChecker
- * @typedef {import("../../type/index.d.ts").NormalizedConfigLinter} NormalizedConfigLinter
- * @typedef {import("../../type/index.d.ts").NormalizedConfigOverride} NormalizedConfigOverride
- * @typedef {import("../../type/index.d.ts").NormalizedConfigReporter} NormalizedConfigReporter
+ * @typedef {import("../../types/configuration/normalized.d.ts").NormalizedConfig} NormalizedConfig
+ * @typedef {import("../../types/configuration/normalized.d.ts").NormalizedConfigChecker} NormalizedConfigChecker
+ * @typedef {import("../../types/configuration/normalized.d.ts").NormalizedConfigLinter} NormalizedConfigLinter
+ * @typedef {import("../../types/configuration/normalized.d.ts").NormalizedConfigOverride} NormalizedConfigOverride
+ * @typedef {import("../../types/configuration/normalized.d.ts").NormalizedConfigReporter} NormalizedConfigReporter
+ * @typedef {import("../../types/level.d.ts").default} Level
+ * @typedef {import("../../types/typeofformatter.d.ts").default} TypeofFormatter
+ * @typedef {import("../../types/typeofwrapper.d.ts").default} TypeofWrapper
  */
 
 /**
  * Lit un fichier JavaScript exportant un objet JSON.
  *
  * @param {string} file L'adresse du fichier qui sera lu.
- * @returns {Promise<Record<string, any>>} L'objet JSON récupéré.
+ * @returns {Promise<Record<string, unknown>>} L'objet JSON récupéré.
  */
 const read = async function (file) {
     try {
         // eslint-disable-next-line no-unsanitized/method
-        const module = await import(pathToFileURL(file));
+        const module = await import(pathToFileURL(file).href);
         return module.default;
     } catch (err) {
         throw new Error(`Cannot import '${file}'.`, { cause: err });
@@ -138,7 +140,7 @@ export const normalizeLevel = function (partial) {
  * Normalise une propriété <code>"formatter"</code>.
  *
  * @param {*} partial La valeur d'une propriété <code>"formatter"</code>.
- * @returns {Promise<typeof Formatter>} La valeur normalisée.
+ * @returns {Promise<TypeofFormatter>} La valeur normalisée.
  * @throws {Error}     Si le <code>"formatter"</code> est invalide.
  * @throws {TypeError} Si le <code>"formatter"</code> n'a pas le bon type.
  */
@@ -178,7 +180,7 @@ export const normalizeFormatter = async function (partial) {
  * @param {Object} context     Le context de la propriété.
  * @param {string} context.dir Le répertoire où se trouve le fichier
  *                             <code>metalint.config.js</code>.
- * @returns {Promise<Record<string, any>>} La valeur normalisée.
+ * @returns {Promise<Record<string, unknown>>} La valeur normalisée.
  * @throws {TypeError} Si l'<code>"options"</code> n'a pas le bon type.
  */
 export const normalizeOption = async function (partial, { dir }) {
@@ -202,7 +204,7 @@ export const normalizeOption = async function (partial, { dir }) {
  * @param {Object} context     Le context de la propriété.
  * @param {string} context.dir Le répertoire où se trouve le fichier
  *                             <code>metalint.config.js</code>.
- * @returns {Promise<Record<string, any>[]>} La valeur normalisée.
+ * @returns {Promise<Record<string, unknown>[]>} La valeur normalisée.
  * @throws {TypeError} Si l'<code>"options"</code> n'a pas le bon type.
  */
 export const normalizeOptions = async function (partials, { dir }) {
@@ -279,7 +281,7 @@ export const normalizeReporters = async function (partials, { dir }) {
  * Normalise une propriété <code>"wrapper"</code>.
  *
  * @param {*} partial La valeur d'une propriété <code>"wrapper"</code>.
- * @returns {Promise<typeof Wrapper>} La valeur normalisée.
+ * @returns {Promise<TypeofWrapper>} La valeur normalisée.
  * @throws {TypeError} Si le <code>"reporters"</code> n'a pas le bon type.
  */
 export const normalizeWrapper = async function (partial) {
@@ -358,7 +360,7 @@ export const normalizeLinter = async function (partial, { dir }) {
 export const normalizeLinters = async function (partials, { dir }) {
     let normalizeds;
     if (undefined === partials) {
-        normalizeds = [];
+        normalizeds = /** @type {NormalizedConfigLinter[]} */ ([]);
     } else if (Array.isArray(partials)) {
         normalizeds = await Promise.all(
             partials.map((p) => normalizeLinter(p, { dir })),
@@ -411,7 +413,7 @@ export const normalizeOverride = async function (partial, { dir }) {
 export const normalizeOverrides = async function (partials, { dir }) {
     let normalizeds;
     if (undefined === partials) {
-        normalizeds = [];
+        normalizeds = /** @type {NormalizedConfigOverride[]} */ ([]);
     } else if (Array.isArray(partials)) {
         normalizeds = await Promise.all(
             partials.map((p) => normalizeOverride(p, { dir })),
@@ -465,7 +467,7 @@ export const normalizeChecker = async function (partial, { dir }) {
 export const normalizeCheckers = async function (partials, { dir }) {
     let normalizeds;
     if (undefined === partials) {
-        normalizeds = [];
+        normalizeds = /** @type {NormalizedConfigChecker[]} */ ([]);
     } else if (Array.isArray(partials)) {
         normalizeds = await Promise.all(
             partials.map((p) => normalizeChecker(p, { dir })),
@@ -495,7 +497,7 @@ export const normalize = async function (partial, { dir }) {
     if ("object" === typeof partial) {
         normalized = {
             patterns: normalizePatterns(partial.patterns, { auto: [] }),
-            fix: normalizeFix(partial.fix),
+            fix: normalizeFix(partial.fix) ?? false,
             level: normalizeLevel(partial.level),
             reporters: await normalizeReporters(partial.reporters, { dir }),
             checkers: await normalizeCheckers(partial.checkers, { dir }),

package/src/core/configuration/override.js

@@ -7,7 +7,7 @@
 import { flattenFix, flattenLevel, flattenOptions } from "./flatten.js";
 
 /**
- * @typedef {import("../../type/index.d.ts").FlattenedConfigLinter} FlattenedConfigLinter
+ * @typedef {import("../../types/configuration/flattened.js").FlattenedConfigLinter} FlattenedConfigLinter
  */
 
 /**

package/src/core/formatter/checkstyle.js

@@ -10,8 +10,8 @@ import Formatter from "./formatter.js";
 
 /**
  * @typedef {import("node:stream").Writable} Writable
- * @typedef {import("../../type/index.js").Level} Level
- * @typedef {import("../../type/index.js").Notice} Notice
+ * @typedef {import("../../types/level.d.ts").default} Level
+ * @typedef {import("../../types/notice.d.ts").default} Notice
  */
 
 /**

package/src/core/formatter/console.js

@@ -12,10 +12,10 @@ import Formatter from "./formatter.js";
 
 /**
  * @typedef {import("node:stream").Writable} Writable
- * @typedef {import("../../type/index.js").Level} Level
- * @typedef {import("../../type/index.js").Location} Location
- * @typedef {import("../../type/index.js").Notice} Notice
- * @typedef {import("../../type/index.js").Severity} Severity
+ * @typedef {import("../../types/level.d.ts").default} Level
+ * @typedef {import("../../types/location.d.ts").default} Location
+ * @typedef {import("../../types/notice.d.ts").default} Notice
+ * @typedef {import("../../types/severity.d.ts").default} Severity
  */
 
 /**
@@ -97,7 +97,7 @@ const printCodeSource = function (locations, content, writer) {
         if (characters.length === i) {
             characters[i] = {
                 line: location.line,
-                columns: [],
+                columns: /** @type {number[]} */ ([]),
             };
             if (undefined !== location.column) {
                 characters[i].columns.push(location.column);
@@ -112,14 +112,14 @@ const printCodeSource = function (locations, content, writer) {
         printCodeSourceLine(line - 1, content, false, writer);
         printCodeSourceLine(line, content, true, writer);
         if (0 !== columns.length) {
-            let dashs = "-".repeat(6 + columns.at(-1));
+            let dashes = "-".repeat(6 + columns.at(-1));
             for (const column of columns) {
-                dashs =
-                    dashs.slice(0, 6 + column) +
+                dashes =
+                    dashes.slice(0, 6 + column) +
                     "^" +
-                    dashs.slice(6 + column + 1);
+                    dashes.slice(6 + column + 1);
             }
-            print(writer, dashs + "\n");
+            print(writer, dashes + "\n");
         }
         printCodeSourceLine(line + 1, content, false, writer);
         printCodeSourceLine(line + 2, content, false, writer);

package/src/core/formatter/csv.js

@@ -9,8 +9,8 @@ import Formatter from "./formatter.js";
 
 /**
  * @typedef {import("node:stream").Writable} Writable
- * @typedef {import("../../type/index.js").Level} Level
- * @typedef {import("../../type/index.js").Notice} Notice
+ * @typedef {import("../../types/level.d.ts").default} Level
+ * @typedef {import("../../types/notice.d.ts").default} Notice
  */
 
 /**

package/src/core/formatter/formatter.js

@@ -8,24 +8,10 @@ import fs from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 
 /**
- * @typedef {import("../../type/index.js").Level} Level
- * @typedef {import("../../type/index.js").Notice} Notice
+ * @typedef {import("../../types/level.d.ts").default} Level
+ * @typedef {import("../../types/notice.d.ts").default} 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

@@ -10,8 +10,8 @@ import Formatter from "./formatter.js";
 
 /**
  * @typedef {import("node:stream").Writable} Writable
- * @typedef {import("../../type/index.js").Level} Level
- * @typedef {import("../../type/index.js").Notice} Notice
+ * @typedef {import("../../types/level.d.ts").default} Level
+ * @typedef {import("../../types/notice.d.ts").default} Notice
  */
 
 /**

package/src/core/formatter/json.js

@@ -9,8 +9,8 @@ import Formatter from "./formatter.js";
 
 /**
  * @typedef {import("node:stream").Writable} Writable
- * @typedef {import("../../type/index.js").Level} Level
- * @typedef {import("../../type/index.js").Notice} Notice
+ * @typedef {import("../../types/level.d.ts").default} Level
+ * @typedef {import("../../types/notice.d.ts").default} Notice
  */
 
 /**

package/src/core/formatter/unix.js

@@ -9,8 +9,8 @@ import Formatter from "./formatter.js";
 
 /**
  * @typedef {import("node:stream").Writable} Writable
- * @typedef {import("../../type/index.js").Level} Level
- * @typedef {import("../../type/index.js").Notice} Notice
+ * @typedef {import("../../types/level.d.ts").default} Level
+ * @typedef {import("../../types/notice.d.ts").default} Notice
  */
 
 /**

package/src/core/index.js

@@ -4,149 +4,232 @@
  * @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";
 
 /**
- * @typedef {import("../type/index.d.ts").FlattenedConfigChecker} FlattenedConfigChecker
- * @typedef {import("../type/index.d.ts").Notice} Notice
+ * @typedef {import("../types/configuration/flattened.d.ts").FlattenedConfig} FlattenedConfig
+ * @typedef {import("../types/configuration/flattened.d.ts").FlattenedConfigChecker} FlattenedConfigChecker
+ * @typedef {import("../types/level.d.ts").default} Level
+ * @typedef {import("../types/notice.d.ts").default} Notice
+ * @typedef {import("../types/severity.d.ts").default} Severity
+ * @typedef {import("../types/typeofformatter.d.ts").default} TypeofFormatter
+ * @typedef {import("./formatter/formatter.js").default} Formatter
+ * @typedef {import("./wrapper/wrapper.js").default} Wrapper
  */
 
-/**
- * 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 {
+    /**
+     * Le répertoire racine.
+     *
+     * @type {string}
+     */
+    #root;
 
-        diff = (locations1.column ?? -1) - (locations2.column ?? -1);
-        if (0 !== diff) {
-            return diff;
-        }
-    }
-    return notice1.locations.length - notice2.locations.length;
-};
+    /**
+     * Les motifs généraux des fichiers.
+     *
+     * @type {Glob}
+     */
+    #glob;
+
+    /**
+     * Les checkers (avec leurs linters).
+     */
+    #checkers;
 
-const Results = class {
     /**
-     * Les données des résultats.
+     * Les formatters.
      *
-     * @type {Record<string, Notice[]|undefined>}
+     * @type {Formatter[]}
      */
-    #data;
+    #formatters;
 
-    constructor(files) {
-        this.#data = Object.fromEntries(files.map((f) => [f, undefined]));
-    }
+    /**
+     * Le cache des wrappers.
+     *
+     * @type {Map<string, Wrapper[]>}
+     */
+    #cache = new Map();
 
-    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] = [];
+    /**
+     * Crée une instance de Metalint à partir d'une configuration sur le système
+     * de fichiers.
+     *
+     * @param {Object}          [options]           Les éventuelles options pour
+     *                                              créer une instance de
+     *                                              Metalint.
+     * @param {string}          [options.config]    L'éventuel chemin vers le
+     *                                              fichier de configuration de
+     *                                              Metalint.
+     * @param {boolean}         [options.fix]       L'éventuelle marque
+     *                                              indiquant si les linters
+     *                                              doivent corriger les
+     *                                              fichiers.
+     * @param {TypeofFormatter} [options.formatter] L'éventuel formatteur à
+     *                                              utiliser.
+     * @param {Level}           [options.level]     L'éventuel niveau minimum
+     *                                              des notifications à
+     *                                              rapporter.
+     * @returns {Promise<Metalint>} Une promesse contenant l'instance de
+     *                              Metalint.
+     */
+    static async fromFileSystem(options = {}) {
+        const config = options.config ?? ".metalint/metalint.config.js";
+
+        // 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.");
             }
-            this.#data[notice.file].push({
-                rule: undefined,
-                severity: Severities.ERROR,
-                locations: [],
-                ...notice,
-            });
+            root = path.join(root, "..");
         }
+
+        // eslint-disable-next-line no-unsanitized/method
+        const { default: configuration } = await import(
+            pathToFileURL(path.join(root, config)).href
+        );
+        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({ patterns, reporters, checkers }, { root });
     }
 
-    toObject() {
-        // Trier les notifications.
-        Object.values(this.#data)
-            .filter((r) => undefined !== r)
-            .forEach((r) => r.sort(compare));
-        return this.#data;
+    /**
+     * Crée une instance de Metalint.
+     *
+     * @param {FlattenedConfig} config       La configuration de Metalint.
+     * @param {Object}          context      Le contexte.
+     * @param {string}          context.root Le répertoire racine.
+     */
+    constructor(config, { root }) {
+        this.#root = root;
+        this.#glob = new Glob(config.patterns, { root: this.#root });
+
+        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) => ({
+            glob: new Glob(checker.patterns, { root: this.#root }),
+            linters: checker.linters,
+            overrides: checker.overrides.map((override) => ({
+                glob: new Glob(override.patterns, { root: this.#root }),
+                linters: override.linters,
+            })),
+        }));
     }
-};
 
-/**
- * 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)) {
-                let key = checker.patterns.join();
-                const values = [checker.linters];
-                for (const override of checker.overrides) {
-                    const subglob = new Glob(override.patterns, { root });
-                    if (subglob.test(file)) {
-                        key += "|" + override.patterns.join();
-                        values.push(override.linters);
+    /**
+     * 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 = /** @type {string[]} */ ([]);
+        for (const base of bases) {
+            files.push(...(await this.#glob.walk(base)));
+        }
+        const results = new Results(files);
+        for (const file of files) {
+            for (const [i, checker] of Object.entries(this.#checkers)) {
+                if (checker.glob.test(file)) {
+                    let key = i.toString();
+                    const values = [checker.linters];
+                    for (const [j, override] of Object.entries(
+                        checker.overrides,
+                    )) {
+                        if (override.glob.test(file)) {
+                            key += `.${j}`;
+                            values.push(override.linters);
+                        }
                     }
-                }
 
-                let wrappers = [];
-                if (cache.has(key)) {
-                    wrappers = cache.get(key);
-                } else {
-                    const linters = values.reduce(mergeLinters);
-                    for (const linter of linters) {
-                        wrappers.push(
+                    let wrappers;
+                    if (this.#cache.has(key)) {
+                        wrappers = this.#cache.get(key);
+                    } else {
+                        wrappers = values.reduce(mergeLinters).map((linter) => {
                             // eslint-disable-next-line new-cap
-                            new linter.wrapper(
+                            return new linter.wrapper(
                                 {
                                     fix: linter.fix,
                                     level: linter.level,
-                                    root,
+                                    root: this.#root,
                                     files,
                                 },
                                 linter.options,
-                            ),
-                        );
+                            );
+                        });
+                        this.#cache.set(key, wrappers);
+                    }
+                    for (const wrapper of wrappers) {
+                        results.add(file, await wrapper.lint(file));
                     }
-                    cache.set(key, wrappers);
-                }
-                for (const wrapper of wrappers) {
-                    results.add(file, await wrapper.lint(file));
                 }
             }
         }
+
+        return results.toObject();
     }
 
-    return results.toObject();
+    /**
+     * Rapporte des résultats dans les formats choisis.
+     *
+     * @param {Record<string, Notice[]|undefined>} results La liste des
+     *                                                     notifications
+     *                                                     regroupées par
+     *                                                     fichier.
+     * @returns {Promise<Severity|undefined>} La sévérité la plus élevée des
+     *                                        notifications ; ou
+     *                                        <code>undefined</code> si les
+     *                                        résultats ont aucune notification.
+     */
+    async report(results) {
+        let severity;
+
+        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;
+                    }
+                }
+            }
+
+            // Afficher les notifications avec chaque rapporteur.
+            for (const formatter of this.#formatters) {
+                await formatter.notify(file, notices);
+            }
+        }
+
+        // Attendre tous les rapporteurs.
+        await Promise.all(this.#formatters.map((f) => f.finalize()));
+        return severity;
+    }
 }