eslint 5.14.1 → 5.15.3

package/lib/rules/no-unused-vars.js

@@ -37,26 +37,22 @@ module.exports = {
                         type: "object",
                         properties: {
                             vars: {
-                                enum: ["all", "local"],
-                                default: "all"
+                                enum: ["all", "local"]
                             },
                             varsIgnorePattern: {
                                 type: "string"
                             },
                             args: {
-                                enum: ["all", "after-used", "none"],
-                                default: "after-used"
+                                enum: ["all", "after-used", "none"]
                             },
                             ignoreRestSiblings: {
-                                type: "boolean",
-                                default: false
+                                type: "boolean"
                             },
                             argsIgnorePattern: {
                                 type: "string"
                             },
                             caughtErrors: {
-                                enum: ["all", "none"],
-                                default: "none"
+                                enum: ["all", "none"]
                             },
                             caughtErrorsIgnorePattern: {
                                 type: "string"
@@ -71,7 +67,7 @@ module.exports = {
     create(context) {
         const sourceCode = context.getSourceCode();
 
-        const REST_PROPERTY_TYPE = /^(?:RestElement|(?:Experimental)?RestProperty)$/;
+        const REST_PROPERTY_TYPE = /^(?:RestElement|(?:Experimental)?RestProperty)$/u;
 
         const config = {
             vars: "all",
@@ -92,15 +88,15 @@ module.exports = {
                 config.caughtErrors = firstOption.caughtErrors || config.caughtErrors;
 
                 if (firstOption.varsIgnorePattern) {
-                    config.varsIgnorePattern = new RegExp(firstOption.varsIgnorePattern);
+                    config.varsIgnorePattern = new RegExp(firstOption.varsIgnorePattern); // eslint-disable-line require-unicode-regexp
                 }
 
                 if (firstOption.argsIgnorePattern) {
-                    config.argsIgnorePattern = new RegExp(firstOption.argsIgnorePattern);
+                    config.argsIgnorePattern = new RegExp(firstOption.argsIgnorePattern); // eslint-disable-line require-unicode-regexp
                 }
 
                 if (firstOption.caughtErrorsIgnorePattern) {
-                    config.caughtErrorsIgnorePattern = new RegExp(firstOption.caughtErrorsIgnorePattern);
+                    config.caughtErrorsIgnorePattern = new RegExp(firstOption.caughtErrorsIgnorePattern); // eslint-disable-line require-unicode-regexp
                 }
             }
         }
@@ -147,7 +143,7 @@ module.exports = {
         // Helpers
         //--------------------------------------------------------------------------
 
-        const STATEMENT_TYPE = /(?:Statement|Declaration)$/;
+        const STATEMENT_TYPE = /(?:Statement|Declaration)$/u;
 
         /**
          * Determines if a given variable is being exported from a module.
@@ -600,7 +596,7 @@ module.exports = {
          * @private
          */
         function getColumnInComment(variable, comment) {
-            const namePattern = new RegExp(`[\\s,]${lodash.escapeRegExp(variable.name)}(?:$|[\\s,:])`, "g");
+            const namePattern = new RegExp(`[\\s,]${lodash.escapeRegExp(variable.name)}(?:$|[\\s,:])`, "gu");
 
             // To ignore the first text "global".
             namePattern.lastIndex = comment.value.indexOf("global") + 6;

package/lib/rules/no-use-before-define.js

@@ -9,8 +9,8 @@
 // Helpers
 //------------------------------------------------------------------------------
 
-const SENTINEL_TYPE = /^(?:(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|CatchClause|ImportDeclaration|ExportNamedDeclaration)$/;
-const FOR_IN_OF_TYPE = /^For(?:In|Of)Statement$/;
+const SENTINEL_TYPE = /^(?:(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|CatchClause|ImportDeclaration|ExportNamedDeclaration)$/u;
+const FOR_IN_OF_TYPE = /^For(?:In|Of)Statement$/u;
 
 /**
  * Parses a given value as options.
@@ -154,9 +154,9 @@ module.exports = {
                     {
                         type: "object",
                         properties: {
-                            functions: { type: "boolean", default: true },
-                            classes: { type: "boolean", default: true },
-                            variables: { type: "boolean", default: true }
+                            functions: { type: "boolean" },
+                            classes: { type: "boolean" },
+                            variables: { type: "boolean" }
                         },
                         additionalProperties: false
                     }

package/lib/rules/no-useless-escape.js

@@ -181,7 +181,7 @@ module.exports = {
                 }
 
                 const value = isTemplateElement ? node.value.raw : node.raw.slice(1, -1);
-                const pattern = /\\[^\d]/g;
+                const pattern = /\\[^\d]/gu;
                 let match;
 
                 while ((match = pattern.exec(value))) {

package/lib/rules/no-var.js

@@ -77,7 +77,7 @@ function isDeclarationInitialized(node) {
     return node.declarations.every(declarator => declarator.init !== null);
 }
 
-const SCOPE_NODE_TYPE = /^(?:Program|BlockStatement|SwitchStatement|ForStatement|ForInStatement|ForOfStatement)$/;
+const SCOPE_NODE_TYPE = /^(?:Program|BlockStatement|SwitchStatement|ForStatement|ForInStatement|ForOfStatement)$/u;
 
 /**
  * Gets the scope node which directly contains a given node.

package/lib/rules/no-warning-comments.js

@@ -47,7 +47,7 @@ module.exports = {
             configuration = context.options[0] || {},
             warningTerms = configuration.terms || ["todo", "fixme", "xxx"],
             location = configuration.location || "start",
-            selfConfigRegEx = /\bno-warning-comments\b/;
+            selfConfigRegEx = /\bno-warning-comments\b/u;
 
         /**
          * Convert a warning term into a RegExp which will match a comment containing that whole word in the specified
@@ -58,7 +58,7 @@ module.exports = {
          * @returns {RegExp} The term converted to a RegExp
          */
         function convertToRegExp(term) {
-            const escaped = term.replace(/[-/\\$^*+?.()|[\]{}]/g, "\\$&");
+            const escaped = term.replace(/[-/\\$^*+?.()|[\]{}]/gu, "\\$&");
             const wordBoundary = "\\b";
             const eitherOrWordBoundary = `|${wordBoundary}`;
             let prefix;
@@ -73,7 +73,7 @@ module.exports = {
              * In these cases, use no bounding match. Same applies for the
              * prefix, handled below.
              */
-            const suffix = /\w$/.test(term) ? "\\b" : "";
+            const suffix = /\w$/u.test(term) ? "\\b" : "";
 
             if (location === "start") {
 
@@ -82,7 +82,7 @@ module.exports = {
                  * there's no need to worry about word boundaries.
                  */
                 prefix = "^\\s*";
-            } else if (/^\w/.test(term)) {
+            } else if (/^\w/u.test(term)) {
                 prefix = wordBoundary;
             } else {
                 prefix = "";
@@ -95,7 +95,7 @@ module.exports = {
                  * ^\s*TERM\b.  This checks the word boundary
                  * at the beginning of the comment.
                  */
-                return new RegExp(prefix + escaped + suffix, "i");
+                return new RegExp(prefix + escaped + suffix, "i"); // eslint-disable-line require-unicode-regexp
             }
 
             /*
@@ -103,7 +103,7 @@ module.exports = {
              * \bTERM\b|\bTERM\b, this checks the entire comment
              * for the term.
              */
-            return new RegExp(prefix + escaped + suffix + eitherOrWordBoundary + term + wordBoundary, "i");
+            return new RegExp(prefix + escaped + suffix + eitherOrWordBoundary + term + wordBoundary, "i"); // eslint-disable-line require-unicode-regexp
         }
 
         const warningRegExps = warningTerms.map(convertToRegExp);

package/lib/rules/object-curly-newline.js

@@ -26,16 +26,14 @@ const OPTION_VALUE = {
             type: "object",
             properties: {
                 multiline: {
-                    type: "boolean",
-                    default: false
+                    type: "boolean"
                 },
                 minProperties: {
                     type: "integer",
                     minimum: 0
                 },
                 consistent: {
-                    type: "boolean",
-                    default: false
+                    type: "boolean"
                 }
             },
             additionalProperties: false,
@@ -61,9 +59,9 @@ function normalizeOptionValue(value) {
         } else if (value === "never") {
             minProperties = Number.POSITIVE_INFINITY;
         } else {
-            multiline = value.multiline;
+            multiline = Boolean(value.multiline);
             minProperties = value.minProperties || Number.POSITIVE_INFINITY;
-            consistent = value.consistent;
+            consistent = Boolean(value.consistent);
         }
     } else {
         consistent = true;

package/lib/rules/object-shorthand.js

@@ -57,8 +57,7 @@ module.exports = {
                             type: "object",
                             properties: {
                                 avoidQuotes: {
-                                    type: "boolean",
-                                    default: false
+                                    type: "boolean"
                                 }
                             },
                             additionalProperties: false
@@ -77,16 +76,13 @@ module.exports = {
                             type: "object",
                             properties: {
                                 ignoreConstructors: {
-                                    type: "boolean",
-                                    default: false
+                                    type: "boolean"
                                 },
                                 avoidQuotes: {
-                                    type: "boolean",
-                                    default: false
+                                    type: "boolean"
                                 },
                                 avoidExplicitReturnArrows: {
-                                    type: "boolean",
-                                    default: false
+                                    type: "boolean"
                                 }
                             },
                             additionalProperties: false

package/lib/rules/one-var.js

@@ -36,16 +36,13 @@ module.exports = {
                                 default: false
                             },
                             var: {
-                                enum: ["always", "never", "consecutive"],
-                                default: "always"
+                                enum: ["always", "never", "consecutive"]
                             },
                             let: {
-                                enum: ["always", "never", "consecutive"],
-                                default: "always"
+                                enum: ["always", "never", "consecutive"]
                             },
                             const: {
-                                enum: ["always", "never", "consecutive"],
-                                default: "always"
+                                enum: ["always", "never", "consecutive"]
                             }
                         },
                         additionalProperties: false

package/lib/rules/padding-line-between-statements.js

@@ -17,10 +17,11 @@ const astUtils = require("../util/ast-utils");
 
 const LT = `[${Array.from(astUtils.LINEBREAKS).join("")}]`;
 const PADDING_LINE_SEQUENCE = new RegExp(
-    String.raw`^(\s*?${LT})\s*${LT}(\s*;?)$`
+    String.raw`^(\s*?${LT})\s*${LT}(\s*;?)$`,
+    "u"
 );
-const CJS_EXPORT = /^(?:module\s*\.\s*)?exports(?:\s*\.|\s*\[|$)/;
-const CJS_IMPORT = /^require\(/;
+const CJS_EXPORT = /^(?:module\s*\.\s*)?exports(?:\s*\.|\s*\[|$)/u;
+const CJS_IMPORT = /^require\(/u;
 
 /**
  * Creates tester which check if a node starts with specific keyword.

package/lib/rules/prefer-const.js

@@ -11,9 +11,9 @@ const astUtils = require("../util/ast-utils");
 // Helpers
 //------------------------------------------------------------------------------
 
-const PATTERN_TYPE = /^(?:.+?Pattern|RestElement|SpreadProperty|ExperimentalRestProperty|Property)$/;
-const DECLARATION_HOST_TYPE = /^(?:Program|BlockStatement|SwitchCase)$/;
-const DESTRUCTURING_HOST_TYPE = /^(?:VariableDeclarator|AssignmentExpression)$/;
+const PATTERN_TYPE = /^(?:.+?Pattern|RestElement|SpreadProperty|ExperimentalRestProperty|Property)$/u;
+const DECLARATION_HOST_TYPE = /^(?:Program|BlockStatement|SwitchCase)$/u;
+const DESTRUCTURING_HOST_TYPE = /^(?:VariableDeclarator|AssignmentExpression)$/u;
 
 /**
  * Checks whether a given node is located at `ForStatement.init` or not.

package/lib/rules/prefer-destructuring.js

@@ -36,12 +36,10 @@ module.exports = {
                                 type: "object",
                                 properties: {
                                     array: {
-                                        type: "boolean",
-                                        default: true
+                                        type: "boolean"
                                     },
                                     object: {
-                                        type: "boolean",
-                                        default: true
+                                        type: "boolean"
                                     }
                                 },
                                 additionalProperties: false
@@ -50,12 +48,10 @@ module.exports = {
                                 type: "object",
                                 properties: {
                                     array: {
-                                        type: "boolean",
-                                        default: true
+                                        type: "boolean"
                                     },
                                     object: {
-                                        type: "boolean",
-                                        default: true
+                                        type: "boolean"
                                     }
                                 },
                                 additionalProperties: false
@@ -67,12 +63,10 @@ module.exports = {
                         type: "object",
                         properties: {
                             array: {
-                                type: "boolean",
-                                default: true
+                                type: "boolean"
                             },
                             object: {
-                                type: "boolean",
-                                default: true
+                                type: "boolean"
                             }
                         },
                         additionalProperties: false
@@ -83,8 +77,7 @@ module.exports = {
                 type: "object",
                 properties: {
                     enforceForRenamedProperties: {
-                        type: "boolean",
-                        default: false
+                        type: "boolean"
                     }
                 },
                 additionalProperties: false

package/lib/rules/prefer-named-capture-group.js

@@ -0,0 +1,123 @@
+/**
+ * @fileoverview Rule to enforce requiring named capture groups in regular expression.
+ * @author Pig Fang <https://github.com/g-plane>
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const {
+    CALL,
+    CONSTRUCT,
+    ReferenceTracker,
+    getStringIfConstant
+} = require("eslint-utils");
+const regexpp = require("regexpp");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const parser = new regexpp.RegExpParser();
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "enforce using named capture group in regular expression",
+            category: "Best Practices",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/prefer-named-capture-group"
+        },
+
+        schema: [],
+
+        messages: {
+            required: "Capture group '{{group}}' should be converted to a named or non-capturing group."
+        }
+    },
+
+    create(context) {
+
+        /**
+         * Function to check regular expression.
+         *
+         * @param {string} regex The regular expression to be check.
+         * @param {ASTNode} node AST node which contains regular expression.
+         * @param {boolean} uFlag Flag indicates whether unicode mode is enabled or not.
+         * @returns {void}
+         */
+        function checkRegex(regex, node, uFlag) {
+            let ast;
+
+            try {
+                ast = parser.parsePattern(regex, 0, regex.length, uFlag);
+            } catch (_) {
+
+                // ignore regex syntax errors
+                return;
+            }
+
+            regexpp.visitRegExpAST(ast, {
+                onCapturingGroupEnter(group) {
+                    if (!group.name) {
+                        const locNode = node.type === "Literal" ? node : node.arguments[0];
+
+                        context.report({
+                            node,
+                            messageId: "required",
+                            loc: {
+                                start: {
+                                    line: locNode.loc.start.line,
+                                    column: locNode.loc.start.column + group.start + 1
+                                },
+                                end: {
+                                    line: locNode.loc.start.line,
+                                    column: locNode.loc.start.column + group.end + 1
+                                }
+                            },
+                            data: {
+                                group: group.raw
+                            }
+                        });
+                    }
+                }
+            });
+        }
+
+        return {
+            Literal(node) {
+                if (node.regex) {
+                    checkRegex(node.regex.pattern, node, node.regex.flags.includes("u"));
+                }
+            },
+            Program() {
+                const scope = context.getScope();
+                const tracker = new ReferenceTracker(scope);
+                const traceMap = {
+                    RegExp: {
+                        [CALL]: true,
+                        [CONSTRUCT]: true
+                    }
+                };
+
+                for (const { node } of tracker.iterateGlobalReferences(traceMap)) {
+                    const regex = getStringIfConstant(node.arguments[0]);
+                    const flags = getStringIfConstant(node.arguments[1]);
+
+                    if (regex) {
+                        checkRegex(regex, node, flags && flags.includes("u"));
+                    }
+                }
+            }
+        };
+    }
+};

package/lib/rules/prefer-object-spread.js

@@ -14,7 +14,7 @@ const {
     isParenthesised
 } = require("../util/ast-utils");
 
-const ANY_SPACE = /\s/;
+const ANY_SPACE = /\s/u;
 
 /**
  * Helper that checks if the Object.assign call has array spread

package/lib/rules/prefer-template.js

@@ -52,7 +52,7 @@ function isOctalEscapeSequence(node) {
         return false;
     }
 
-    const match = node.raw.match(/^([^\\]|\\[^0-7])*\\([0-7]{1,3})/);
+    const match = node.raw.match(/^([^\\]|\\[^0-7])*\\([0-7]{1,3})/u);
 
     if (match) {
 
@@ -187,14 +187,14 @@ module.exports = {
                  * for some reason, don't add another backslash, because that would change the meaning of the code (it would cause
                  * an actual backslash character to appear before the dollar sign).
                  */
-                return `\`${currentNode.raw.slice(1, -1).replace(/\\*(\${|`)/g, matched => {
+                return `\`${currentNode.raw.slice(1, -1).replace(/\\*(\$\{|`)/gu, matched => {
                     if (matched.lastIndexOf("\\") % 2) {
                         return `\\${matched}`;
                     }
                     return matched;
 
                 // Unescape any quotes that appear in the original Literal that no longer need to be escaped.
-                }).replace(new RegExp(`\\\\${currentNode.raw[0]}`, "g"), currentNode.raw[0])}\``;
+                }).replace(new RegExp(`\\\\${currentNode.raw[0]}`, "gu"), currentNode.raw[0])}\``;
             }
 
             if (currentNode.type === "TemplateLiteral") {

package/lib/rules/quote-props.js

@@ -32,8 +32,7 @@ module.exports = {
                     type: "array",
                     items: [
                         {
-                            enum: ["always", "as-needed", "consistent", "consistent-as-needed"],
-                            default: "always"
+                            enum: ["always", "as-needed", "consistent", "consistent-as-needed"]
                         }
                     ],
                     minItems: 0,
@@ -43,23 +42,19 @@ module.exports = {
                     type: "array",
                     items: [
                         {
-                            enum: ["always", "as-needed", "consistent", "consistent-as-needed"],
-                            default: "always"
+                            enum: ["always", "as-needed", "consistent", "consistent-as-needed"]
                         },
                         {
                             type: "object",
                             properties: {
                                 keywords: {
-                                    type: "boolean",
-                                    default: false
+                                    type: "boolean"
                                 },
                                 unnecessary: {
-                                    type: "boolean",
-                                    default: true
+                                    type: "boolean"
                                 },
                                 numbers: {
-                                    type: "boolean",
-                                    default: false
+                                    type: "boolean"
                                 }
                             },
                             additionalProperties: false

package/lib/rules/quotes.js

@@ -34,7 +34,7 @@ const QUOTE_SETTINGS = {
 };
 
 // An unescaped newline is a newline preceded by an even number of backslashes.
-const UNESCAPED_LINEBREAK_PATTERN = new RegExp(String.raw`(^|[^\\])(\\\\)*[${Array.from(astUtils.LINEBREAKS).join("")}]`);
+const UNESCAPED_LINEBREAK_PATTERN = new RegExp(String.raw`(^|[^\\])(\\\\)*[${Array.from(astUtils.LINEBREAKS).join("")}]`, "u");
 
 /**
  * Switches quoting of javascript string between ' " and `
@@ -54,7 +54,7 @@ QUOTE_SETTINGS.backtick.convert = function(str) {
     if (newQuote === oldQuote) {
         return str;
     }
-    return newQuote + str.slice(1, -1).replace(/\\(\${|\r\n?|\n|.)|["'`]|\${|(\r\n?|\n)/g, (match, escaped, newline) => {
+    return newQuote + str.slice(1, -1).replace(/\\(\$\{|\r\n?|\n|.)|["'`]|\$\{|(\r\n?|\n)/gu, (match, escaped, newline) => {
         if (escaped === oldQuote || oldQuote === "`" && escaped === "${") {
             return escaped; // unescape
         }
@@ -100,12 +100,10 @@ module.exports = {
                         type: "object",
                         properties: {
                             avoidEscape: {
-                                type: "boolean",
-                                default: false
+                                type: "boolean"
                             },
                             allowTemplateLiterals: {
-                                type: "boolean",
-                                default: false
+                                type: "boolean"
                             }
                         },
                         additionalProperties: false

package/lib/rules/semi.js

@@ -40,8 +40,7 @@ module.exports = {
                             type: "object",
                             properties: {
                                 beforeStatementContinuationChars: {
-                                    enum: ["always", "any", "never"],
-                                    default: "any"
+                                    enum: ["always", "any", "never"]
                                 }
                             },
                             additionalProperties: false
@@ -59,7 +58,7 @@ module.exports = {
                         {
                             type: "object",
                             properties: {
-                                omitLastInOneLineBlock: { type: "boolean", default: false }
+                                omitLastInOneLineBlock: { type: "boolean" }
                             },
                             additionalProperties: false
                         }
@@ -73,11 +72,11 @@ module.exports = {
 
     create(context) {
 
-        const OPT_OUT_PATTERN = /^[-[(/+`]/; // One of [(/+-`
+        const OPT_OUT_PATTERN = /^[-[(/+`]/u; // One of [(/+-`
         const options = context.options[1];
         const never = context.options[0] === "never";
-        const exceptOneLine = options && options.omitLastInOneLineBlock;
-        const beforeStatementContinuationChars = options && options.beforeStatementContinuationChars;
+        const exceptOneLine = Boolean(options && options.omitLastInOneLineBlock);
+        const beforeStatementContinuationChars = options && options.beforeStatementContinuationChars || "any";
         const sourceCode = context.getSourceCode();
 
         //--------------------------------------------------------------------------
@@ -292,7 +291,7 @@ module.exports = {
             const parent = node.parent;
 
             if ((parent.type !== "ForStatement" || parent.init !== node) &&
-                (!/^For(?:In|Of)Statement/.test(parent.type) || parent.left !== node)
+                (!/^For(?:In|Of)Statement/u.test(parent.type) || parent.left !== node)
             ) {
                 checkForSemicolon(node);
             }
@@ -319,7 +318,7 @@ module.exports = {
                 }
             },
             ExportDefaultDeclaration(node) {
-                if (!/(?:Class|Function)Declaration/.test(node.declaration.type)) {
+                if (!/(?:Class|Function)Declaration/u.test(node.declaration.type)) {
                     checkForSemicolon(node);
                 }
             }

package/lib/rules/space-before-function-paren.js

@@ -37,16 +37,13 @@ module.exports = {
                         type: "object",
                         properties: {
                             anonymous: {
-                                enum: ["always", "never", "ignore"],
-                                default: "always"
+                                enum: ["always", "never", "ignore"]
                             },
                             named: {
-                                enum: ["always", "never", "ignore"],
-                                default: "always"
+                                enum: ["always", "never", "ignore"]
                             },
                             asyncArrow: {
-                                enum: ["always", "never", "ignore"],
-                                default: "always"
+                                enum: ["always", "never", "ignore"]
                             }
                         },
                         additionalProperties: false