metalint/lib/glob.js

"use strict";

const fs   = require("fs");
const path = require("path");

/**
 * Protège les caractères spéciaux des expressions rationnelles.
 *
 * @param {string} pattern Les caractères.
 * @return {string} Les caractères protégés.
 */
const sanitize = function (pattern) {
    return pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
};

/**
 * Transforme un patron en expression rationnelle.
 *
 * @param {string} pattern Le patron.
 * @return {Object.<string, Object>} La marque pour la négation et l'expression
 *                                   rationnelle.
 */
const compile = function (pattern) {
    const negate = pattern.startsWith("!");
    const glob = pattern.replace(/^!/, "");
    if ("**" === glob) {
        return { negate, "regexp": /.*/ };
    }

    let regexp = glob.startsWith("/") ? "^"
                                      : "^(.*/)?";

    for (let i = 0; i < glob.length; ++i) {
        if ("/" === glob[i]) {
            if ("/**/" === glob.substr(i, 4)) {
                regexp += "/.*/";
                i += 3;
            } else if ("/**" === glob.substr(i, 3)) {
                if (glob.length === i + 3) {
                    regexp += "/.*";
                    i += 2;
                } else {
                    throw new Error(pattern + ": ** non suivi d'un slash");
                }
            } else {
                regexp += "/";
            }
        } else if ("*" === glob[i]) {
            // Si c'est le dernier caractère ou qu'il n'est pas suivi par
            // étoile.
            if (glob.length === i + 1 || "*" !== glob[i + 1]) {
                regexp += "[^/]*";
            // Sinon : ce n'est pas le dernier caractère et le prochain est
            // une étoile.
            } else if (0 === i) {
                regexp += ".*";
                ++i;
            } else {
                throw new Error(pattern + ": ** non précédé d'un slash");
            }
        } else if ("?" === glob[i]) {
            regexp += "[^/]";
        } else if ("[" === glob[i]) {
            regexp += "[";
            for (++i; i < glob.length; ++i) {
                if ("]" === glob[i]) {
                    regexp += "]";
                    break;
                } else {
                    regexp += sanitize(glob[i]);
                }
            }
            if (i === glob.length) {
                throw new Error(pattern + ": ] manquant");
            }
        } else {
            regexp += sanitize(glob[i]);
        }
    }

    if (negate) {
        if (regexp.endsWith("/")) {
            regexp += ".*";
        } else {
            regexp += "(/.*)?";
        }
    } else if (!regexp.endsWith("/")) {
        regexp += "/?";
    }
    regexp += "$";

    return { negate, "regexp": new RegExp(regexp) };
};

/**
 * Teste si un fichier respecte un des patrons.
 *
 * @param {string}         file      L’adresse du fichier qui sera vérifié.
 * @param {Array.<string>} patterns  La liste des patrons.
 * @param {string}         root      L’adresse du répertoire où se trouve le
 *                                   dossier <code>.metalint/</code>.
 * @param {boolean}        directory La marque indiquant si le fichier est un
 *                                   répertoire.
 * @return {string} <code>"MATCHED"</code> si le fichier respecte au moins un
 *                  patron ; <code>"NEGATE"</code> si le fichier ne respecte
 *                  pas un patron négatif ; sinon <code>"NONE"</code>.
 */
const exec = function (file, patterns, root, directory) {
    const relative = "/" + path.relative(root, path.join(process.cwd(), file)) +
                     (directory ? "/" : "");

    let result = "NONE";
    for (const pattern of patterns) {
        if (pattern.negate) {
            if (pattern.regexp.test(relative)) {
                return "NEGATE";
            }
        } else if ("NONE" === result && pattern.regexp.test(relative)) {
            result = "MATCHED";
        }
    }
    return result;
};

const deep = function (base, patterns, root) {
    const directory = fs.lstatSync(base).isDirectory();
    const result = exec(base, patterns, root, directory);
    if ("NEGATE" === result) {
        return [];
    }

    const files = [];
    if ("MATCHED" === result) {
        files.push(base);
    }
    if (directory) {
        for (const file of fs.readdirSync(base)) {
            files.push(...deep(path.join(base, file), patterns, root));
        }
    }
    return files;
};

/**
 * Vérifie si un fichier respecte un des patrons.
 *
 * @param {string}         file      L’adresse du fichier qui sera vérifié.
 * @param {Array.<string>} patterns  La liste des patrons.
 * @param {string}         root      L’adresse du répertoire où se trouve le
 *                                   dossier <code>.metalint/</code>.
 * @param {boolean}        directory La marque indiquant si le fichier est un
 *                                   répertoire.
 * @return {boolean} <code>true</code> si le fichier respectent au moins un
 *                   patron ; sinon <code>false</code>.
 */
const test = function (file, patterns, root, directory) {
    return "MATCHED" === exec(file, patterns.map(compile), root, directory);
};

/**
 * Récupère toute l’arborescence des fichiers respectant un des patrons.
 *
 * @param {string}         bases    La liste des fichiers / répertoires servant
 *                                  de racine pour l’arborescence.
 * @param {Array.<string>} patterns La liste des patrons.
 * @param {string}          root    L’adresse du répertoire où se trouve le
 *                                  dossier <code>.metalint/</code>.
 * @return {Array.<string>} La liste des fichiers respectant un des patrons.
 */
const walk = function (bases, patterns, root) {
    if (0 === bases.length) {
        return deep(".", patterns.map(compile), root);
    }

    const files = [];
    for (const base of bases) {
        files.push(...deep(base, patterns.map(compile), root));
    }
    return files;
};

module.exports = { test, walk };