eslint 4.7.1 → 4.10.0

package/lib/rules/no-alert.js

@@ -53,11 +53,10 @@ function findReference(scope, node) {
 /**
  * Checks if the given identifier node is shadowed in the given scope.
  * @param {Object} scope The current scope.
- * @param {Object} globalScope The global scope.
  * @param {string} node The identifier node to check
  * @returns {boolean} Whether or not the name is shadowed.
  */
-function isShadowed(scope, globalScope, node) {
+function isShadowed(scope, node) {
     const reference = findReference(scope, node);
 
     return reference && reference.resolved && reference.resolved.defs.length > 0;
@@ -66,15 +65,15 @@ function isShadowed(scope, globalScope, node) {
 /**
  * Checks if the given identifier node is a ThisExpression in the global scope or the global window property.
  * @param {Object} scope The current scope.
- * @param {Object} globalScope The global scope.
  * @param {string} node The identifier node to check
  * @returns {boolean} Whether or not the node is a reference to the global object.
  */
-function isGlobalThisReferenceOrGlobalWindow(scope, globalScope, node) {
+function isGlobalThisReferenceOrGlobalWindow(scope, node) {
     if (scope.type === "global" && node.type === "ThisExpression") {
         return true;
-    } else if (node.name === "window") {
-        return !isShadowed(scope, globalScope, node);
+    }
+    if (node.name === "window") {
+        return !isShadowed(scope, node);
     }
 
     return false;
@@ -96,14 +95,7 @@ module.exports = {
     },
 
     create(context) {
-        let globalScope;
-
         return {
-
-            Program() {
-                globalScope = context.getScope();
-            },
-
             CallExpression(node) {
                 const callee = node.callee,
                     currentScope = context.getScope();
@@ -112,11 +104,11 @@ module.exports = {
                 if (callee.type === "Identifier") {
                     const identifierName = callee.name;
 
-                    if (!isShadowed(currentScope, globalScope, callee) && isProhibitedIdentifier(callee.name)) {
+                    if (!isShadowed(currentScope, callee) && isProhibitedIdentifier(callee.name)) {
                         report(context, node, identifierName);
                     }
 
-                } else if (callee.type === "MemberExpression" && isGlobalThisReferenceOrGlobalWindow(currentScope, globalScope, callee.object)) {
+                } else if (callee.type === "MemberExpression" && isGlobalThisReferenceOrGlobalWindow(currentScope, callee.object)) {
                     const identifierName = getPropertyName(callee);
 
                     if (isProhibitedIdentifier(identifierName)) {

package/lib/rules/no-catch-shadow.js

@@ -51,7 +51,7 @@ module.exports = {
             CatchClause(node) {
                 let scope = context.getScope();
 
-                // When blockBindings is enabled, CatchClause creates its own scope
+                // When ecmaVersion >= 6, CatchClause creates its own scope
                 // so start from one upper scope to exclude the current node
                 if (scope.block === node) {
                     scope = scope.upper;

package/lib/rules/no-constant-condition.js

@@ -138,7 +138,7 @@ module.exports = {
         function checkConstantConditionLoopInSet(node) {
             if (loopsInCurrentScope.has(node)) {
                 loopsInCurrentScope.delete(node);
-                context.report({ node, message: "Unexpected constant condition." });
+                context.report({ node: node.test, message: "Unexpected constant condition." });
             }
         }
 
@@ -150,7 +150,7 @@ module.exports = {
          */
         function reportIfConstant(node) {
             if (node.test && isConstant(node.test, true)) {
-                context.report({ node, message: "Unexpected constant condition." });
+                context.report({ node: node.test, message: "Unexpected constant condition." });
             }
         }
 

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

@@ -31,7 +31,8 @@ module.exports = {
         function getRegExp(node) {
             if (node.value instanceof RegExp) {
                 return node.value;
-            } else if (typeof node.value === "string") {
+            }
+            if (typeof node.value === "string") {
 
                 const parent = context.getAncestors().pop();
 

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

@@ -24,8 +24,15 @@ module.exports = {
             recommended: false
         },
 
-        schema: [],
-
+        schema: [{
+            type: "object",
+            properties: {
+                allowElseIf: {
+                    type: "boolean"
+                }
+            },
+            additionalProperties: false
+        }],
         fixable: "code"
     },
 
@@ -134,13 +141,13 @@ module.exports = {
 
         /**
          * Check to see if the node is valid for evaluation,
-         * meaning it has an else and not an else-if
+         * meaning it has an else.
          *
          * @param {Node} node The node being evaluated
          * @returns {boolean} True if the node is valid
          */
         function hasElse(node) {
-            return node.alternate && node.consequent && node.alternate.type !== "IfStatement";
+            return node.alternate && node.consequent;
         }
 
         /**
@@ -189,14 +196,15 @@ module.exports = {
             return checkForReturnOrIf(node);
         }
 
+
         /**
-         * Check the if statement
+         * Check the if statement, but don't catch else-if blocks.
          * @returns {void}
          * @param {Node} node The node for the if statement to check
          * @private
          */
-        function IfStatement(node) {
-            const parent = context.getAncestors().pop();
+        function checkIfWithoutElse(node) {
+            const parent = node.parent;
             let consequents,
                 alternate;
 
@@ -221,13 +229,40 @@ module.exports = {
             }
         }
 
+        /**
+         * Check the if statement
+         * @returns {void}
+         * @param {Node} node The node for the if statement to check
+         * @private
+         */
+        function checkIfWithElse(node) {
+            const parent = node.parent;
+
+
+            /*
+             * Fixing this would require splitting one statement into two, so no error should
+             * be reported if this node is in a position where only one statement is allowed.
+             */
+            if (!astUtils.STATEMENT_LIST_PARENTS.has(parent.type)) {
+                return;
+            }
+
+            const alternate = node.alternate;
+
+            if (alternate && alwaysReturns(node.consequent)) {
+                displayReport(alternate);
+            }
+        }
+
+        const allowElseIf = !(context.options[0] && context.options[0].allowElseIf === false);
+
         //--------------------------------------------------------------------------
         // Public API
         //--------------------------------------------------------------------------
 
         return {
 
-            "IfStatement:exit": IfStatement
+            "IfStatement:exit": allowElseIf ? checkIfWithoutElse : checkIfWithElse
 
         };
 

package/lib/rules/no-extra-parens.js

@@ -195,10 +195,12 @@ module.exports = {
         function containsAssignment(node) {
             if (node.type === "AssignmentExpression") {
                 return true;
-            } else if (node.type === "ConditionalExpression" &&
+            }
+            if (node.type === "ConditionalExpression" &&
                     (node.consequent.type === "AssignmentExpression" || node.alternate.type === "AssignmentExpression")) {
                 return true;
-            } else if ((node.left && node.left.type === "AssignmentExpression") ||
+            }
+            if ((node.left && node.left.type === "AssignmentExpression") ||
                     (node.right && node.right.type === "AssignmentExpression")) {
                 return true;
             }
@@ -219,7 +221,8 @@ module.exports = {
 
             if (node.type === "ReturnStatement") {
                 return node.argument && containsAssignment(node.argument);
-            } else if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
+            }
+            if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
                 return containsAssignment(node.body);
             }
             return containsAssignment(node);

package/lib/rules/no-lonely-if.js

@@ -45,7 +45,8 @@ module.exports = {
                             const lastIfToken = sourceCode.getLastToken(node.consequent);
                             const sourceText = sourceCode.getText();
 
-                            if (sourceText.slice(openingElseCurly.range[1], node.range[0]).trim() || sourceText.slice(node.range[1], closingElseCurly.range[0]).trim()) {
+                            if (sourceText.slice(openingElseCurly.range[1],
+                                node.range[0]).trim() || sourceText.slice(node.range[1], closingElseCurly.range[0]).trim()) {
 
                                 // Don't fix if there are any non-whitespace characters interfering (e.g. comments)
                                 return null;

package/lib/rules/no-loop-func.js

@@ -88,12 +88,11 @@ function getTopLoopNode(node, excludedNode) {
  * Checks whether a given reference which refers to an upper scope's variable is
  * safe or not.
  *
- * @param {ASTNode} funcNode - A target function node.
  * @param {ASTNode} loopNode - A containing loop node.
  * @param {eslint-scope.Reference} reference - A reference to check.
  * @returns {boolean} `true` if the reference is safe or not.
  */
-function isSafe(funcNode, loopNode, reference) {
+function isSafe(loopNode, reference) {
     const variable = reference.resolved;
     const definition = variable && variable.defs[0];
     const declaration = definition && definition.parent;
@@ -183,7 +182,7 @@ module.exports = {
             const references = context.getScope().through;
 
             if (references.length > 0 &&
-                !references.every(isSafe.bind(null, node, loopNode))
+                !references.every(isSafe.bind(null, loopNode))
             ) {
                 context.report({ node, message: "Don't make functions within a loop." });
             }

package/lib/rules/no-mixed-requires.js

@@ -104,14 +104,16 @@ module.exports = {
 
                 // "var x = require('util');"
                 return DECL_REQUIRE;
-            } else if (allowCall &&
+            }
+            if (allowCall &&
                 initExpression.type === "CallExpression" &&
                 initExpression.callee.type === "CallExpression"
             ) {
 
                 // "var x = require('diagnose')('sub-module');"
                 return getDeclarationType(initExpression.callee);
-            } else if (initExpression.type === "MemberExpression") {
+            }
+            if (initExpression.type === "MemberExpression") {
 
                 // "var x = require('glob').Glob;"
                 return getDeclarationType(initExpression.object);
@@ -131,7 +133,8 @@ module.exports = {
 
                 // "var x = require('glob').Glob;"
                 return inferModuleType(initExpression.object);
-            } else if (initExpression.arguments.length === 0) {
+            }
+            if (initExpression.arguments.length === 0) {
 
                 // "var x = require();"
                 return REQ_COMPUTED;
@@ -149,7 +152,8 @@ module.exports = {
 
                 // "var fs = require('fs');"
                 return REQ_CORE;
-            } else if (/^\.{0,2}\//.test(arg.value)) {
+            }
+            if (/^\.{0,2}\//.test(arg.value)) {
 
                 // "var utils = require('./utils');"
                 return REQ_FILE;

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-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

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-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-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;

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

@@ -63,7 +63,14 @@ function parseRegExp(regExpText) {
                 return Object.assign(state, { inCharClass: false, startingCharClass: false });
             }
         }
-        charList.push({ text: char, index, escaped: state.escapeNextChar, inCharClass: state.inCharClass, startsCharClass: state.startingCharClass, endsCharClass: false });
+        charList.push({
+            text: char,
+            index,
+            escaped: state.escapeNextChar,
+            inCharClass: state.inCharClass,
+            startsCharClass: state.startingCharClass,
+            endsCharClass: false
+        });
         return Object.assign(state, { escapeNextChar: false, startingCharClass: false });
     }, { escapeNextChar: false, inCharClass: false, startingCharClass: false });