Server IP : 150.95.80.236 / Your IP : 3.144.25.133 Web Server : Apache System : Linux host-150-95-80-236 3.10.0-1160.105.1.el7.x86_64 #1 SMP Thu Dec 7 15:39:45 UTC 2023 x86_64 User : social-telecare ( 10000) PHP Version : 7.4.33 Disable Function : opcache_get_status MySQL : OFF | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /var/www/vhosts/pcu.in.th/api-uat.pcu.in.th/node_modules/eslint/lib/rules/ |
Upload File : |
/** * @fileoverview Rule to disallow use of the `RegExp` constructor in favor of regular expression literals * @author Milos Djermanovic */ "use strict"; //------------------------------------------------------------------------------ // Requirements //------------------------------------------------------------------------------ const astUtils = require("./utils/ast-utils"); const { CALL, CONSTRUCT, ReferenceTracker, findVariable } = require("@eslint-community/eslint-utils"); const { RegExpValidator, visitRegExpAST, RegExpParser } = require("@eslint-community/regexpp"); const { canTokensBeAdjacent } = require("./utils/ast-utils"); const { REGEXPP_LATEST_ECMA_VERSION } = require("./utils/regular-expressions"); //------------------------------------------------------------------------------ // Helpers //------------------------------------------------------------------------------ /** * Determines whether the given node is a string literal. * @param {ASTNode} node Node to check. * @returns {boolean} True if the node is a string literal. */ function isStringLiteral(node) { return node.type === "Literal" && typeof node.value === "string"; } /** * Determines whether the given node is a regex literal. * @param {ASTNode} node Node to check. * @returns {boolean} True if the node is a regex literal. */ function isRegexLiteral(node) { return node.type === "Literal" && Object.prototype.hasOwnProperty.call(node, "regex"); } const validPrecedingTokens = new Set([ "(", ";", "[", ",", "=", "+", "*", "-", "?", "~", "%", "**", "!", "typeof", "instanceof", "&&", "||", "??", "return", "...", "delete", "void", "in", "<", ">", "<=", ">=", "==", "===", "!=", "!==", "<<", ">>", ">>>", "&", "|", "^", ":", "{", "=>", "*=", "<<=", ">>=", ">>>=", "^=", "|=", "&=", "??=", "||=", "&&=", "**=", "+=", "-=", "/=", "%=", "/", "do", "break", "continue", "debugger", "case", "throw" ]); //------------------------------------------------------------------------------ // Rule Definition //------------------------------------------------------------------------------ /** @type {import('../shared/types').Rule} */ module.exports = { meta: { type: "suggestion", docs: { description: "Disallow use of the `RegExp` constructor in favor of regular expression literals", recommended: false, url: "https://eslint.org/docs/latest/rules/prefer-regex-literals" }, hasSuggestions: true, schema: [ { type: "object", properties: { disallowRedundantWrapping: { type: "boolean", default: false } }, additionalProperties: false } ], messages: { unexpectedRegExp: "Use a regular expression literal instead of the 'RegExp' constructor.", replaceWithLiteral: "Replace with an equivalent regular expression literal.", replaceWithLiteralAndFlags: "Replace with an equivalent regular expression literal with flags '{{ flags }}'.", replaceWithIntendedLiteralAndFlags: "Replace with a regular expression literal with flags '{{ flags }}'.", unexpectedRedundantRegExp: "Regular expression literal is unnecessarily wrapped within a 'RegExp' constructor.", unexpectedRedundantRegExpWithFlags: "Use regular expression literal with flags instead of the 'RegExp' constructor." } }, create(context) { const [{ disallowRedundantWrapping = false } = {}] = context.options; const sourceCode = context.sourceCode; /** * Determines whether the given identifier node is a reference to a global variable. * @param {ASTNode} node `Identifier` node to check. * @returns {boolean} True if the identifier is a reference to a global variable. */ function isGlobalReference(node) { const scope = sourceCode.getScope(node); const variable = findVariable(scope, node); return variable !== null && variable.scope.type === "global" && variable.defs.length === 0; } /** * Determines whether the given node is a String.raw`` tagged template expression * with a static template literal. * @param {ASTNode} node Node to check. * @returns {boolean} True if the node is String.raw`` with a static template. */ function isStringRawTaggedStaticTemplateLiteral(node) { return node.type === "TaggedTemplateExpression" && astUtils.isSpecificMemberAccess(node.tag, "String", "raw") && isGlobalReference(astUtils.skipChainExpression(node.tag).object) && astUtils.isStaticTemplateLiteral(node.quasi); } /** * Gets the value of a string * @param {ASTNode} node The node to get the string of. * @returns {string|null} The value of the node. */ function getStringValue(node) { if (isStringLiteral(node)) { return node.value; } if (astUtils.isStaticTemplateLiteral(node)) { return node.quasis[0].value.cooked; } if (isStringRawTaggedStaticTemplateLiteral(node)) { return node.quasi.quasis[0].value.raw; } return null; } /** * Determines whether the given node is considered to be a static string by the logic of this rule. * @param {ASTNode} node Node to check. * @returns {boolean} True if the node is a static string. */ function isStaticString(node) { return isStringLiteral(node) || astUtils.isStaticTemplateLiteral(node) || isStringRawTaggedStaticTemplateLiteral(node); } /** * Determines whether the relevant arguments of the given are all static string literals. * @param {ASTNode} node Node to check. * @returns {boolean} True if all arguments are static strings. */ function hasOnlyStaticStringArguments(node) { const args = node.arguments; if ((args.length === 1 || args.length === 2) && args.every(isStaticString)) { return true; } return false; } /** * Determines whether the arguments of the given node indicate that a regex literal is unnecessarily wrapped. * @param {ASTNode} node Node to check. * @returns {boolean} True if the node already contains a regex literal argument. */ function isUnnecessarilyWrappedRegexLiteral(node) { const args = node.arguments; if (args.length === 1 && isRegexLiteral(args[0])) { return true; } if (args.length === 2 && isRegexLiteral(args[0]) && isStaticString(args[1])) { return true; } return false; } /** * Returns a ecmaVersion compatible for regexpp. * @param {number} ecmaVersion The ecmaVersion to convert. * @returns {import("@eslint-community/regexpp/ecma-versions").EcmaVersion} The resulting ecmaVersion compatible for regexpp. */ function getRegexppEcmaVersion(ecmaVersion) { if (ecmaVersion <= 5) { return 5; } return Math.min(ecmaVersion, REGEXPP_LATEST_ECMA_VERSION); } const regexppEcmaVersion = getRegexppEcmaVersion(context.languageOptions.ecmaVersion); /** * Makes a character escaped or else returns null. * @param {string} character The character to escape. * @returns {string} The resulting escaped character. */ function resolveEscapes(character) { switch (character) { case "\n": case "\\\n": return "\\n"; case "\r": case "\\\r": return "\\r"; case "\t": case "\\\t": return "\\t"; case "\v": case "\\\v": return "\\v"; case "\f": case "\\\f": return "\\f"; case "/": return "\\/"; default: return null; } } /** * Checks whether the given regex and flags are valid for the ecma version or not. * @param {string} pattern The regex pattern to check. * @param {string | undefined} flags The regex flags to check. * @returns {boolean} True if the given regex pattern and flags are valid for the ecma version. */ function isValidRegexForEcmaVersion(pattern, flags) { const validator = new RegExpValidator({ ecmaVersion: regexppEcmaVersion }); try { validator.validatePattern(pattern, 0, pattern.length, { unicode: flags ? flags.includes("u") : false, unicodeSets: flags ? flags.includes("v") : false }); if (flags) { validator.validateFlags(flags); } return true; } catch { return false; } } /** * Checks whether two given regex flags contain the same flags or not. * @param {string} flagsA The regex flags. * @param {string} flagsB The regex flags. * @returns {boolean} True if two regex flags contain same flags. */ function areFlagsEqual(flagsA, flagsB) { return [...flagsA].sort().join("") === [...flagsB].sort().join(""); } /** * Merges two regex flags. * @param {string} flagsA The regex flags. * @param {string} flagsB The regex flags. * @returns {string} The merged regex flags. */ function mergeRegexFlags(flagsA, flagsB) { const flagsSet = new Set([ ...flagsA, ...flagsB ]); return [...flagsSet].join(""); } /** * Checks whether a give node can be fixed to the given regex pattern and flags. * @param {ASTNode} node The node to check. * @param {string} pattern The regex pattern to check. * @param {string} flags The regex flags * @returns {boolean} True if a node can be fixed to the given regex pattern and flags. */ function canFixTo(node, pattern, flags) { const tokenBefore = sourceCode.getTokenBefore(node); return sourceCode.getCommentsInside(node).length === 0 && (!tokenBefore || validPrecedingTokens.has(tokenBefore.value)) && isValidRegexForEcmaVersion(pattern, flags); } /** * Returns a safe output code considering the before and after tokens. * @param {ASTNode} node The regex node. * @param {string} newRegExpValue The new regex expression value. * @returns {string} The output code. */ function getSafeOutput(node, newRegExpValue) { const tokenBefore = sourceCode.getTokenBefore(node); const tokenAfter = sourceCode.getTokenAfter(node); return (tokenBefore && !canTokensBeAdjacent(tokenBefore, newRegExpValue) && tokenBefore.range[1] === node.range[0] ? " " : "") + newRegExpValue + (tokenAfter && !canTokensBeAdjacent(newRegExpValue, tokenAfter) && node.range[1] === tokenAfter.range[0] ? " " : ""); } return { Program(node) { const scope = sourceCode.getScope(node); const tracker = new ReferenceTracker(scope); const traceMap = { RegExp: { [CALL]: true, [CONSTRUCT]: true } }; for (const { node: refNode } of tracker.iterateGlobalReferences(traceMap)) { if (disallowRedundantWrapping && isUnnecessarilyWrappedRegexLiteral(refNode)) { const regexNode = refNode.arguments[0]; if (refNode.arguments.length === 2) { const suggests = []; const argFlags = getStringValue(refNode.arguments[1]) || ""; if (canFixTo(refNode, regexNode.regex.pattern, argFlags)) { suggests.push({ messageId: "replaceWithLiteralAndFlags", pattern: regexNode.regex.pattern, flags: argFlags }); } const literalFlags = regexNode.regex.flags || ""; const mergedFlags = mergeRegexFlags(literalFlags, argFlags); if ( !areFlagsEqual(mergedFlags, argFlags) && canFixTo(refNode, regexNode.regex.pattern, mergedFlags) ) { suggests.push({ messageId: "replaceWithIntendedLiteralAndFlags", pattern: regexNode.regex.pattern, flags: mergedFlags }); } context.report({ node: refNode, messageId: "unexpectedRedundantRegExpWithFlags", suggest: suggests.map(({ flags, pattern, messageId }) => ({ messageId, data: { flags }, fix(fixer) { return fixer.replaceText(refNode, getSafeOutput(refNode, `/${pattern}/${flags}`)); } })) }); } else { const outputs = []; if (canFixTo(refNode, regexNode.regex.pattern, regexNode.regex.flags)) { outputs.push(sourceCode.getText(regexNode)); } context.report({ node: refNode, messageId: "unexpectedRedundantRegExp", suggest: outputs.map(output => ({ messageId: "replaceWithLiteral", fix(fixer) { return fixer.replaceText( refNode, getSafeOutput(refNode, output) ); } })) }); } } else if (hasOnlyStaticStringArguments(refNode)) { let regexContent = getStringValue(refNode.arguments[0]); let noFix = false; let flags; if (refNode.arguments[1]) { flags = getStringValue(refNode.arguments[1]); } if (!canFixTo(refNode, regexContent, flags)) { noFix = true; } if (!/^[-a-zA-Z0-9\\[\](){} \t\r\n\v\f!@#$%^&*+^_=/~`.><?,'"|:;]*$/u.test(regexContent)) { noFix = true; } if (regexContent && !noFix) { let charIncrease = 0; const ast = new RegExpParser({ ecmaVersion: regexppEcmaVersion }).parsePattern(regexContent, 0, regexContent.length, { unicode: flags ? flags.includes("u") : false, unicodeSets: flags ? flags.includes("v") : false }); visitRegExpAST(ast, { onCharacterEnter(characterNode) { const escaped = resolveEscapes(characterNode.raw); if (escaped) { regexContent = regexContent.slice(0, characterNode.start + charIncrease) + escaped + regexContent.slice(characterNode.end + charIncrease); if (characterNode.raw.length === 1) { charIncrease += 1; } } } }); } const newRegExpValue = `/${regexContent || "(?:)"}/${flags || ""}`; context.report({ node: refNode, messageId: "unexpectedRegExp", suggest: noFix ? [] : [{ messageId: "replaceWithLiteral", fix(fixer) { return fixer.replaceText(refNode, getSafeOutput(refNode, newRegExpValue)); } }] }); } } } }; } };