eslint 4.7.2 → 4.11.0

package/lib/rules/no-param-reassign.js

@@ -127,8 +127,10 @@ module.exports = {
             if (identifier &&
                 !reference.init &&
 
-                // Destructuring assignments can have multiple default value,
-                // so possibly there are multiple writeable references for the same identifier.
+                /*
+                 * Destructuring assignments can have multiple default value,
+                 * so possibly there are multiple writeable references for the same identifier.
+                 */
                 (index === 0 || references[index - 1].identifier !== identifier)
             ) {
                 if (reference.isWrite()) {

package/lib/rules/no-regex-spaces.js

@@ -32,7 +32,7 @@ module.exports = {
          * @param {ASTNode} node node to validate
          * @param {string} value regular expression to validate
          * @param {number} valueStart The start location of the regex/string literal. It will always be the case that
-         `sourceCode.getText().slice(valueStart, valueStart + value.length) === value`
+         * `sourceCode.getText().slice(valueStart, valueStart + value.length) === value`
          * @returns {void}
          * @private
          */

package/lib/rules/no-restricted-imports.js

@@ -4,6 +4,13 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const DEFAULT_MESSAGE_TEMPLATE = "'{{importName}}' import is restricted from being used.";
+const CUSTOM_MESSAGE_TEMPLATE = "'{{importName}}' import is restricted from being used. {{customMessage}}";
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -11,9 +18,29 @@
 const ignore = require("ignore");
 
 const arrayOfStrings = {
+    type: "array",
+    items: { type: "string" },
+    uniqueItems: true
+};
+
+const arrayOfStringsOrObjects = {
     type: "array",
     items: {
-        type: "string"
+        anyOf: [
+            { type: "string" },
+            {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    message: {
+                        type: "string",
+                        minLength: 1
+                    }
+                },
+                additionalProperties: false,
+                required: ["name"]
+            }
+        ]
     },
     uniqueItems: true
 };
@@ -28,17 +55,17 @@ module.exports = {
 
         schema: {
             anyOf: [
-                arrayOfStrings,
+                arrayOfStringsOrObjects,
                 {
                     type: "array",
-                    items: [{
+                    items: {
                         type: "object",
                         properties: {
-                            paths: arrayOfStrings,
+                            paths: arrayOfStringsOrObjects,
                             patterns: arrayOfStrings
                         },
                         additionalProperties: false
-                    }],
+                    },
                     additionalItems: false
                 }
             ]
@@ -47,35 +74,77 @@ module.exports = {
 
     create(context) {
         const options = Array.isArray(context.options) ? context.options : [];
-        const isStringArray = typeof options[0] !== "object";
-        const restrictedPaths = new Set(isStringArray ? context.options : options[0].paths || []);
-        const restrictedPatterns = isStringArray ? [] : options[0].patterns || [];
+        const isPathAndPatternsObject =
+            typeof options[0] === "object" &&
+            (options[0].hasOwnProperty("paths") || options[0].hasOwnProperty("patterns"));
+
+        const restrictedPaths = (isPathAndPatternsObject ? options[0].paths : context.options) || [];
+        const restrictedPatterns = (isPathAndPatternsObject ? options[0].patterns : []) || [];
+
+        const restrictedPathMessages = restrictedPaths.reduce((memo, importName) => {
+            if (typeof importName === "string") {
+                memo[importName] = null;
+            } else {
+                memo[importName.name] = importName.message;
+            }
+            return memo;
+        }, {});
 
         // if no imports are restricted we don"t need to check
-        if (restrictedPaths.size === 0 && restrictedPatterns.length === 0) {
+        if (Object.keys(restrictedPaths).length === 0 && restrictedPatterns.length === 0) {
             return {};
         }
 
         const ig = ignore().add(restrictedPatterns);
 
+        /**
+         * Report a restricted path.
+         * @param {node} node representing the restricted path reference
+         * @returns {void}
+         * @private
+         */
+        function reportPath(node) {
+            const importName = node.source.value.trim();
+            const customMessage = restrictedPathMessages[importName];
+            const message = customMessage
+                ? CUSTOM_MESSAGE_TEMPLATE
+                : DEFAULT_MESSAGE_TEMPLATE;
+
+            context.report({
+                node,
+                message,
+                data: {
+                    importName,
+                    customMessage
+                }
+            });
+        }
+
+        /**
+         * Check if the given name is a restricted path name.
+         * @param {string} name name of a variable
+         * @returns {boolean} whether the variable is a restricted path or not
+         * @private
+         */
+        function isRestrictedPath(name) {
+            return Object.prototype.hasOwnProperty.call(restrictedPathMessages, name);
+        }
+
         return {
             ImportDeclaration(node) {
                 if (node && node.source && node.source.value) {
-
                     const importName = node.source.value.trim();
 
-                    if (restrictedPaths.has(importName)) {
-                        context.report({
-                            node,
-                            message: "'{{importName}}' import is restricted from being used.",
-                            data: { importName }
-                        });
+                    if (isRestrictedPath(importName)) {
+                        reportPath(node);
                     }
                     if (restrictedPatterns.length > 0 && ig.ignores(importName)) {
                         context.report({
                             node,
                             message: "'{{importName}}' import is restricted from being used by a pattern.",
-                            data: { importName }
+                            data: {
+                                importName
+                            }
                         });
                     }
                 }

package/lib/rules/no-restricted-modules.js

@@ -4,6 +4,13 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const DEFAULT_MESSAGE_TEMPLATE = "'{{moduleName}}' module is restricted from being used.";
+const CUSTOM_MESSAGE_TEMPLATE = "'{{moduleName}}' module is restricted from being used. {{customMessage}}";
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -11,9 +18,29 @@
 const ignore = require("ignore");
 
 const arrayOfStrings = {
+    type: "array",
+    items: { type: "string" },
+    uniqueItems: true
+};
+
+const arrayOfStringsOrObjects = {
     type: "array",
     items: {
-        type: "string"
+        anyOf: [
+            { type: "string" },
+            {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    message: {
+                        type: "string",
+                        minLength: 1
+                    }
+                },
+                additionalProperties: false,
+                required: ["name"]
+            }
+        ]
     },
     uniqueItems: true
 };
@@ -28,17 +55,17 @@ module.exports = {
 
         schema: {
             anyOf: [
-                arrayOfStrings,
+                arrayOfStringsOrObjects,
                 {
                     type: "array",
-                    items: [{
+                    items: {
                         type: "object",
                         properties: {
-                            paths: arrayOfStrings,
+                            paths: arrayOfStringsOrObjects,
                             patterns: arrayOfStrings
                         },
                         additionalProperties: false
-                    }],
+                    },
                     additionalItems: false
                 }
             ]
@@ -47,17 +74,30 @@ module.exports = {
 
     create(context) {
         const options = Array.isArray(context.options) ? context.options : [];
-        const isStringArray = typeof options[0] !== "object";
-        const restrictedPaths = new Set(isStringArray ? context.options : options[0].paths || []);
-        const restrictedPatterns = isStringArray ? [] : options[0].patterns || [];
+        const isPathAndPatternsObject =
+            typeof options[0] === "object" &&
+            (options[0].hasOwnProperty("paths") || options[0].hasOwnProperty("patterns"));
+
+        const restrictedPaths = (isPathAndPatternsObject ? options[0].paths : context.options) || [];
+        const restrictedPatterns = (isPathAndPatternsObject ? options[0].patterns : []) || [];
+
+        const restrictedPathMessages = restrictedPaths.reduce((memo, importName) => {
+            if (typeof importName === "string") {
+                memo[importName] = null;
+            } else {
+                memo[importName.name] = importName.message;
+            }
+            return memo;
+        }, {});
 
         // if no imports are restricted we don"t need to check
-        if (restrictedPaths.size === 0 && restrictedPatterns.length === 0) {
+        if (Object.keys(restrictedPaths).length === 0 && restrictedPatterns.length === 0) {
             return {};
         }
 
         const ig = ignore().add(restrictedPatterns);
 
+
         /**
          * Function to check if a node is a string literal.
          * @param {ASTNode} node The node to check.
@@ -76,6 +116,39 @@ module.exports = {
             return node.callee.type === "Identifier" && node.callee.name === "require";
         }
 
+        /**
+         * Report a restricted path.
+         * @param {node} node representing the restricted path reference
+         * @returns {void}
+         * @private
+         */
+        function reportPath(node) {
+            const moduleName = node.arguments[0].value.trim();
+            const customMessage = restrictedPathMessages[moduleName];
+            const message = customMessage
+                ? CUSTOM_MESSAGE_TEMPLATE
+                : DEFAULT_MESSAGE_TEMPLATE;
+
+            context.report({
+                node,
+                message,
+                data: {
+                    moduleName,
+                    customMessage
+                }
+            });
+        }
+
+        /**
+         * Check if the given name is a restricted path name
+         * @param {string} name name of a variable
+         * @returns {boolean} whether the variable is a restricted path or not
+         * @private
+         */
+        function isRestrictedPath(name) {
+            return Object.prototype.hasOwnProperty.call(restrictedPathMessages, name);
+        }
+
         return {
             CallExpression(node) {
                 if (isRequireCall(node)) {
@@ -85,12 +158,8 @@ module.exports = {
                         const moduleName = node.arguments[0].value.trim();
 
                         // check if argument value is in restricted modules array
-                        if (restrictedPaths.has(moduleName)) {
-                            context.report({
-                                node,
-                                message: "'{{moduleName}}' module is restricted from being used.",
-                                data: { moduleName }
-                            });
+                        if (isRestrictedPath(moduleName)) {
+                            reportPath(node);
                         }
 
                         if (restrictedPatterns.length > 0 && ig.ignores(moduleName)) {

package/lib/rules/no-restricted-properties.js

@@ -92,12 +92,12 @@ module.exports = {
         });
 
         /**
-        * Checks to see whether a property access is restricted, and reports it if so.
-        * @param {ASTNode} node The node to report
-        * @param {string} objectName The name of the object
-        * @param {string} propertyName The name of the property
-        * @returns {undefined}
-        */
+         * Checks to see whether a property access is restricted, and reports it if so.
+         * @param {ASTNode} node The node to report
+         * @param {string} objectName The name of the object
+         * @param {string} propertyName The name of the property
+         * @returns {undefined}
+         */
         function checkPropertyAccess(node, objectName, propertyName) {
             if (propertyName === null) {
                 return;
@@ -135,10 +135,10 @@ module.exports = {
         }
 
         /**
-        * Checks property accesses in a destructuring assignment expression, e.g. `var foo; ({foo} = bar);`
-        * @param {ASTNode} node An AssignmentExpression or AssignmentPattern node
-        * @returns {undefined}
-        */
+         * Checks property accesses in a destructuring assignment expression, e.g. `var foo; ({foo} = bar);`
+         * @param {ASTNode} node An AssignmentExpression or AssignmentPattern node
+         * @returns {undefined}
+         */
         function checkDestructuringAssignment(node) {
             if (node.right.type === "Identifier") {
                 const objectName = node.right.name;

package/lib/rules/no-return-await.js

@@ -40,12 +40,12 @@ module.exports = {
         }
 
         /**
-        * Determines whether a thrown error from this node will be caught/handled within this function rather than immediately halting
-        * this function. For example, a statement in a `try` block will always have an error handler. A statement in
-        * a `catch` block will only have an error handler if there is also a `finally` block.
-        * @param {ASTNode} node A node representing a location where an could be thrown
-        * @returns {boolean} `true` if a thrown error will be caught/handled in this function
-        */
+         * Determines whether a thrown error from this node will be caught/handled within this function rather than immediately halting
+         * this function. For example, a statement in a `try` block will always have an error handler. A statement in
+         * a `catch` block will only have an error handler if there is also a `finally` block.
+         * @param {ASTNode} node A node representing a location where an could be thrown
+         * @returns {boolean} `true` if a thrown error will be caught/handled in this function
+         */
         function hasErrorHandler(node) {
             let ancestor = node;
 

package/lib/rules/no-self-assign.js

@@ -114,8 +114,10 @@ function eachSelfAssignment(left, right, props, report) {
         right.properties.length >= 1
     ) {
 
-        // Gets the index of the last spread property.
-        // It's possible to overwrite properties followed by it.
+        /*
+         * Gets the index of the last spread property.
+         * It's possible to overwrite properties followed by it.
+         */
         let startJ = 0;
 
         for (let i = right.properties.length - 1; i >= 0; --i) {

package/lib/rules/no-sequences.js

@@ -40,10 +40,12 @@ module.exports = {
             WithStatement: "object",
             ArrowFunctionExpression: "body"
 
-            // Omitting CallExpression - commas are parsed as argument separators
-            // Omitting NewExpression - commas are parsed as argument separators
-            // Omitting ForInStatement - parts aren't individually parenthesised
-            // Omitting ForStatement - parts aren't individually parenthesised
+            /*
+             * Omitting CallExpression - commas are parsed as argument separators
+             * Omitting NewExpression - commas are parsed as argument separators
+             * Omitting ForInStatement - parts aren't individually parenthesised
+             * Omitting ForStatement - parts aren't individually parenthesised
+             */
         };
 
         /**

package/lib/rules/no-trailing-spaces.js

@@ -49,7 +49,7 @@ module.exports = {
 
         const options = context.options[0] || {},
             skipBlankLines = options.skipBlankLines || false,
-            ignoreComments = typeof options.ignoreComments === "undefined" || options.ignoreComments;
+            ignoreComments = typeof options.ignoreComments === "boolean" && options.ignoreComments;
 
         /**
          * Report the error message
@@ -101,8 +101,10 @@ module.exports = {
 
             Program: function checkTrailingSpaces(node) {
 
-                // Let's hack. Since Espree does not return whitespace nodes,
-                // fetch the source code and do matching via regexps.
+                /*
+                 * Let's hack. Since Espree does not return whitespace nodes,
+                 * fetch the source code and do matching via regexps.
+                 */
 
                 const re = new RegExp(NONBLANK),
                     skipMatch = new RegExp(SKIP_BLANK),
@@ -117,9 +119,11 @@ module.exports = {
                 for (let i = 0, ii = lines.length; i < ii; i++) {
                     const matches = re.exec(lines[i]);
 
-                    // Always add linebreak length to line length to accommodate for line break (\n or \r\n)
-                    // Because during the fix time they also reserve one spot in the array.
-                    // Usually linebreak length is 2 for \r\n (CRLF) and 1 for \n (LF)
+                    /*
+                     * Always add linebreak length to line length to accommodate for line break (\n or \r\n)
+                     * Because during the fix time they also reserve one spot in the array.
+                     * Usually linebreak length is 2 for \r\n (CRLF) and 1 for \n (LF)
+                     */
                     const linebreakLength = linebreaks && linebreaks[i] ? linebreaks[i].length : 1;
                     const lineLength = lines[i].length + linebreakLength;
 
@@ -140,8 +144,10 @@ module.exports = {
                             continue;
                         }
 
-                        // If the line has only whitespace, and skipBlankLines
-                        // is true, don't report it
+                        /*
+                         * If the line has only whitespace, and skipBlankLines
+                         * is true, don't report it
+                         */
                         if (skipBlankLines && skipMatch.test(lines[i])) {
                             totalLength += lineLength;
                             continue;

package/lib/rules/no-unneeded-ternary.js

@@ -72,8 +72,10 @@ module.exports = {
                     node.right,
                     token => token.value === node.operator
                 );
+                const text = sourceCode.getText();
 
-                return sourceCode.getText().slice(node.range[0], operatorToken.range[0]) + OPERATOR_INVERSES[node.operator] + sourceCode.getText().slice(operatorToken.range[1], node.range[1]);
+                return text.slice(node.range[0],
+                    operatorToken.range[0]) + OPERATOR_INVERSES[node.operator] + text.slice(operatorToken.range[1], node.range[1]);
             }
 
             if (astUtils.getPrecedence(node) < astUtils.getPrecedence({ type: "UnaryExpression" })) {

package/lib/rules/no-unreachable.js

@@ -145,8 +145,10 @@ module.exports = {
                 nextNode = node;
             }
 
-            // Report the current range since this statement is reachable or is
-            // not consecutive to the current range.
+            /*
+             * Report the current range since this statement is reachable or is
+             * not consecutive to the current range.
+             */
             if (!range.isEmpty) {
                 context.report({
                     message: "Unreachable code.",

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

@@ -59,7 +59,8 @@ module.exports = {
                          * Only perform a fix if there are no comments between the label and the body. This will be the case
                          * when there is exactly one token/comment (the ":") between the label and the body.
                          */
-                        if (sourceCode.getTokenAfter(node.label, { includeComments: true }) === sourceCode.getTokenBefore(node.body, { includeComments: true })) {
+                        if (sourceCode.getTokenAfter(node.label, { includeComments: true }) ===
+                                sourceCode.getTokenBefore(node.body, { includeComments: true })) {
                             return fixer.removeRange([node.range[0], node.body.range[0]]);
                         }
 

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

@@ -59,11 +59,11 @@ function isOuterClass(variable, reference) {
 }
 
 /**
-* Checks whether or not a given variable is a variable declaration in an upper function scope.
-* @param {eslint-scope.Variable} variable - A variable to check.
-* @param {eslint-scope.Reference} reference - A reference to check.
-* @returns {boolean} `true` if the variable is a variable declaration.
-*/
+ * Checks whether or not a given variable is a variable declaration in an upper function scope.
+ * @param {eslint-scope.Variable} variable - A variable to check.
+ * @param {eslint-scope.Reference} reference - A reference to check.
+ * @returns {boolean} `true` if the variable is a variable declaration.
+ */
 function isOuterVariable(variable, reference) {
     return (
         variable.defs[0].type === "Variable" &&
@@ -194,12 +194,14 @@ module.exports = {
             scope.references.forEach(reference => {
                 const variable = reference.resolved;
 
-                // Skips when the reference is:
-                // - initialization's.
-                // - referring to an undefined variable.
-                // - referring to a global environment variable (there're no identifiers).
-                // - located preceded by the variable (except in initializers).
-                // - allowed by options.
+                /*
+                 * Skips when the reference is:
+                 * - initialization's.
+                 * - referring to an undefined variable.
+                 * - referring to a global environment variable (there're no identifiers).
+                 * - located preceded by the variable (except in initializers).
+                 * - allowed by options.
+                 */
                 if (reference.init ||
                     !variable ||
                     variable.identifiers.length === 0 ||

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

@@ -28,30 +28,6 @@ function isCallOrNonVariadicApply(node) {
     );
 }
 
-/**
- * Checks whether or not the tokens of two given nodes are same.
- * @param {ASTNode} left - A node 1 to compare.
- * @param {ASTNode} right - A node 2 to compare.
- * @param {SourceCode} sourceCode - The ESLint source code object.
- * @returns {boolean} the source code for the given node.
- */
-function equalTokens(left, right, sourceCode) {
-    const tokensL = sourceCode.getTokens(left);
-    const tokensR = sourceCode.getTokens(right);
-
-    if (tokensL.length !== tokensR.length) {
-        return false;
-    }
-    for (let i = 0; i < tokensL.length; ++i) {
-        if (tokensL[i].type !== tokensR[i].type ||
-            tokensL[i].value !== tokensR[i].value
-        ) {
-            return false;
-        }
-    }
-
-    return true;
-}
 
 /**
  * Checks whether or not `thisArg` is not changed by `.call()`/`.apply()`.
@@ -64,7 +40,7 @@ function isValidThisArg(expectedThis, thisArg, sourceCode) {
     if (!expectedThis) {
         return astUtils.isNullOrUndefined(thisArg);
     }
-    return equalTokens(expectedThis, thisArg, sourceCode);
+    return astUtils.equalTokens(expectedThis, thisArg, sourceCode);
 }
 
 //------------------------------------------------------------------------------

package/lib/rules/no-useless-computed-key.js

@@ -50,7 +50,8 @@ module.exports = {
                             const rightSquareBracket = sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isClosingBracketToken);
                             const tokensBetween = sourceCode.getTokensBetween(leftSquareBracket, rightSquareBracket, 1);
 
-                            if (tokensBetween.slice(0, -1).some((token, index) => sourceCode.getText().slice(token.range[1], tokensBetween[index + 1].range[0]).trim())) {
+                            if (tokensBetween.slice(0, -1).some((token, index) =>
+                                sourceCode.getText().slice(token.range[1], tokensBetween[index + 1].range[0]).trim())) {
 
                                 // If there are comments between the brackets and the property name, don't do a fix.
                                 return null;