eslint 5.14.1 → 5.15.3

package/lib/rules/id-match.js

@@ -53,7 +53,7 @@ module.exports = {
         // Options
         //--------------------------------------------------------------------------
         const pattern = context.options[0] || "^.+$",
-            regexp = new RegExp(pattern);
+            regexp = new RegExp(pattern); // eslint-disable-line require-unicode-regexp
 
         const options = context.options[1] || {},
             properties = !!options.properties,

package/lib/rules/implicit-arrow-linebreak.js

@@ -4,11 +4,7 @@
  */
 "use strict";
 
-const {
-    isArrowToken,
-    isParenthesised,
-    isOpeningParenToken
-} = require("../util/ast-utils");
+const { isCommentToken, isNotOpeningParenToken } = require("../util/ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -39,153 +35,7 @@ module.exports = {
 
     create(context) {
         const sourceCode = context.getSourceCode();
-
-        //----------------------------------------------------------------------
-        // Helpers
-        //----------------------------------------------------------------------
-        /**
-         * Gets the applicable preference for a particular keyword
-         * @returns {string} The applicable option for the keyword, e.g. 'beside'
-         */
-        function getOption() {
-            return context.options[0] || "beside";
-        }
-
-        /**
-         * Formats the comments depending on whether it's a line or block comment.
-         * @param {Comment[]} comments The array of comments between the arrow and body
-         * @param {Integer} column The column number of the first token
-         * @returns {string} A string of comment text joined by line breaks
-         */
-        function formatComments(comments, column) {
-            const whiteSpaces = " ".repeat(column);
-
-            return `${comments.map(comment => {
-
-                if (comment.type === "Line") {
-                    return `//${comment.value}`;
-                }
-
-                return `/*${comment.value}*/`;
-            }).join(`\n${whiteSpaces}`)}\n${whiteSpaces}`;
-        }
-
-        /**
-         * Finds the first token to prepend comments to depending on the parent type
-         * @param {Node} node The validated node
-         * @returns {Token|Node} The node to prepend comments to
-         */
-        function findFirstToken(node) {
-            switch (node.parent.type) {
-                case "VariableDeclarator":
-
-                    // If the parent is first or only declarator, return the declaration, else, declarator
-                    return sourceCode.getFirstToken(
-                        node.parent.parent.declarations.length === 1 ||
-                        node.parent.parent.declarations[0].id.name === node.parent.id.name
-                            ? node.parent.parent : node.parent
-                    );
-                case "CallExpression":
-                case "Property":
-
-                    // find the object key
-                    return sourceCode.getFirstToken(node.parent);
-                default:
-                    return node;
-            }
-        }
-
-        /**
-         * Helper function for adding parentheses fixes for nodes containing nested arrow functions
-         * @param {Fixer} fixer Fixer
-         * @param {Token} arrow - The arrow token
-         * @param {ASTNode} arrowBody - The arrow function body
-         * @returns {Function[]} autofixer -- wraps function bodies with parentheses
-         */
-        function addParentheses(fixer, arrow, arrowBody) {
-            const parenthesesFixes = [];
-            let closingParentheses = "";
-
-            let followingBody = arrowBody;
-            let currentArrow = arrow;
-
-            while (currentArrow) {
-                if (!isParenthesised(sourceCode, followingBody)) {
-                    parenthesesFixes.push(
-                        fixer.insertTextAfter(currentArrow, " (")
-                    );
-
-                    const paramsToken = sourceCode.getTokenBefore(currentArrow, token =>
-                        isOpeningParenToken(token) || token.type === "Identifier");
-
-                    const whiteSpaces = " ".repeat(paramsToken.loc.start.column);
-
-                    closingParentheses = `\n${whiteSpaces})${closingParentheses}`;
-                }
-
-                currentArrow = sourceCode.getTokenAfter(currentArrow, isArrowToken);
-
-                if (currentArrow) {
-                    followingBody = sourceCode.getTokenAfter(currentArrow, token => !isOpeningParenToken(token));
-                }
-            }
-
-            return [...parenthesesFixes,
-                fixer.insertTextAfter(arrowBody, closingParentheses)
-            ];
-        }
-
-        /**
-         * Autofixes the function body to collapse onto the same line as the arrow.
-         * If comments exist, prepends the comments before the arrow function.
-         * If the function body contains arrow functions, appends the function bodies with parentheses.
-         * @param {Token} arrowToken The arrow token.
-         * @param {ASTNode} arrowBody the function body
-         * @param {ASTNode} node The evaluated node
-         * @returns {Function} autofixer -- validates the node to adhere to besides
-         */
-        function autoFixBesides(arrowToken, arrowBody, node) {
-            return fixer => {
-                const placeBesides = fixer.replaceTextRange([arrowToken.range[1], arrowBody.range[0]], " ");
-
-                const comments = sourceCode.getCommentsInside(node).filter(comment =>
-                    comment.loc.start.line < arrowBody.loc.start.line);
-
-                if (comments.length) {
-
-                    // If the grandparent is not a variable declarator
-                    if (
-                        arrowBody.parent &&
-                        arrowBody.parent.parent &&
-                        arrowBody.parent.parent.type !== "VariableDeclarator"
-                    ) {
-
-                        // If any arrow functions follow, return the necessary parens fixes.
-                        if (sourceCode.getTokenAfter(arrowToken, isArrowToken) && arrowBody.parent.parent.type !== "VariableDeclarator") {
-                            return addParentheses(fixer, arrowToken, arrowBody);
-                        }
-
-                        // If any arrow functions precede, the necessary fixes have already been returned, so return null.
-                        if (sourceCode.getTokenBefore(arrowToken, isArrowToken) && arrowBody.parent.parent.type !== "VariableDeclarator") {
-                            return null;
-                        }
-                    }
-
-                    const firstToken = findFirstToken(node);
-
-                    const commentText = formatComments(comments, firstToken.loc.start.column);
-
-                    const commentBeforeExpression = fixer.insertTextBeforeRange(
-                        firstToken.range,
-                        commentText
-                    );
-
-                    return [placeBesides, commentBeforeExpression];
-                }
-
-                return placeBesides;
-            };
-        }
+        const option = context.options[0] || "beside";
 
         /**
          * Validates the location of an arrow function body
@@ -193,35 +43,30 @@ module.exports = {
          * @returns {void}
          */
         function validateExpression(node) {
-            const option = getOption();
-
-            let tokenBefore = sourceCode.getTokenBefore(node.body);
-            const hasParens = tokenBefore.value === "(";
-
-            if (node.type === "BlockStatement") {
+            if (node.body.type === "BlockStatement") {
                 return;
             }
 
-            let fixerTarget = node.body;
+            const arrowToken = sourceCode.getTokenBefore(node.body, isNotOpeningParenToken);
+            const firstTokenOfBody = sourceCode.getTokenAfter(arrowToken);
 
-            if (hasParens) {
-
-                // Gets the first token before the function body that is not an open paren
-                tokenBefore = sourceCode.getTokenBefore(node.body, token => token.value !== "(");
-                fixerTarget = sourceCode.getTokenAfter(tokenBefore);
-            }
-
-            if (tokenBefore.loc.end.line === fixerTarget.loc.start.line && option === "below") {
+            if (arrowToken.loc.end.line === firstTokenOfBody.loc.start.line && option === "below") {
                 context.report({
-                    node: fixerTarget,
+                    node: firstTokenOfBody,
                     messageId: "expected",
-                    fix: fixer => fixer.insertTextBefore(fixerTarget, "\n")
+                    fix: fixer => fixer.insertTextBefore(firstTokenOfBody, "\n")
                 });
-            } else if (tokenBefore.loc.end.line !== fixerTarget.loc.start.line && option === "beside") {
+            } else if (arrowToken.loc.end.line !== firstTokenOfBody.loc.start.line && option === "beside") {
                 context.report({
-                    node: fixerTarget,
+                    node: firstTokenOfBody,
                     messageId: "unexpected",
-                    fix: autoFixBesides(tokenBefore, fixerTarget, node)
+                    fix(fixer) {
+                        if (sourceCode.getFirstTokenBetween(arrowToken, firstTokenOfBody, { includeComments: true, filter: isCommentToken })) {
+                            return null;
+                        }
+
+                        return fixer.replaceTextRange([arrowToken.range[1], firstTokenOfBody.range[0]], " ");
+                    }
                 });
             }
         }

package/lib/rules/indent-legacy.js

@@ -975,7 +975,7 @@ module.exports = {
          * @returns {boolean} the result
          */
         function isWrappedInParenthesis(node) {
-            const regex = /^return\s*?\(\s*?\);*?/;
+            const regex = /^return\s*?\(\s*?\);*?/u;
 
             const statementWithoutArgument = sourceCode.getText(node).replace(
                 sourceCode.getText(node.argument), ""

package/lib/rules/indent.js

@@ -442,7 +442,7 @@ class OffsetStorage {
                 const offset = (
                     offsetInfo.from &&
                     offsetInfo.from.loc.start.line === token.loc.start.line &&
-                    !/^\s*?\n/.test(token.value) &&
+                    !/^\s*?\n/u.test(token.value) &&
                     !offsetInfo.force
                 ) ? 0 : offsetInfo.offset * this._indentSize;
 
@@ -785,7 +785,7 @@ module.exports = {
          * or the total number of linebreaks if the string is all whitespace.
          */
         function countTrailingLinebreaks(string) {
-            const trailingWhitespace = string.match(/\s*$/)[0];
+            const trailingWhitespace = string.match(/\s*$/u)[0];
             const linebreakMatches = trailingWhitespace.match(astUtils.createGlobalLinebreakMatcher());
 
             return linebreakMatches === null ? 0 : linebreakMatches.length;

package/lib/rules/init-declarations.js

@@ -75,8 +75,7 @@ module.exports = {
                             type: "object",
                             properties: {
                                 ignoreForLoopInit: {
-                                    type: "boolean",
-                                    default: false
+                                    type: "boolean"
                                 }
                             },
                             additionalProperties: false

package/lib/rules/jsx-quotes.js

@@ -20,14 +20,14 @@ const QUOTE_SETTINGS = {
         quote: "\"",
         description: "singlequote",
         convert(str) {
-            return str.replace(/'/g, "\"");
+            return str.replace(/'/gu, "\"");
         }
     },
     "prefer-single": {
         quote: "'",
         description: "doublequote",
         convert(str) {
-            return str.replace(/"/g, "'");
+            return str.replace(/"/gu, "'");
         }
     }
 };

package/lib/rules/key-spacing.js

@@ -148,20 +148,16 @@ module.exports = {
                                     type: "object",
                                     properties: {
                                         mode: {
-                                            enum: ["strict", "minimum"],
-                                            default: "strict"
+                                            enum: ["strict", "minimum"]
                                         },
                                         on: {
-                                            enum: ["colon", "value"],
-                                            default: "colon"
+                                            enum: ["colon", "value"]
                                         },
                                         beforeColon: {
-                                            type: "boolean",
-                                            default: false
+                                            type: "boolean"
                                         },
                                         afterColon: {
-                                            type: "boolean",
-                                            default: true
+                                            type: "boolean"
                                         }
                                     },
                                     additionalProperties: false
@@ -169,16 +165,13 @@ module.exports = {
                             ]
                         },
                         mode: {
-                            enum: ["strict", "minimum"],
-                            default: "strict"
+                            enum: ["strict", "minimum"]
                         },
                         beforeColon: {
-                            type: "boolean",
-                            default: false
+                            type: "boolean"
                         },
                         afterColon: {
-                            type: "boolean",
-                            default: true
+                            type: "boolean"
                         }
                     },
                     additionalProperties: false
@@ -190,16 +183,13 @@ module.exports = {
                             type: "object",
                             properties: {
                                 mode: {
-                                    enum: ["strict", "minimum"],
-                                    default: "strict"
+                                    enum: ["strict", "minimum"]
                                 },
                                 beforeColon: {
-                                    type: "boolean",
-                                    default: false
+                                    type: "boolean"
                                 },
                                 afterColon: {
-                                    type: "boolean",
-                                    default: true
+                                    type: "boolean"
                                 }
                             },
                             additionalProperties: false
@@ -216,20 +206,16 @@ module.exports = {
                                             type: "object",
                                             properties: {
                                                 mode: {
-                                                    enum: ["strict", "minimum"],
-                                                    default: "strict"
+                                                    enum: ["strict", "minimum"]
                                                 },
                                                 on: {
-                                                    enum: ["colon", "value"],
-                                                    default: "colon"
+                                                    enum: ["colon", "value"]
                                                 },
                                                 beforeColon: {
-                                                    type: "boolean",
-                                                    default: false
+                                                    type: "boolean"
                                                 },
                                                 afterColon: {
-                                                    type: "boolean",
-                                                    default: true
+                                                    type: "boolean"
                                                 }
                                             },
                                             additionalProperties: false
@@ -237,16 +223,13 @@ module.exports = {
                                     ]
                                 },
                                 mode: {
-                                    enum: ["strict", "minimum"],
-                                    default: "strict"
+                                    enum: ["strict", "minimum"]
                                 },
                                 beforeColon: {
-                                    type: "boolean",
-                                    default: false
+                                    type: "boolean"
                                 },
                                 afterColon: {
-                                    type: "boolean",
-                                    default: true
+                                    type: "boolean"
                                 }
                             },
                             additionalProperties: false
@@ -261,16 +244,13 @@ module.exports = {
                             type: "object",
                             properties: {
                                 mode: {
-                                    enum: ["strict", "minimum"],
-                                    default: "strict"
+                                    enum: ["strict", "minimum"]
                                 },
                                 beforeColon: {
-                                    type: "boolean",
-                                    default: false
+                                    type: "boolean"
                                 },
                                 afterColon: {
-                                    type: "boolean",
-                                    default: true
+                                    type: "boolean"
                                 }
                             },
                             additionalProperties: false
@@ -279,16 +259,13 @@ module.exports = {
                             type: "object",
                             properties: {
                                 mode: {
-                                    enum: ["strict", "minimum"],
-                                    default: "strict"
+                                    enum: ["strict", "minimum"]
                                 },
                                 beforeColon: {
-                                    type: "boolean",
-                                    default: false
+                                    type: "boolean"
                                 },
                                 afterColon: {
-                                    type: "boolean",
-                                    default: true
+                                    type: "boolean"
                                 }
                             },
                             additionalProperties: false
@@ -297,20 +274,16 @@ module.exports = {
                             type: "object",
                             properties: {
                                 mode: {
-                                    enum: ["strict", "minimum"],
-                                    default: "strict"
+                                    enum: ["strict", "minimum"]
                                 },
                                 on: {
-                                    enum: ["colon", "value"],
-                                    default: "colon"
+                                    enum: ["colon", "value"]
                                 },
                                 beforeColon: {
-                                    type: "boolean",
-                                    default: false
+                                    type: "boolean"
                                 },
                                 afterColon: {
-                                    type: "boolean",
-                                    default: true
+                                    type: "boolean"
                                 }
                             },
                             additionalProperties: false
@@ -528,7 +501,7 @@ module.exports = {
          * @returns {Object} Whitespace before and after the property's colon.
          */
         function getPropertyWhitespace(property) {
-            const whitespace = /(\s*):(\s*)/.exec(sourceCode.getText().slice(
+            const whitespace = /(\s*):(\s*)/u.exec(sourceCode.getText().slice(
                 property.key.range[1], property.value.range[0]
             ));
 

package/lib/rules/keyword-spacing.js

@@ -16,13 +16,13 @@ const astUtils = require("../util/ast-utils"),
 // Constants
 //------------------------------------------------------------------------------
 
-const PREV_TOKEN = /^[)\]}>]$/;
-const NEXT_TOKEN = /^(?:[([{<~!]|\+\+?|--?)$/;
-const PREV_TOKEN_M = /^[)\]}>*]$/;
-const NEXT_TOKEN_M = /^[{*]$/;
-const TEMPLATE_OPEN_PAREN = /\$\{$/;
-const TEMPLATE_CLOSE_PAREN = /^\}/;
-const CHECK_TYPE = /^(?:JSXElement|RegularExpression|String|Template)$/;
+const PREV_TOKEN = /^[)\]}>]$/u;
+const NEXT_TOKEN = /^(?:[([{<~!]|\+\+?|--?)$/u;
+const PREV_TOKEN_M = /^[)\]}>*]$/u;
+const NEXT_TOKEN_M = /^[{*]$/u;
+const TEMPLATE_OPEN_PAREN = /\$\{$/u;
+const TEMPLATE_CLOSE_PAREN = /^\}/u;
+const CHECK_TYPE = /^(?:JSXElement|RegularExpression|String|Template)$/u;
 const KEYS = keywords.concat(["as", "async", "await", "from", "get", "let", "of", "set", "yield"]);
 
 // check duplications.

package/lib/rules/line-comment-position.js

@@ -38,12 +38,10 @@ module.exports = {
                                 type: "string"
                             },
                             applyDefaultPatterns: {
-                                type: "boolean",
-                                default: true
+                                type: "boolean"
                             },
                             applyDefaultIgnorePatterns: {
-                                type: "boolean",
-                                default: true
+                                type: "boolean"
                             }
                         },
                         additionalProperties: false
@@ -74,13 +72,13 @@ module.exports = {
             if (Object.prototype.hasOwnProperty.call(options, "applyDefaultIgnorePatterns")) {
                 applyDefaultIgnorePatterns = options.applyDefaultIgnorePatterns;
             } else {
-                applyDefaultIgnorePatterns = options.applyDefaultPatterns;
+                applyDefaultIgnorePatterns = options.applyDefaultPatterns !== false;
             }
         }
 
         const defaultIgnoreRegExp = astUtils.COMMENTS_IGNORE_PATTERN;
-        const fallThroughRegExp = /^\s*falls?\s?through/;
-        const customIgnoreRegExp = new RegExp(ignorePattern);
+        const fallThroughRegExp = /^\s*falls?\s?through/u;
+        const customIgnoreRegExp = new RegExp(ignorePattern); // eslint-disable-line require-unicode-regexp
         const sourceCode = context.getSourceCode();
 
         //--------------------------------------------------------------------------

package/lib/rules/lines-around-comment.js

@@ -130,7 +130,7 @@ module.exports = {
         const options = Object.assign({}, context.options[0]);
         const ignorePattern = options.ignorePattern;
         const defaultIgnoreRegExp = astUtils.COMMENTS_IGNORE_PATTERN;
-        const customIgnoreRegExp = new RegExp(ignorePattern);
+        const customIgnoreRegExp = new RegExp(ignorePattern); // eslint-disable-line require-unicode-regexp
         const applyDefaultIgnorePatterns = options.applyDefaultIgnorePatterns !== false;
 
         options.beforeBlockComment = typeof options.beforeBlockComment !== "undefined" ? options.beforeBlockComment : true;

package/lib/rules/max-depth.js

@@ -32,13 +32,11 @@ module.exports = {
                         properties: {
                             maximum: {
                                 type: "integer",
-                                minimum: 0,
-                                default: 4
+                                minimum: 0
                             },
                             max: {
                                 type: "integer",
-                                minimum: 0,
-                                default: 4
+                                minimum: 0
                             }
                         },
                         additionalProperties: false
@@ -61,7 +59,10 @@ module.exports = {
             option = context.options[0];
         let maxDepth = 4;
 
-        if (typeof option === "object") {
+        if (
+            typeof option === "object" &&
+            (Object.prototype.hasOwnProperty.call(option, "maximum") || Object.prototype.hasOwnProperty.call(option, "max"))
+        ) {
             maxDepth = option.maximum || option.max;
         }
         if (typeof option === "number") {

package/lib/rules/max-len.js

@@ -103,7 +103,7 @@ module.exports = {
          *   too many false positives
          * - We don't care about matching the entire URL, any small segment is fine
          */
-        const URL_REGEXP = /[^:/?#]:\/\/[^?#]/;
+        const URL_REGEXP = /[^:/?#]:\/\/[^?#]/u;
 
         const sourceCode = context.getSourceCode();
 
@@ -118,7 +118,7 @@ module.exports = {
         function computeLineLength(line, tabWidth) {
             let extraCharacterCount = 0;
 
-            line.replace(/\t/g, (match, offset) => {
+            line.replace(/\t/gu, (match, offset) => {
                 const totalOffset = offset + extraCharacterCount,
                     previousTabStopOffset = tabWidth ? totalOffset % tabWidth : 0,
                     spaceCount = tabWidth - previousTabStopOffset;
@@ -153,7 +153,7 @@ module.exports = {
         let ignorePattern = options.ignorePattern || null;
 
         if (ignorePattern) {
-            ignorePattern = new RegExp(ignorePattern);
+            ignorePattern = new RegExp(ignorePattern); // eslint-disable-line require-unicode-regexp
         }
 
         //--------------------------------------------------------------------------
@@ -201,7 +201,7 @@ module.exports = {
         function stripTrailingComment(line, comment) {
 
             // loc.column is zero-indexed
-            return line.slice(0, comment.loc.start.column).replace(/\s+$/, "");
+            return line.slice(0, comment.loc.start.column).replace(/\s+$/u, "");
         }
 
         /**

package/lib/rules/max-lines-per-function.js

@@ -187,7 +187,7 @@ module.exports = {
                 }
 
                 if (skipBlankLines) {
-                    if (line.match(/^\s*$/)) {
+                    if (line.match(/^\s*$/u)) {
                         continue;
                     }
                 }

package/lib/rules/max-lines.js

@@ -38,16 +38,13 @@ module.exports = {
                         properties: {
                             max: {
                                 type: "integer",
-                                minimum: 0,
-                                default: 300
+                                minimum: 0
                             },
                             skipComments: {
-                                type: "boolean",
-                                default: false
+                                type: "boolean"
                             },
                             skipBlankLines: {
-                                type: "boolean",
-                                default: false
+                                type: "boolean"
                             }
                         },
                         additionalProperties: false
@@ -64,7 +61,7 @@ module.exports = {
         const option = context.options[0];
         let max = 300;
 
-        if (typeof option === "object") {
+        if (typeof option === "object" && Object.prototype.hasOwnProperty.call(option, "max")) {
             max = option.max;
         } else if (typeof option === "number") {
             max = option;