eslint 5.13.0 → 5.15.1

package/lib/rules/capitalized-comments.js

@@ -16,13 +16,8 @@ const astUtils = require("../util/ast-utils");
 //------------------------------------------------------------------------------
 
 const DEFAULT_IGNORE_PATTERN = astUtils.COMMENTS_IGNORE_PATTERN,
-    WHITESPACE = /\s/g,
-    MAYBE_URL = /^\s*[^:/?#\s]+:\/\/[^?#]/, // TODO: Combine w/ max-len pattern?
-    DEFAULTS = {
-        ignorePattern: null,
-        ignoreInlineComments: false,
-        ignoreConsecutiveComments: false
-    };
+    WHITESPACE = /\s/gu,
+    MAYBE_URL = /^\s*[^:/?#\s]+:\/\/[^?#]/u; // TODO: Combine w/ max-len pattern?
 
 /*
  * Base schema body for defining the basic capitalization rule, ignorePattern,
@@ -44,6 +39,11 @@ const SCHEMA_BODY = {
     },
     additionalProperties: false
 };
+const DEFAULTS = {
+    ignorePattern: "",
+    ignoreInlineComments: false,
+    ignoreConsecutiveComments: false
+};
 
 /**
  * Get normalized options for either block or line comments from the given
@@ -59,11 +59,7 @@ const SCHEMA_BODY = {
  * @param {string} which Either "line" or "block".
  * @returns {Object} The normalized options.
  */
-function getNormalizedOptions(rawOptions, which) {
-    if (!rawOptions) {
-        return Object.assign({}, DEFAULTS);
-    }
-
+function getNormalizedOptions(rawOptions = {}, which) {
     return Object.assign({}, DEFAULTS, rawOptions[which] || rawOptions);
 }
 
@@ -95,7 +91,7 @@ function createRegExpForIgnorePatterns(normalizedOptions) {
         const ignorePatternStr = normalizedOptions[key].ignorePattern;
 
         if (ignorePatternStr) {
-            const regExp = RegExp(`^\\s*(?:${ignorePatternStr})`);
+            const regExp = RegExp(`^\\s*(?:${ignorePatternStr})`); // eslint-disable-line require-unicode-regexp
 
             normalizedOptions[key].ignorePatternRegExp = regExp;
         }
@@ -214,7 +210,7 @@ module.exports = {
 
             // 2. Check for custom ignore pattern.
             const commentWithoutAsterisks = comment.value
-                .replace(/\*/g, "");
+                .replace(/\*/gu, "");
 
             if (options.ignorePatternRegExp && options.ignorePatternRegExp.test(commentWithoutAsterisks)) {
                 return true;

package/lib/rules/class-methods-use-this.js

@@ -38,7 +38,7 @@ module.exports = {
         }
     },
     create(context) {
-        const config = context.options[0] ? Object.assign({}, context.options[0]) : {};
+        const config = Object.assign({}, context.options[0]);
         const exceptMethods = new Set(config.exceptMethods || []);
 
         const stack = [];

package/lib/rules/comma-spacing.js

@@ -28,10 +28,12 @@ module.exports = {
                 type: "object",
                 properties: {
                     before: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     after: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     }
                 },
                 additionalProperties: false
@@ -50,8 +52,8 @@ module.exports = {
         const tokensAndComments = sourceCode.tokensAndComments;
 
         const options = {
-            before: context.options[0] ? !!context.options[0].before : false,
-            after: context.options[0] ? !!context.options[0].after : true
+            before: context.options[0] ? context.options[0].before : false,
+            after: context.options[0] ? context.options[0].after : true
         };
 
         //--------------------------------------------------------------------------
@@ -118,6 +120,10 @@ module.exports = {
                 report(reportItem, "before", tokens.left);
             }
 
+            if (tokens.right && astUtils.isClosingParenToken(tokens.right)) {
+                return;
+            }
+
             if (tokens.right && !options.after && tokens.right.type === "Line") {
                 return;
             }

package/lib/rules/complexity.js

@@ -63,13 +63,12 @@ module.exports = {
         const option = context.options[0];
         let THRESHOLD = 20;
 
-        if (typeof option === "object" && Object.prototype.hasOwnProperty.call(option, "maximum") && typeof option.maximum === "number") {
-            THRESHOLD = option.maximum;
-        }
-        if (typeof option === "object" && Object.prototype.hasOwnProperty.call(option, "max") && typeof option.max === "number") {
-            THRESHOLD = option.max;
-        }
-        if (typeof option === "number") {
+        if (
+            typeof option === "object" &&
+            (Object.prototype.hasOwnProperty.call(option, "maximum") || Object.prototype.hasOwnProperty.call(option, "max"))
+        ) {
+            THRESHOLD = option.maximum || option.max;
+        } else if (typeof option === "number") {
             THRESHOLD = option;
         }
 

package/lib/rules/consistent-return.js

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

package/lib/rules/curly.js

@@ -191,7 +191,7 @@ module.exports = {
                 return true;
             }
 
-            if (/^[([/`+-]/.test(tokenAfter.value)) {
+            if (/^[([/`+-]/u.test(tokenAfter.value)) {
 
                 // If the next token starts with a character that would disrupt ASI, insert a semicolon.
                 return true;

package/lib/rules/default-case.js

@@ -4,7 +4,7 @@
  */
 "use strict";
 
-const DEFAULT_COMMENT_PATTERN = /^no default$/i;
+const DEFAULT_COMMENT_PATTERN = /^no default$/iu;
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -39,7 +39,7 @@ module.exports = {
     create(context) {
         const options = context.options[0] || {};
         const commentPattern = options.commentPattern
-            ? new RegExp(options.commentPattern)
+            ? new RegExp(options.commentPattern) // eslint-disable-line require-unicode-regexp
             : DEFAULT_COMMENT_PATTERN;
 
         const sourceCode = context.getSourceCode();

package/lib/rules/dot-notation.js

@@ -14,7 +14,7 @@ const astUtils = require("../util/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/u;
 const keywords = require("../util/keywords");
 
 module.exports = {
@@ -33,10 +33,12 @@ module.exports = {
                 type: "object",
                 properties: {
                     allowKeywords: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     },
                     allowPattern: {
-                        type: "string"
+                        type: "string",
+                        default: ""
                     }
                 },
                 additionalProperties: false
@@ -53,13 +55,13 @@ module.exports = {
 
     create(context) {
         const options = context.options[0] || {};
-        const allowKeywords = options.allowKeywords === void 0 || !!options.allowKeywords;
+        const allowKeywords = options.allowKeywords === void 0 || options.allowKeywords;
         const sourceCode = context.getSourceCode();
 
         let allowPattern;
 
         if (options.allowPattern) {
-            allowPattern = new RegExp(options.allowPattern);
+            allowPattern = new RegExp(options.allowPattern); // eslint-disable-line require-unicode-regexp
         }
 
         /**

package/lib/rules/eol-last.js

@@ -97,7 +97,7 @@ module.exports = {
                         loc: location,
                         messageId: "unexpected",
                         fix(fixer) {
-                            const finalEOLs = /(?:\r?\n)+$/,
+                            const finalEOLs = /(?:\r?\n)+$/u,
                                 match = finalEOLs.exec(sourceCode.text),
                                 start = match.index,
                                 end = sourceCode.text.length;

package/lib/rules/func-call-spacing.js

@@ -92,8 +92,8 @@ module.exports = {
                 return;
             }
 
-            const textBetweenTokens = text.slice(prevToken.range[1], parenToken.range[0]).replace(/\/\*.*?\*\//g, "");
-            const hasWhitespace = /\s/.test(textBetweenTokens);
+            const textBetweenTokens = text.slice(prevToken.range[1], parenToken.range[0]).replace(/\/\*.*?\*\//gu, "");
+            const hasWhitespace = /\s/u.test(textBetweenTokens);
             const hasNewline = hasWhitespace && astUtils.LINEBREAK_MATCHER.test(textBetweenTokens);
 
             /*

package/lib/rules/func-style.js

@@ -27,7 +27,8 @@ module.exports = {
                 type: "object",
                 properties: {
                     allowArrowFunctions: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
@@ -43,7 +44,7 @@ module.exports = {
     create(context) {
 
         const style = context.options[0],
-            allowArrowFunctions = context.options[1] && context.options[1].allowArrowFunctions === true,
+            allowArrowFunctions = context.options[1] && context.options[1].allowArrowFunctions,
             enforceDeclarations = (style === "declaration"),
             stack = [];
 

package/lib/rules/getter-return.js

@@ -14,7 +14,7 @@ const astUtils = require("../util/ast-utils");
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
-const TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/;
+const TARGET_NODE_TYPE = /^(?:Arrow)?FunctionExpression$/u;
 
 /**
  * Checks a given code path segment is reachable.
@@ -60,7 +60,8 @@ module.exports = {
                 type: "object",
                 properties: {
                     allowImplicit: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false

package/lib/rules/handle-callback-err.js

@@ -52,7 +52,7 @@ module.exports = {
          */
         function matchesConfiguredErrorName(name) {
             if (isPattern(errorArgument)) {
-                const regexp = new RegExp(errorArgument);
+                const regexp = new RegExp(errorArgument); // eslint-disable-line require-unicode-regexp
 
                 return regexp.test(name);
             }

package/lib/rules/id-length.js

@@ -26,10 +26,11 @@ module.exports = {
                 type: "object",
                 properties: {
                     min: {
-                        type: "number"
+                        type: "integer",
+                        default: 2
                     },
                     max: {
-                        type: "number"
+                        type: "integer"
                     },
                     exceptions: {
                         type: "array",

package/lib/rules/id-match.js

@@ -28,13 +28,16 @@ module.exports = {
                 type: "object",
                 properties: {
                     properties: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     onlyDeclarations: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     ignoreDestructuring: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     }
                 }
             }
@@ -50,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/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;
 
@@ -518,7 +518,8 @@ module.exports = {
                 properties: {
                     SwitchCase: {
                         type: "integer",
-                        minimum: 0
+                        minimum: 0,
+                        default: 0
                     },
                     VariableDeclarator: {
                         oneOf: [
@@ -582,7 +583,8 @@ module.exports = {
                     ObjectExpression: ELEMENT_LIST_SCHEMA,
                     ImportDeclaration: ELEMENT_LIST_SCHEMA,
                     flatTernaryExpressions: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     ignoredNodes: {
                         type: "array",
@@ -594,7 +596,8 @@ module.exports = {
                         }
                     },
                     ignoreComments: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
@@ -650,7 +653,7 @@ module.exports = {
             }
 
             if (context.options[1]) {
-                lodash.merge(options, context.options[1]);
+                Object.assign(options, context.options[1]);
 
                 if (typeof options.VariableDeclarator === "number" || options.VariableDeclarator === "first") {
                     options.VariableDeclarator = {
@@ -782,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/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

@@ -501,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.
@@ -80,16 +80,16 @@ module.exports = {
             {
                 type: "object",
                 properties: {
-                    before: { type: "boolean" },
-                    after: { type: "boolean" },
+                    before: { type: "boolean", default: true },
+                    after: { type: "boolean", default: true },
                     overrides: {
                         type: "object",
                         properties: KEYS.reduce((retv, key) => {
                             retv[key] = {
                                 type: "object",
                                 properties: {
-                                    before: { type: "boolean" },
-                                    after: { type: "boolean" }
+                                    before: { type: "boolean", default: true },
+                                    after: { type: "boolean", default: true }
                                 },
                                 additionalProperties: false
                             };
@@ -228,9 +228,9 @@ module.exports = {
          *      Keys are keywords (there are for every keyword).
          *      Values are instances of `{"before": function, "after": function}`.
          */
-        function parseOptions(options) {
-            const before = !options || options.before !== false;
-            const after = !options || options.after !== false;
+        function parseOptions(options = {}) {
+            const before = options.before !== false;
+            const after = options.after !== false;
             const defaultValue = {
                 before: before ? expectSpaceBefore : unexpectSpaceBefore,
                 after: after ? expectSpaceAfter : unexpectSpaceAfter

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

@@ -31,7 +31,8 @@ module.exports = {
                         type: "object",
                         properties: {
                             position: {
-                                enum: ["above", "beside"]
+                                enum: ["above", "beside"],
+                                default: "above"
                             },
                             ignorePattern: {
                                 type: "string"
@@ -69,15 +70,15 @@ module.exports = {
             ignorePattern = options.ignorePattern;
 
             if (Object.prototype.hasOwnProperty.call(options, "applyDefaultIgnorePatterns")) {
-                applyDefaultIgnorePatterns = options.applyDefaultIgnorePatterns !== false;
+                applyDefaultIgnorePatterns = options.applyDefaultIgnorePatterns;
             } else {
                 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

@@ -68,22 +68,28 @@ module.exports = {
                 type: "object",
                 properties: {
                     beforeBlockComment: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     },
                     afterBlockComment: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     beforeLineComment: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     afterLineComment: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     allowBlockStart: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     allowBlockEnd: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     allowClassStart: {
                         type: "boolean"
@@ -121,19 +127,13 @@ module.exports = {
 
     create(context) {
 
-        const options = context.options[0] ? Object.assign({}, context.options[0]) : {};
+        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.beforeLineComment = options.beforeLineComment || false;
-        options.afterLineComment = options.afterLineComment || false;
         options.beforeBlockComment = typeof options.beforeBlockComment !== "undefined" ? options.beforeBlockComment : true;
-        options.afterBlockComment = options.afterBlockComment || false;
-        options.allowBlockStart = options.allowBlockStart || false;
-        options.allowBlockEnd = options.allowBlockEnd || false;
 
         const sourceCode = context.getSourceCode();
 

package/lib/rules/lines-between-class-members.js

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

package/lib/rules/max-depth.js

@@ -59,11 +59,11 @@ module.exports = {
             option = context.options[0];
         let maxDepth = 4;
 
-        if (typeof option === "object" && Object.prototype.hasOwnProperty.call(option, "maximum") && typeof option.maximum === "number") {
-            maxDepth = option.maximum;
-        }
-        if (typeof option === "object" && Object.prototype.hasOwnProperty.call(option, "max") && typeof option.max === "number") {
-            maxDepth = option.max;
+        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") {
             maxDepth = option;