eslint-plugin-n 14.0.0

package/lib/util/enumerate-property-names.js

@@ -0,0 +1,39 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const { CALL, CONSTRUCT, READ } = require("eslint-utils")
+
+/**
+ * Enumerate property names of a given object recursively.
+ * @param {object} trackMap The map for APIs to enumerate.
+ * @param {string[]|undefined} path The path to the current map.
+ * @returns {IterableIterator<string>} The property names of the map.
+ */
+function* enumeratePropertyNames(trackMap, path = []) {
+    for (const key of Object.keys(trackMap)) {
+        const value = trackMap[key]
+        if (typeof value !== "object") {
+            continue
+        }
+
+        path.push(key)
+
+        if (value[CALL]) {
+            yield `${path.join(".")}()`
+        }
+        if (value[CONSTRUCT]) {
+            yield `new ${path.join(".")}()`
+        }
+        if (value[READ]) {
+            yield path.join(".")
+        }
+        yield* enumeratePropertyNames(value, path)
+
+        path.pop()
+    }
+}
+
+module.exports = enumeratePropertyNames

package/lib/util/exists.js

@@ -0,0 +1,58 @@
+/**
+ * @author Toru Nagashima
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const fs = require("fs")
+const path = require("path")
+const Cache = require("./cache")
+
+const ROOT = /^(?:[/.]|\.\.|[A-Z]:\\|\\\\)(?:[/\\]\.\.)*$/u
+const cache = new Cache()
+
+/**
+ * Check whether the file exists or not.
+ * @param {string} filePath The file path to check.
+ * @returns {boolean} `true` if the file exists.
+ */
+function existsCaseSensitive(filePath) {
+    let dirPath = filePath
+
+    while (dirPath !== "" && !ROOT.test(dirPath)) {
+        const fileName = path.basename(dirPath)
+        dirPath = path.dirname(dirPath)
+
+        if (fs.readdirSync(dirPath).indexOf(fileName) === -1) {
+            return false
+        }
+    }
+
+    return true
+}
+
+/**
+ * Checks whether or not the file of a given path exists.
+ *
+ * @param {string} filePath - A file path to check.
+ * @returns {boolean} `true` if the file of a given path exists.
+ */
+module.exports = function exists(filePath) {
+    let result = cache.get(filePath)
+    if (result == null) {
+        try {
+            const relativePath = path.relative(process.cwd(), filePath)
+            result =
+                fs.statSync(relativePath).isFile() &&
+                existsCaseSensitive(relativePath)
+        } catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error
+            }
+            result = false
+        }
+        cache.set(filePath, result)
+    }
+
+    return result
+}

package/lib/util/get-allow-modules.js

@@ -0,0 +1,47 @@
+/**
+ * @author Toru Nagashima
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const DEFAULT_VALUE = Object.freeze([])
+
+/**
+ * Gets `allowModules` property from a given option object.
+ *
+ * @param {object|undefined} option - An option object to get.
+ * @returns {string[]|null} The `allowModules` value, or `null`.
+ */
+function get(option) {
+    if (option && option.allowModules && Array.isArray(option.allowModules)) {
+        return option.allowModules.map(String)
+    }
+    return null
+}
+
+/**
+ * Gets "allowModules" setting.
+ *
+ * 1. This checks `options` property, then returns it if exists.
+ * 2. This checks `settings.node` property, then returns it if exists.
+ * 3. This returns `[]`.
+ *
+ * @param {RuleContext} context - The rule context.
+ * @returns {string[]} A list of extensions.
+ */
+module.exports = function getAllowModules(context) {
+    return (
+        get(context.options && context.options[0]) ||
+        get(context.settings && context.settings.node) ||
+        DEFAULT_VALUE
+    )
+}
+
+module.exports.schema = {
+    type: "array",
+    items: {
+        type: "string",
+        pattern: "^(?:@[a-zA-Z0-9_\\-.]+/)?[a-zA-Z0-9_\\-.]+$",
+    },
+    uniqueItems: true,
+}

package/lib/util/get-configured-node-version.js

@@ -0,0 +1,39 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const { Range } = require("semver") //eslint-disable-line no-unused-vars
+const getPackageJson = require("./get-package-json")
+const getSemverRange = require("./get-semver-range")
+
+/**
+ * Get the `engines.node` field of package.json.
+ * @param {string} filename The path to the current linting file.
+ * @returns {Range|null} The range object of the `engines.node` field.
+ */
+function getEnginesNode(filename) {
+    const info = getPackageJson(filename)
+    return getSemverRange(info && info.engines && info.engines.node)
+}
+
+/**
+ * Gets version configuration.
+ *
+ * 1. Parse a given version then return it if it's valid.
+ * 2. Look package.json up and parse `engines.node` then return it if it's valid.
+ * 3. Return `>=8.0.0`.
+ *
+ * @param {string|undefined} version The version range text.
+ * @param {string} filename The path to the current linting file.
+ * This will be used to look package.json up if `version` is not a valid version range.
+ * @returns {Range} The configured version range.
+ */
+module.exports = function getConfiguredNodeVersion(version, filename) {
+    return (
+        getSemverRange(version) ||
+        getEnginesNode(filename) ||
+        getSemverRange(">=8.0.0")
+    )
+}

package/lib/util/get-convert-path.js

@@ -0,0 +1,189 @@
+/**
+ * @author Toru Nagashima
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const Minimatch = require("minimatch").Minimatch
+
+/**
+ * @param {any} x - An any value.
+ * @returns {any} Always `x`.
+ */
+function identity(x) {
+    return x
+}
+
+/**
+ * Converts old-style value to new-style value.
+ *
+ * @param {any} x - The value to convert.
+ * @returns {({include: string[], exclude: string[], replace: string[]})[]} Normalized value.
+ */
+function normalizeValue(x) {
+    if (Array.isArray(x)) {
+        return x
+    }
+
+    return Object.keys(x).map(pattern => ({
+        include: [pattern],
+        exclude: [],
+        replace: x[pattern],
+    }))
+}
+
+/**
+ * Ensures the given value is a string array.
+ *
+ * @param {any} x - The value to ensure.
+ * @returns {string[]} The string array.
+ */
+function toStringArray(x) {
+    if (Array.isArray(x)) {
+        return x.map(String)
+    }
+    return []
+}
+
+/**
+ * Creates the function which checks whether a file path is matched with the given pattern or not.
+ *
+ * @param {string[]} includePatterns - The glob patterns to include files.
+ * @param {string[]} excludePatterns - The glob patterns to exclude files.
+ * @returns {function} Created predicate function.
+ */
+function createMatch(includePatterns, excludePatterns) {
+    const include = includePatterns.map(pattern => new Minimatch(pattern))
+    const exclude = excludePatterns.map(pattern => new Minimatch(pattern))
+
+    return filePath =>
+        include.some(m => m.match(filePath)) &&
+        !exclude.some(m => m.match(filePath))
+}
+
+/**
+ * Creates a function which replaces a given path.
+ *
+ * @param {RegExp} fromRegexp - A `RegExp` object to replace.
+ * @param {string} toStr - A new string to replace.
+ * @returns {function} A function which replaces a given path.
+ */
+function defineConvert(fromRegexp, toStr) {
+    return filePath => filePath.replace(fromRegexp, toStr)
+}
+
+/**
+ * Combines given converters.
+ * The result function converts a given path with the first matched converter.
+ *
+ * @param {{match: function, convert: function}} converters - A list of converters to combine.
+ * @returns {function} A function which replaces a given path.
+ */
+function combine(converters) {
+    return filePath => {
+        for (const converter of converters) {
+            if (converter.match(filePath)) {
+                return converter.convert(filePath)
+            }
+        }
+        return filePath
+    }
+}
+
+/**
+ * Parses `convertPath` property from a given option object.
+ *
+ * @param {object|undefined} option - An option object to get.
+ * @returns {function|null} A function which converts a path., or `null`.
+ */
+function parse(option) {
+    if (
+        !option ||
+        !option.convertPath ||
+        typeof option.convertPath !== "object"
+    ) {
+        return null
+    }
+
+    const converters = []
+    for (const pattern of normalizeValue(option.convertPath)) {
+        const include = toStringArray(pattern.include)
+        const exclude = toStringArray(pattern.exclude)
+        const fromRegexp = new RegExp(String(pattern.replace[0]))  
+        const toStr = String(pattern.replace[1])
+
+        converters.push({
+            match: createMatch(include, exclude),
+            convert: defineConvert(fromRegexp, toStr),
+        })
+    }
+
+    return combine(converters)
+}
+
+/**
+ * Gets "convertPath" setting.
+ *
+ * 1. This checks `options` property, then returns it if exists.
+ * 2. This checks `settings.node` property, then returns it if exists.
+ * 3. This returns a function of identity.
+ *
+ * @param {RuleContext} context - The rule context.
+ * @returns {function} A function which converts a path.
+ */
+module.exports = function getConvertPath(context) {
+    return (
+        parse(context.options && context.options[0]) ||
+        parse(context.settings && context.settings.node) ||
+        identity
+    )
+}
+
+/**
+ * JSON Schema for `convertPath` option.
+ */
+module.exports.schema = {
+    anyOf: [
+        {
+            type: "object",
+            properties: {},
+            patternProperties: {
+                "^.+$": {
+                    type: "array",
+                    items: { type: "string" },
+                    minItems: 2,
+                    maxItems: 2,
+                },
+            },
+            additionalProperties: false,
+        },
+        {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    include: {
+                        type: "array",
+                        items: { type: "string" },
+                        minItems: 1,
+                        uniqueItems: true,
+                    },
+                    exclude: {
+                        type: "array",
+                        items: { type: "string" },
+                        uniqueItems: true,
+                    },
+                    replace: {
+                        type: "array",
+                        items: { type: "string" },
+                        minItems: 2,
+                        maxItems: 2,
+                    },
+                },
+                additionalProperties: false,
+                required: ["include", "replace"],
+            },
+            minItems: 1,
+        },
+    ],
+}

package/lib/util/get-npmignore.js

@@ -0,0 +1,184 @@
+/**
+ * @author Toru Nagashima
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const fs = require("fs")
+const path = require("path")
+const ignore = require("ignore")
+const Cache = require("./cache")
+const exists = require("./exists")
+const getPackageJson = require("./get-package-json")
+
+const cache = new Cache()
+const SLASH_AT_BEGIN_AND_END = /^!?\/+|^!|\/+$/gu
+const PARENT_RELATIVE_PATH = /^\.\./u
+const NEVER_IGNORED = /^(?:readme\.[^.]*|(?:licen[cs]e|changes|changelog|history)(?:\.[^.]*)?)$/iu
+
+/**
+ * Checks whether or not a given file name is a relative path to a ancestor
+ * directory.
+ *
+ * @param {string} filePath - A file name to check.
+ * @returns {boolean} `true` if the file name is a relative path to a ancestor
+ *      directory.
+ */
+function isAncestorFiles(filePath) {
+    return PARENT_RELATIVE_PATH.test(filePath)
+}
+
+/**
+ * @param {function} f - A function.
+ * @param {function} g - A function.
+ * @returns {function} A logical-and function of `f` and `g`.
+ */
+function and(f, g) {
+    return filePath => f(filePath) && g(filePath)
+}
+
+/**
+ * @param {function} f - A function.
+ * @param {function} g - A function.
+ * @param {function|null} h - A function.
+ * @returns {function} A logical-or function of `f`, `g`, and `h`.
+ */
+function or(f, g, h) {
+    return filePath => f(filePath) || g(filePath) || (h && h(filePath))
+}
+
+/**
+ * @param {function} f - A function.
+ * @returns {function} A logical-not function of `f`.
+ */
+function not(f) {
+    return filePath => !f(filePath)
+}
+
+/**
+ * Creates a function which checks whether or not a given file is ignoreable.
+ *
+ * @param {object} p - An object of package.json.
+ * @returns {function} A function which checks whether or not a given file is ignoreable.
+ */
+function filterNeverIgnoredFiles(p) {
+    const basedir = path.dirname(p.filePath)
+    const mainFilePath =
+        typeof p.main === "string" ? path.join(basedir, p.main) : null
+
+    return filePath =>
+        path.join(basedir, filePath) !== mainFilePath &&
+        filePath !== "package.json" &&
+        !NEVER_IGNORED.test(path.relative(basedir, filePath))
+}
+
+/**
+ * Creates a function which checks whether or not a given file should be ignored.
+ *
+ * @param {string[]|null} files - File names of whitelist.
+ * @returns {function|null} A function which checks whether or not a given file should be ignored.
+ */
+function parseWhiteList(files) {
+    if (!files || !Array.isArray(files)) {
+        return null
+    }
+
+    const ig = ignore()
+    const igN = ignore()
+    let hasN = false
+
+    for (const file of files) {
+        if (typeof file === "string" && file) {
+            const body = file.replace(SLASH_AT_BEGIN_AND_END, "")
+            if (file.startsWith("!")) {
+                igN.add(`${body}`)
+                igN.add(`${body}/**`)
+                hasN = true
+            } else {
+                ig.add(`/${body}`)
+                ig.add(`/${body}/**`)
+            }
+        }
+    }
+
+    return hasN
+        ? or(ig.createFilter(), not(igN.createFilter()))
+        : ig.createFilter()
+}
+
+/**
+ * Creates a function which checks whether or not a given file should be ignored.
+ *
+ * @param {string} basedir - The directory path "package.json" exists.
+ * @param {boolean} filesFieldExists - `true` if `files` field of `package.json` exists.
+ * @returns {function|null} A function which checks whether or not a given file should be ignored.
+ */
+function parseNpmignore(basedir, filesFieldExists) {
+    let filePath = path.join(basedir, ".npmignore")
+    if (!exists(filePath)) {
+        if (filesFieldExists) {
+            return null
+        }
+
+        filePath = path.join(basedir, ".gitignore")
+        if (!exists(filePath)) {
+            return null
+        }
+    }
+
+    const ig = ignore()
+    ig.add(fs.readFileSync(filePath, "utf8"))
+    return not(ig.createFilter())
+}
+
+/**
+ * Gets an object to check whether a given path should be ignored or not.
+ * The object is created from:
+ *
+ * - `files` field of `package.json`
+ * - `.npmignore`
+ *
+ * @param {string} startPath - A file path to lookup.
+ * @returns {object}
+ *      An object to check whther or not a given path should be ignored.
+ *      The object has a method `match`.
+ *      `match` returns `true` if a given file path should be ignored.
+ */
+module.exports = function getNpmignore(startPath) {
+    const retv = { match: isAncestorFiles }
+
+    const p = getPackageJson(startPath)
+    if (p) {
+        const data = cache.get(p.filePath)
+        if (data) {
+            return data
+        }
+
+        const filesIgnore = parseWhiteList(p.files)
+        const npmignoreIgnore = parseNpmignore(
+            path.dirname(p.filePath),
+            Boolean(filesIgnore)
+        )
+
+        if (filesIgnore && npmignoreIgnore) {
+            retv.match = and(
+                filterNeverIgnoredFiles(p),
+                or(isAncestorFiles, filesIgnore, npmignoreIgnore)
+            )
+        } else if (filesIgnore) {
+            retv.match = and(
+                filterNeverIgnoredFiles(p),
+                or(isAncestorFiles, filesIgnore)
+            )
+        } else if (npmignoreIgnore) {
+            retv.match = and(
+                filterNeverIgnoredFiles(p),
+                or(isAncestorFiles, npmignoreIgnore)
+            )
+        }
+
+        cache.set(p.filePath, retv)
+    }
+
+    return retv
+}

package/lib/util/get-package-json.js

@@ -0,0 +1,75 @@
+/**
+ * @author Toru Nagashima
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const fs = require("fs")
+const path = require("path")
+const Cache = require("./cache")
+
+const cache = new Cache()
+
+/**
+ * Reads the `package.json` data in a given path.
+ *
+ * Don't cache the data.
+ *
+ * @param {string} dir - The path to a directory to read.
+ * @returns {object|null} The read `package.json` data, or null.
+ */
+function readPackageJson(dir) {
+    const filePath = path.join(dir, "package.json")
+    try {
+        const text = fs.readFileSync(filePath, "utf8")
+        const data = JSON.parse(text)
+
+        if (typeof data === "object" && data !== null) {
+            data.filePath = filePath
+            return data
+        }
+    } catch (_err) {
+        // do nothing.
+    }
+
+    return null
+}
+
+/**
+ * Gets a `package.json` data.
+ * The data is cached if found, then it's used after.
+ *
+ * @param {string} [startPath] - A file path to lookup.
+ * @returns {object|null} A found `package.json` data or `null`.
+ *      This object have additional property `filePath`.
+ */
+module.exports = function getPackageJson(startPath = "a.js") {
+    const startDir = path.dirname(path.resolve(startPath))
+    let dir = startDir
+    let prevDir = ""
+    let data = null
+
+    do {
+        data = cache.get(dir)
+        if (data) {
+            if (dir !== startDir) {
+                cache.set(startDir, data)
+            }
+            return data
+        }
+
+        data = readPackageJson(dir)
+        if (data) {
+            cache.set(dir, data)
+            cache.set(startDir, data)
+            return data
+        }
+
+        // Go to next.
+        prevDir = dir
+        dir = path.resolve(dir, "..")
+    } while (dir !== prevDir)
+
+    cache.set(startDir, null)
+    return null
+}

package/lib/util/get-resolve-paths.js

@@ -0,0 +1,44 @@
+/**
+ * @author Toru Nagashima
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const DEFAULT_VALUE = Object.freeze([])
+
+/**
+ * Gets `resolvePaths` property from a given option object.
+ *
+ * @param {object|undefined} option - An option object to get.
+ * @returns {string[]|null} The `allowModules` value, or `null`.
+ */
+function get(option) {
+    if (option && option.resolvePaths && Array.isArray(option.resolvePaths)) {
+        return option.resolvePaths.map(String)
+    }
+    return null
+}
+
+/**
+ * Gets "resolvePaths" setting.
+ *
+ * 1. This checks `options` property, then returns it if exists.
+ * 2. This checks `settings.node` property, then returns it if exists.
+ * 3. This returns `[]`.
+ *
+ * @param {RuleContext} context - The rule context.
+ * @returns {string[]} A list of extensions.
+ */
+module.exports = function getResolvePaths(context, optionIndex = 0) {
+    return (
+        get(context.options && context.options[optionIndex]) ||
+        get(context.settings && context.settings.node) ||
+        DEFAULT_VALUE
+    )
+}
+
+module.exports.schema = {
+    type: "array",
+    items: { type: "string" },
+    uniqueItems: true,
+}

package/lib/util/get-semver-range.js

@@ -0,0 +1,30 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const { Range } = require("semver")
+const cache = new Map()
+
+/**
+ * Get the `semver.Range` object of a given range text.
+ * @param {string} x The text expression for a semver range.
+ * @returns {Range|null} The range object of a given range text.
+ * It's null if the `x` is not a valid range text.
+ */
+module.exports = function getSemverRange(x) {
+    const s = String(x)
+    let ret = cache.get(s) || null
+
+    if (!ret) {
+        try {
+            ret = new Range(s)
+        } catch (_error) {
+            // Ignore parsing error.
+        }
+        cache.set(s, ret)
+    }
+
+    return ret
+}