eslint-plugin-n 14.0.0

package/lib/rules/shebang.js

@@ -0,0 +1,170 @@
+/**
+ * @author Toru Nagashima
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const path = require("path")
+const getConvertPath = require("../util/get-convert-path")
+const getPackageJson = require("../util/get-package-json")
+
+const NODE_SHEBANG = "#!/usr/bin/env node\n"
+const SHEBANG_PATTERN = /^(#!.+?)?(\r)?\n/u
+const NODE_SHEBANG_PATTERN = /#!\/usr\/bin\/env node(?: [^\r\n]+?)?\n/u
+
+function simulateNodeResolutionAlgorithm(filePath, binField) {
+    const possibilities = [filePath]
+    let newFilePath = filePath.replace(/\.js$/u, "")
+    possibilities.push(newFilePath)
+    newFilePath = newFilePath.replace(/[/\\]index$/u, "")
+    possibilities.push(newFilePath)
+    return possibilities.includes(binField)
+}
+
+/**
+ * Checks whether or not a given path is a `bin` file.
+ *
+ * @param {string} filePath - A file path to check.
+ * @param {string|object|undefined} binField - A value of the `bin` field of `package.json`.
+ * @param {string} basedir - A directory path that `package.json` exists.
+ * @returns {boolean} `true` if the file is a `bin` file.
+ */
+function isBinFile(filePath, binField, basedir) {
+    if (!binField) {
+        return false
+    }
+    if (typeof binField === "string") {
+        return simulateNodeResolutionAlgorithm(
+            filePath,
+            path.resolve(basedir, binField)
+        )
+    }
+    return Object.keys(binField).some(key =>
+        simulateNodeResolutionAlgorithm(
+            filePath,
+            path.resolve(basedir, binField[key])
+        )
+    )
+}
+
+/**
+ * Gets the shebang line (includes a line ending) from a given code.
+ *
+ * @param {SourceCode} sourceCode - A source code object to check.
+ * @returns {{length: number, bom: boolean, shebang: string, cr: boolean}}
+ *      shebang's information.
+ *      `retv.shebang` is an empty string if shebang doesn't exist.
+ */
+function getShebangInfo(sourceCode) {
+    const m = SHEBANG_PATTERN.exec(sourceCode.text)
+
+    return {
+        bom: sourceCode.hasBOM,
+        cr: Boolean(m && m[2]),
+        length: (m && m[0].length) || 0,
+        shebang: (m && m[1] && `${m[1]}\n`) || "",
+    }
+}
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "suggest correct usage of shebang",
+            category: "Possible Errors",
+            recommended: true,
+            url:
+                "https://github.com/mysticatea/eslint-plugin-node/blob/HEAD/docs/rules/shebang.md",
+        },
+        type: "problem",
+        fixable: "code",
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    //
+                    convertPath: getConvertPath.schema,
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    create(context) {
+        const sourceCode = context.getSourceCode()
+        let filePath = context.getFilename()
+        if (filePath === "<input>") {
+            return {}
+        }
+        filePath = path.resolve(filePath)
+
+        const p = getPackageJson(filePath)
+        if (!p) {
+            return {}
+        }
+
+        const basedir = path.dirname(p.filePath)
+        filePath = path.join(
+            basedir,
+            getConvertPath(context)(
+                path.relative(basedir, filePath).replace(/\\/gu, "/")
+            )
+        )
+
+        const needsShebang = isBinFile(filePath, p.bin, basedir)
+        const info = getShebangInfo(sourceCode)
+
+        return {
+            Program(node) {
+                if (
+                    needsShebang
+                        ? NODE_SHEBANG_PATTERN.test(info.shebang)
+                        : !info.shebang
+                ) {
+                    // Good the shebang target.
+                    // Checks BOM and \r.
+                    if (needsShebang && info.bom) {
+                        context.report({
+                            node,
+                            message: "This file must not have Unicode BOM.",
+                            fix(fixer) {
+                                return fixer.removeRange([-1, 0])
+                            },
+                        })
+                    }
+                    if (needsShebang && info.cr) {
+                        context.report({
+                            node,
+                            message:
+                                "This file must have Unix linebreaks (LF).",
+                            fix(fixer) {
+                                const index = sourceCode.text.indexOf("\r")
+                                return fixer.removeRange([index, index + 1])
+                            },
+                        })
+                    }
+                } else if (needsShebang) {
+                    // Shebang is lacking.
+                    context.report({
+                        node,
+                        message:
+                            'This file needs shebang "#!/usr/bin/env node".',
+                        fix(fixer) {
+                            return fixer.replaceTextRange(
+                                [-1, info.length],
+                                NODE_SHEBANG
+                            )
+                        },
+                    })
+                } else {
+                    // Shebang is extra.
+                    context.report({
+                        node,
+                        message: "This file needs no shebang.",
+                        fix(fixer) {
+                            return fixer.removeRange([0, info.length])
+                        },
+                    })
+                }
+            },
+        }
+    },
+}

package/lib/util/cache.js

@@ -0,0 +1,58 @@
+/**
+ * @author Toru Nagashima
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const SKIP_TIME = 5000
+
+/**
+ * The class of cache.
+ * The cache will dispose of each value if the value has not been accessed
+ * during 5 seconds.
+ */
+module.exports = class Cache {
+    /**
+     * Initialize this cache instance.
+     */
+    constructor() {
+        this.map = new Map()
+    }
+
+    /**
+     * Get the cached value of the given key.
+     * @param {any} key The key to get.
+     * @returns {any} The cached value or null.
+     */
+    get(key) {
+        const entry = this.map.get(key)
+        const now = Date.now()
+
+        if (entry) {
+            if (entry.expire > now) {
+                entry.expire = now + SKIP_TIME
+                return entry.value
+            }
+            this.map.delete(key)
+        }
+        return null
+    }
+
+    /**
+     * Set the value of the given key.
+     * @param {any} key The key to set.
+     * @param {any} value The value to set.
+     * @returns {void}
+     */
+    set(key, value) {
+        const entry = this.map.get(key)
+        const expire = Date.now() + SKIP_TIME
+
+        if (entry) {
+            entry.value = value
+            entry.expire = expire
+        } else {
+            this.map.set(key, { value, expire })
+        }
+    }
+}

package/lib/util/check-existence.js

@@ -0,0 +1,40 @@
+/**
+ * @author Toru Nagashima
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const exists = require("./exists")
+const getAllowModules = require("./get-allow-modules")
+
+/**
+ * Checks whether or not each requirement target exists.
+ *
+ * It looks up the target according to the logic of Node.js.
+ * See Also: https://nodejs.org/api/modules.html
+ *
+ * @param {RuleContext} context - A context to report.
+ * @param {ImportTarget[]} targets - A list of target information to check.
+ * @returns {void}
+ */
+module.exports = function checkForExistence(context, targets) {
+    const allowed = new Set(getAllowModules(context))
+
+    for (const target of targets) {
+        const missingModule =
+            target.moduleName != null &&
+            !allowed.has(target.moduleName) &&
+            target.filePath == null
+        const missingFile =
+            target.moduleName == null && !exists(target.filePath)
+
+        if (missingModule || missingFile) {
+            context.report({
+                node: target.node,
+                loc: target.node.loc,
+                message: '"{{name}}" is not found.',
+                data: target,
+            })
+        }
+    }
+}

package/lib/util/check-extraneous.js

@@ -0,0 +1,52 @@
+/**
+ * @author Toru Nagashima
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const getAllowModules = require("./get-allow-modules")
+const getPackageJson = require("./get-package-json")
+
+/**
+ * Checks whether or not each requirement target is published via package.json.
+ *
+ * It reads package.json and checks the target exists in `dependencies`.
+ *
+ * @param {RuleContext} context - A context to report.
+ * @param {string} filePath - The current file path.
+ * @param {ImportTarget[]} targets - A list of target information to check.
+ * @returns {void}
+ */
+module.exports = function checkForExtraneous(context, filePath, targets) {
+    const packageInfo = getPackageJson(filePath)
+    if (!packageInfo) {
+        return
+    }
+
+    const allowed = new Set(getAllowModules(context))
+    const dependencies = new Set(
+        [].concat(
+            Object.keys(packageInfo.dependencies || {}),
+            Object.keys(packageInfo.devDependencies || {}),
+            Object.keys(packageInfo.peerDependencies || {}),
+            Object.keys(packageInfo.optionalDependencies || {})
+        )
+    )
+
+    for (const target of targets) {
+        const extraneous =
+            target.moduleName != null &&
+            target.filePath != null &&
+            !dependencies.has(target.moduleName) &&
+            !allowed.has(target.moduleName)
+
+        if (extraneous) {
+            context.report({
+                node: target.node,
+                loc: target.node.loc,
+                message: '"{{moduleName}}" is extraneous.',
+                data: target,
+            })
+        }
+    }
+}

package/lib/util/check-prefer-global.js

@@ -0,0 +1,63 @@
+/**
+ * @author Toru Nagashima
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const { ReferenceTracker } = require("eslint-utils")
+
+/**
+ * Verifier for `prefer-global/*` rules.
+ */
+class Verifier {
+    /**
+     * Initialize this instance.
+     * @param {RuleContext} context The rule context to report.
+     * @param {{modules:object,globals:object}} trackMap The track map.
+     */
+    constructor(context, trackMap) {
+        this.context = context
+        this.trackMap = trackMap
+        this.verify =
+            context.options[0] === "never"
+                ? this.verifyToPreferModules
+                : this.verifyToPreferGlobals
+    }
+
+    /**
+     * Verify the code to suggest the use of globals.
+     * @returns {void}
+     */
+    verifyToPreferGlobals() {
+        const { context, trackMap } = this
+        const tracker = new ReferenceTracker(context.getScope(), {
+            mode: "legacy",
+        })
+
+        for (const { node } of [
+            ...tracker.iterateCjsReferences(trackMap.modules),
+            ...tracker.iterateEsmReferences(trackMap.modules),
+        ]) {
+            context.report({ node, messageId: "preferGlobal" })
+        }
+    }
+
+    /**
+     * Verify the code to suggest the use of modules.
+     * @returns {void}
+     */
+    verifyToPreferModules() {
+        const { context, trackMap } = this
+        const tracker = new ReferenceTracker(context.getScope())
+
+        for (const { node } of tracker.iterateGlobalReferences(
+            trackMap.globals
+        )) {
+            context.report({ node, messageId: "preferModule" })
+        }
+    }
+}
+
+module.exports = function checkForPreferGlobal(context, trackMap) {
+    new Verifier(context, trackMap).verify()
+}

package/lib/util/check-publish.js

@@ -0,0 +1,71 @@
+/**
+ * @author Toru Nagashima
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const path = require("path")
+const getAllowModules = require("./get-allow-modules")
+const getConvertPath = require("./get-convert-path")
+const getNpmignore = require("./get-npmignore")
+const getPackageJson = require("./get-package-json")
+
+/**
+ * Checks whether or not each requirement target is published via package.json.
+ *
+ * It reads package.json and checks the target exists in `dependencies`.
+ *
+ * @param {RuleContext} context - A context to report.
+ * @param {string} filePath - The current file path.
+ * @param {ImportTarget[]} targets - A list of target information to check.
+ * @returns {void}
+ */
+module.exports = function checkForPublish(context, filePath, targets) {
+    const packageInfo = getPackageJson(filePath)
+    if (!packageInfo) {
+        return
+    }
+
+    const allowed = new Set(getAllowModules(context))
+    const convertPath = getConvertPath(context)
+    const basedir = path.dirname(packageInfo.filePath)
+     
+    const toRelative = fullPath => {
+        const retv = path.relative(basedir, fullPath).replace(/\\/gu, "/")
+        return convertPath(retv)
+    }
+    const npmignore = getNpmignore(filePath)
+    const devDependencies = new Set(
+        Object.keys(packageInfo.devDependencies || {})
+    )
+    const dependencies = new Set(
+        [].concat(
+            Object.keys(packageInfo.dependencies || {}),
+            Object.keys(packageInfo.peerDependencies || {}),
+            Object.keys(packageInfo.optionalDependencies || {})
+        )
+    )
+
+    if (!npmignore.match(toRelative(filePath))) {
+        // This file is published, so this cannot import private files.
+        for (const target of targets) {
+            const isPrivateFile =
+                target.moduleName == null &&
+                npmignore.match(toRelative(target.filePath))
+            const isDevPackage =
+                target.moduleName != null &&
+                devDependencies.has(target.moduleName) &&
+                !dependencies.has(target.moduleName) &&
+                !allowed.has(target.moduleName)
+
+            if (isPrivateFile || isDevPackage) {
+                context.report({
+                    node: target.node,
+                    loc: target.node.loc,
+                    message: '"{{name}}" is not published.',
+                    data: { name: target.moduleName || target.name },
+                })
+            }
+        }
+    }
+}

package/lib/util/check-restricted.js

@@ -0,0 +1,109 @@
+/**
+ * @author Toru Nagashima
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const path = require("path")
+const { Minimatch } = require("minimatch")
+
+/** @typedef {import("../util/import-target")} ImportTarget */
+/**
+ * @typedef {Object} DefinitionData
+ * @property {string | string[]} name The name to disallow.
+ * @property {string} [message] The custom message to show.
+ */
+
+/**
+ * Check if matched or not.
+ * @param {InstanceType<Minimatch>} matcher The matcher.
+ * @param {boolean} absolute The flag that the matcher is for absolute paths.
+ * @param {ImportTarget} importee The importee information.
+ */
+function match(matcher, absolute, { filePath, name }) {
+    if (absolute) {
+        return filePath != null && matcher.match(filePath)
+    }
+    return matcher.match(name)
+}
+
+/** Restriction. */
+class Restriction {
+    /**
+     * Initialize this restriction.
+     * @param {DefinitionData} def The definition of a restriction.
+     */
+    constructor({ name, message }) {
+        const names = Array.isArray(name) ? name : [name]
+        const matchers = names.map(raw => {
+            const negate = raw[0] === "!" && raw[1] !== "("
+            const pattern = negate ? raw.slice(1) : raw
+            const absolute = path.isAbsolute(pattern)
+            const matcher = new Minimatch(pattern, { dot: true })
+            return { absolute, matcher, negate }
+        })
+
+        this.matchers = matchers
+        this.message = message ? ` ${message}` : ""
+    }
+
+    /**
+     * Check if a given importee is disallowed.
+     * @param {ImportTarget} importee The importee to check.
+     * @returns {boolean} `true` if the importee is disallowed.
+     */
+    match(importee) {
+        return this.matchers.reduce(
+            (ret, { absolute, matcher, negate }) =>
+                negate
+                    ? ret && !match(matcher, absolute, importee)
+                    : ret || match(matcher, absolute, importee),
+            false
+        )
+    }
+}
+
+/**
+ * Create a restriction.
+ * @param {string | DefinitionData} def A definition.
+ * @returns {Restriction} Created restriction.
+ */
+function createRestriction(def) {
+    if (typeof def === "string") {
+        return new Restriction({ name: def })
+    }
+    return new Restriction(def)
+}
+
+/**
+ * Create restrictions.
+ * @param {(string | DefinitionData | GlobDefinition)[]} defs Definitions.
+ * @returns {(Restriction | GlobRestriction)[]} Created restrictions.
+ */
+function createRestrictions(defs) {
+    return (defs || []).map(createRestriction)
+}
+
+/**
+ * Checks if given importees are disallowed or not.
+ * @param {RuleContext} context - A context to report.
+ * @param {ImportTarget[]} targets - A list of target information to check.
+ * @returns {void}
+ */
+module.exports = function checkForRestriction(context, targets) {
+    const restrictions = createRestrictions(context.options[0])
+
+    for (const target of targets) {
+        const restriction = restrictions.find(r => r.match(target))
+        if (restriction) {
+            context.report({
+                node: target.node,
+                messageId: "restricted",
+                data: {
+                    name: target.name,
+                    customMessage: restriction.message,
+                },
+            })
+        }
+    }
+}

package/lib/util/check-unsupported-builtins.js

@@ -0,0 +1,108 @@
+/**
+ * @author Toru Nagashima
+ * See LICENSE file in root directory for full license.
+ */
+"use strict"
+
+const { Range, lt, major } = require("semver") //eslint-disable-line no-unused-vars
+const { ReferenceTracker } = require("eslint-utils")
+const getConfiguredNodeVersion = require("./get-configured-node-version")
+const getSemverRange = require("./get-semver-range")
+
+/**
+ * @typedef {Object} SupportInfo
+ * @property {string | null} supported The stably supported version. If `null` is present, it hasn't been supported yet.
+ * @property {string[]} [backported] The backported versions.
+ * @property {string} [experimental] The added version as experimental.
+ */
+
+/**
+ * Parses the options.
+ * @param {RuleContext} context The rule context.
+ * @returns {{version:Range,ignores:Set<string>}} Parsed value.
+ */
+function parseOptions(context) {
+    const raw = context.options[0] || {}
+    const filePath = context.getFilename()
+    const version = getConfiguredNodeVersion(raw.version, filePath)
+    const ignores = new Set(raw.ignores || [])
+
+    return Object.freeze({ version, ignores })
+}
+
+/**
+ * Check if it has been supported.
+ * @param {SupportInfo} info The support info.
+ * @param {Range} configured The configured version range.
+ */
+function isSupported({ backported, supported }, configured) {
+    if (
+        backported &&
+        backported.length >= 2 &&
+        !backported.every((v, i) => i === 0 || lt(backported[i - 1], v))
+    ) {
+        throw new Error("Invalid BackportConfiguration")
+    }
+
+    if (supported == null) {
+        return false
+    }
+    if (backported == null || backported.length === 0) {
+        return !configured.intersects(getSemverRange(`<${supported}`))
+    }
+
+    return !configured.intersects(
+        getSemverRange(
+            [...backported, supported]
+                .map((v, i) => (i === 0 ? `<${v}` : `>=${major(v)}.0.0 <${v}`))
+                .join(" || ")
+        )
+    )
+}
+
+/**
+ * Get the formatted text of a given supported version.
+ * @param {SupportInfo} info The support info.
+ */
+function supportedVersionToString({ backported, supported }) {
+    if (supported == null) {
+        return "(none yet)"
+    }
+    if (backported == null || backported.length === 0) {
+        return supported
+    }
+    return `${supported} (backported: ^${backported.join(", ^")})`
+}
+
+/**
+ * Verify the code to report unsupported APIs.
+ * @param {RuleContext} context The rule context.
+ * @param {{modules:object,globals:object}} trackMap The map for APIs to report.
+ * @returns {void}
+ */
+module.exports = function checkUnsupportedBuiltins(context, trackMap) {
+    const options = parseOptions(context)
+    const tracker = new ReferenceTracker(context.getScope(), { mode: "legacy" })
+    const references = [
+        ...tracker.iterateCjsReferences(trackMap.modules || {}),
+        ...tracker.iterateEsmReferences(trackMap.modules || {}),
+        ...tracker.iterateGlobalReferences(trackMap.globals || {}),
+    ]
+
+    for (const { node, path, info } of references) {
+        const name = path.join(".")
+        const supported = isSupported(info, options.version)
+
+        if (!supported && !options.ignores.has(name)) {
+            context.report({
+                node,
+                messageId: "unsupported",
+                data: {
+                    name,
+                    supported: supportedVersionToString(info),
+                    version: options.version.raw,
+                },
+            })
+        }
+    }
+}