update socials section
This commit is contained in:
507
node_modules/eslint/lib/rules/prefer-regex-literals.js
generated
vendored
Normal file
507
node_modules/eslint/lib/rules/prefer-regex-literals.js
generated
vendored
Normal file
@ -0,0 +1,507 @@
|
||||
/**
|
||||
* @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));
|
||||
}
|
||||
}]
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
};
|
||||
Reference in New Issue
Block a user