eslint 3.9.0 → 3.10.2

package/lib/rules/max-lines.js

@@ -114,26 +114,18 @@ module.exports = {
 
         return {
             "Program:exit"() {
-                let lines = sourceCode.lines.map(function(text, i) {
-                    return { lineNumber: i + 1, text };
-                });
+                let lines = sourceCode.lines.map((text, i) => ({ lineNumber: i + 1, text }));
 
                 if (skipBlankLines) {
-                    lines = lines.filter(function(l) {
-                        return l.text.trim() !== "";
-                    });
+                    lines = lines.filter(l => l.text.trim() !== "");
                 }
 
                 if (skipComments) {
                     const comments = sourceCode.getAllComments();
 
-                    const commentLines = lodash.flatten(comments.map(function(comment) {
-                        return getLinesWithoutCode(comment);
-                    }));
+                    const commentLines = lodash.flatten(comments.map(comment => getLinesWithoutCode(comment)));
 
-                    lines = lines.filter(function(l) {
-                        return !lodash.includes(commentLines, l.lineNumber);
-                    });
+                    lines = lines.filter(l => !lodash.includes(commentLines, l.lineNumber));
                 }
 
                 if (lines.length > max) {

package/lib/rules/max-statements.js

@@ -84,9 +84,18 @@ module.exports = {
          */
         function reportIfTooManyStatements(node, count, max) {
             if (count > max) {
+                const messageEnd = " has too many statements ({{count}}). Maximum allowed is {{max}}.";
+                let name = "This function";
+
+                if (node.id) {
+                    name = `Function '${node.id.name}'`;
+                } else if (node.parent.type === "MethodDefinition" || node.parent.type === "Property") {
+                    name = `Function '${context.getSource(node.parent.key)}'`;
+                }
+
                 context.report(
                     node,
-                    "This function has too many statements ({{count}}). Maximum allowed is {{max}}.",
+                    name + messageEnd,
                     { count, max });
             }
         }
@@ -146,7 +155,7 @@ module.exports = {
                     return;
                 }
 
-                topLevelFunctions.forEach(function(element) {
+                topLevelFunctions.forEach(element => {
                     const count = element.count;
                     const node = element.node;
 

package/lib/rules/newline-after-var.js

@@ -37,7 +37,7 @@ module.exports = {
         const mode = context.options[0] === "never" ? "never" : "always";
 
         // Cache starting and ending line numbers of comments for faster lookup
-        const commentEndLine = sourceCode.getAllComments().reduce(function(result, token) {
+        const commentEndLine = sourceCode.getAllComments().reduce((result, token) => {
             result[token.loc.start.line] = token.loc.end.line;
             return result;
         }, {});

package/lib/rules/newline-before-return.js

@@ -36,9 +36,7 @@ module.exports = {
         function isPrecededByTokens(node, testTokens) {
             const tokenBefore = sourceCode.getTokenBefore(node);
 
-            return testTokens.some(function(token) {
-                return tokenBefore.value === token;
-            });
+            return testTokens.some(token => tokenBefore.value === token);
         }
 
         /**
@@ -82,7 +80,7 @@ module.exports = {
                 return numLinesComments;
             }
 
-            comments.forEach(function(comment) {
+            comments.forEach(comment => {
                 numLinesComments++;
 
                 if (comment.type === "Block") {

package/lib/rules/no-alert.js

@@ -41,10 +41,8 @@ function report(context, node, identifierName) {
  * @returns {Reference|null} Returns the found reference or null if none were found.
  */
 function findReference(scope, node) {
-    const references = scope.references.filter(function(reference) {
-        return reference.identifier.range[0] === node.range[0] &&
-            reference.identifier.range[1] === node.range[1];
-    });
+    const references = scope.references.filter(reference => reference.identifier.range[0] === node.range[0] &&
+            reference.identifier.range[1] === node.range[1]);
 
     if (references.length === 1) {
         return references[0];

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

@@ -30,7 +30,7 @@ module.exports = {
          * @returns {void}
          */
         function checkVariable(variable) {
-            astUtils.getModifyingReferences(variable.references).forEach(function(reference) {
+            astUtils.getModifyingReferences(variable.references).forEach(reference => {
                 context.report(
                     reference.identifier,
                     "'{{name}}' is a class.",

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

@@ -30,7 +30,7 @@ module.exports = {
          * @returns {void}
          */
         function checkVariable(variable) {
-            astUtils.getModifyingReferences(variable.references).forEach(function(reference) {
+            astUtils.getModifyingReferences(variable.references).forEach(reference => {
                 context.report(
                     reference.identifier,
                     "'{{name}}' is constant.",

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

@@ -85,7 +85,7 @@ module.exports = {
                     stringControlChars = regexStr.slice(subStrIndex, -1)
                         .split(consecutiveSlashes)
                         .filter(Boolean)
-                        .map(function(x) {
+                        .map(x => {
                             const match = x.match(stringControlCharWithoutSlash) || [x];
 
                             return `\\${match[0]}`;
@@ -93,7 +93,7 @@ module.exports = {
                 }
             }
 
-            return controlChars.map(function(x) {
+            return controlChars.map(x => {
                 const hexCode = `0${x.charCodeAt(0).toString(16)}`.slice(-2);
 
                 return `\\x${hexCode}`;

package/lib/rules/no-duplicate-case.js

@@ -28,7 +28,7 @@ module.exports = {
             SwitchStatement(node) {
                 const mapping = {};
 
-                node.cases.forEach(function(switchCase) {
+                node.cases.forEach(switchCase => {
                     const key = sourceCode.getText(switchCase.test);
 
                     if (mapping[key]) {

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

@@ -30,7 +30,7 @@ module.exports = {
          * @returns {void}
          */
         function checkVariable(variable) {
-            astUtils.getModifyingReferences(variable.references).forEach(function(reference) {
+            astUtils.getModifyingReferences(variable.references).forEach(reference => {
                 context.report(
                     reference.identifier,
                     "Do not assign to the exception parameter.");

package/lib/rules/no-extend-native.js

@@ -44,14 +44,10 @@ module.exports = {
 
         const config = context.options[0] || {};
         const exceptions = config.exceptions || [];
-        let modifiedBuiltins = Object.keys(globals.builtin).filter(function(builtin) {
-            return builtin[0].toUpperCase() === builtin[0];
-        });
+        let modifiedBuiltins = Object.keys(globals.builtin).filter(builtin => builtin[0].toUpperCase() === builtin[0]);
 
         if (exceptions.length) {
-            modifiedBuiltins = modifiedBuiltins.filter(function(builtIn) {
-                return exceptions.indexOf(builtIn) === -1;
-            });
+            modifiedBuiltins = modifiedBuiltins.filter(builtIn => exceptions.indexOf(builtIn) === -1);
         }
 
         return {
@@ -72,7 +68,7 @@ module.exports = {
                     return;
                 }
 
-                modifiedBuiltins.forEach(function(builtin) {
+                modifiedBuiltins.forEach(builtin => {
                     if (lhs.object.object.name === builtin) {
                         context.report({
                             node,

package/lib/rules/no-extra-boolean-cast.js

@@ -17,10 +17,13 @@ module.exports = {
             recommended: true
         },
 
-        schema: []
+        schema: [],
+
+        fixable: "code"
     },
 
     create(context) {
+        const sourceCode = context.getSourceCode();
 
         // Node types which have a test which will coerce values to booleans.
         const BOOLEAN_NODE_TYPES = [
@@ -70,7 +73,11 @@ module.exports = {
                         grandparent.callee.type === "Identifier" &&
                         grandparent.callee.name === "Boolean")
                 ) {
-                    context.report(node, "Redundant double negation.");
+                    context.report({
+                        node,
+                        message: "Redundant double negation.",
+                        fix: fixer => fixer.replaceText(parent, sourceCode.getText(node.argument))
+                    });
                 }
             },
             CallExpression(node) {
@@ -81,7 +88,11 @@ module.exports = {
                 }
 
                 if (isInBooleanContext(node, parent)) {
-                    context.report(node, "Redundant Boolean call.");
+                    context.report({
+                        node,
+                        message: "Redundant Boolean call.",
+                        fix: fixer => fixer.replaceText(node, sourceCode.getText(node.arguments[0]))
+                    });
                 }
             }
         };

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

@@ -352,7 +352,7 @@ module.exports = {
                     report(node.arguments[0]);
                 }
             } else {
-                [].forEach.call(node.arguments, function(arg) {
+                [].forEach.call(node.arguments, arg => {
                     if (hasExcessParens(arg) && precedence(arg) >= precedence({type: "AssignmentExpression"})) {
                         report(arg);
                     }
@@ -381,7 +381,7 @@ module.exports = {
 
         return {
             ArrayExpression(node) {
-                [].forEach.call(node.elements, function(e) {
+                [].forEach.call(node.elements, e => {
                     if (e && hasExcessParens(e) && precedence(e) >= precedence({type: "AssignmentExpression"})) {
                         report(e);
                     }
@@ -531,7 +531,7 @@ module.exports = {
             NewExpression: dryCallNew,
 
             ObjectExpression(node) {
-                [].forEach.call(node.properties, function(e) {
+                [].forEach.call(node.properties, e => {
                     const v = e.value;
 
                     if (v && hasExcessParens(v) && precedence(v) >= precedence({type: "AssignmentExpression"})) {
@@ -557,7 +557,7 @@ module.exports = {
             },
 
             SequenceExpression(node) {
-                [].forEach.call(node.expressions, function(e) {
+                [].forEach.call(node.expressions, e => {
                     if (hasExcessParens(e) && precedence(e) >= precedence(node)) {
                         report(e);
                     }

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

@@ -30,7 +30,7 @@ module.exports = {
          * @returns {void}
          */
         function checkReference(references) {
-            astUtils.getModifyingReferences(references).forEach(function(reference) {
+            astUtils.getModifyingReferences(references).forEach(reference => {
                 context.report(
                     reference.identifier,
                     "'{{name}}' is a function.",

package/lib/rules/no-implicit-globals.js

@@ -25,26 +25,26 @@ module.exports = {
             Program() {
                 const scope = context.getScope();
 
-                scope.variables.forEach(function(variable) {
+                scope.variables.forEach(variable => {
                     if (variable.writeable) {
                         return;
                     }
 
-                    variable.defs.forEach(function(def) {
+                    variable.defs.forEach(def => {
                         if (def.type === "FunctionName" || (def.type === "Variable" && def.parent.kind === "var")) {
                             context.report(def.node, "Implicit global variable, assign as global property instead.");
                         }
                     });
                 });
 
-                scope.implicit.variables.forEach(function(variable) {
+                scope.implicit.variables.forEach(variable => {
                     const scopeVariable = scope.set.get(variable.name);
 
                     if (scopeVariable && scopeVariable.writeable) {
                         return;
                     }
 
-                    variable.defs.forEach(function(def) {
+                    variable.defs.forEach(def => {
                         context.report(def.node, "Implicit global variable, assign as global property instead.");
                     });
                 });

package/lib/rules/no-irregular-whitespace.js

@@ -76,7 +76,7 @@ module.exports = {
             const locStart = node.loc.start;
             const locEnd = node.loc.end;
 
-            errors = errors.filter(function(error) {
+            errors = errors.filter(error => {
                 const errorLoc = error[1];
 
                 if (errorLoc.line >= locStart.line && errorLoc.line <= locEnd.line) {
@@ -142,7 +142,7 @@ module.exports = {
         function checkForIrregularWhitespace(node) {
             const sourceLines = sourceCode.lines;
 
-            sourceLines.forEach(function(sourceLine, lineIndex) {
+            sourceLines.forEach((sourceLine, lineIndex) => {
                 const lineNumber = lineIndex + 1;
                 let match;
 
@@ -233,7 +233,7 @@ module.exports = {
                 }
 
                 // If we have any errors remaining report on them
-                errors.forEach(function(error) {
+                errors.forEach(error => {
                     context.report.apply(context, error);
                 });
             };

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

@@ -62,9 +62,7 @@ function normalizeOptions(options) {
  * @returns {boolean} `true` if such group existed.
  */
 function includesBothInAGroup(groups, left, right) {
-    return groups.some(function(group) {
-        return group.indexOf(left) !== -1 && group.indexOf(right) !== -1;
-    });
+    return groups.some(group => group.indexOf(left) !== -1 && group.indexOf(right) !== -1);
 }
 
 //------------------------------------------------------------------------------

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

@@ -169,7 +169,7 @@ module.exports = {
         function isMixed(declarations) {
             const contains = {};
 
-            declarations.forEach(function(declaration) {
+            declarations.forEach(declaration => {
                 const type = getDeclarationType(declaration.init);
 
                 contains[type] = true;
@@ -190,7 +190,7 @@ module.exports = {
         function isGrouped(declarations) {
             const found = {};
 
-            declarations.forEach(function(declaration) {
+            declarations.forEach(declaration => {
                 if (getDeclarationType(declaration.init) === DECL_REQUIRE) {
                     found[inferModuleType(declaration.init)] = true;
                 }

package/lib/rules/no-mixed-spaces-and-tabs.js

@@ -89,11 +89,11 @@ module.exports = {
                 const lines = sourceCode.lines,
                     comments = sourceCode.getAllComments();
 
-                comments.forEach(function(comment) {
+                comments.forEach(comment => {
                     ignoredLocs.push(comment.loc);
                 });
 
-                ignoredLocs.sort(function(first, second) {
+                ignoredLocs.sort((first, second) => {
                     if (beforeLoc(first, second.start.line, second.start.column)) {
                         return 1;
                     }
@@ -114,7 +114,7 @@ module.exports = {
                     regex = /^(?=[\t ]* \t)/;
                 }
 
-                lines.forEach(function(line, i) {
+                lines.forEach((line, i) => {
                     const match = regex.exec(line);
 
                     if (match) {

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

@@ -47,7 +47,7 @@ module.exports = {
             lastCommentIndex = 0;
 
         if (options && options.exceptions) {
-            Object.keys(options.exceptions).forEach(function(key) {
+            Object.keys(options.exceptions).forEach(key => {
                 if (options.exceptions[key]) {
                     exceptions[key] = true;
                 } else {

package/lib/rules/no-new-symbol.js

@@ -28,7 +28,7 @@ module.exports = {
                 const variable = globalScope.set.get("Symbol");
 
                 if (variable && variable.defs.length === 0) {
-                    variable.references.forEach(function(ref) {
+                    variable.references.forEach(ref => {
                         const node = ref.identifier;
 
                         if (node.parent && node.parent.type === "NewExpression") {

package/lib/rules/no-redeclare.js

@@ -40,14 +40,12 @@ module.exports = {
          * @private
          */
         function findVariablesInScope(scope) {
-            scope.variables.forEach(function(variable) {
+            scope.variables.forEach(variable => {
                 const hasBuiltin = options.builtinGlobals && "writeable" in variable;
                 const count = (hasBuiltin ? 1 : 0) + variable.identifiers.length;
 
                 if (count >= 2) {
-                    variable.identifiers.sort(function(a, b) {
-                        return a.range[1] - b.range[1];
-                    });
+                    variable.identifiers.sort((a, b) => a.range[1] - b.range[1]);
 
                     for (let i = (hasBuiltin ? 0 : 1), l = variable.identifiers.length; i < l; i++) {
                         context.report(

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

@@ -60,14 +60,14 @@ module.exports = {
                 const scope = context.getScope();
 
                 // Report variables declared elsewhere (ex: variables defined as "global" by eslint)
-                scope.variables.forEach(function(variable) {
+                scope.variables.forEach(variable => {
                     if (!variable.defs.length && isRestricted(variable.name)) {
                         variable.references.forEach(reportReference);
                     }
                 });
 
                 // Report variables not declared at all
-                scope.through.forEach(function(reference) {
+                scope.through.forEach(reference => {
                     if (isRestricted(reference.identifier.name)) {
                         reportReference(reference);
                     }

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

@@ -8,6 +8,16 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
+const ignore = require("ignore");
+
+const arrayOfStrings = {
+    type: "array",
+    items: {
+        type: "string"
+    },
+    uniqueItems: true
+};
+
 module.exports = {
     meta: {
         docs: {
@@ -17,31 +27,55 @@ module.exports = {
         },
 
         schema: {
-            type: "array",
-            items: {
-                type: "string"
-            },
-            uniqueItems: true
+            anyOf: [
+                arrayOfStrings,
+                {
+                    type: "array",
+                    items: [{
+                        type: "object",
+                        properties: {
+                            paths: arrayOfStrings,
+                            patterns: arrayOfStrings
+                        },
+                        additionalProperties: false
+                    }],
+                    additionalItems: false
+                }
+            ]
         }
     },
 
     create(context) {
-        const restrictedImports = context.options;
+        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 || [];
 
         // if no imports are restricted we don"t need to check
-        if (restrictedImports.length === 0) {
+        if (restrictedPaths.size === 0 && restrictedPatterns.length === 0) {
             return {};
         }
 
+        const ig = ignore().add(restrictedPatterns);
+
         return {
             ImportDeclaration(node) {
                 if (node && node.source && node.source.value) {
 
-                    const value = node.source.value.trim();
+                    const importName = node.source.value.trim();
 
-                    if (restrictedImports.indexOf(value) !== -1) {
-                        context.report(node, "'{{importName}}' import is restricted from being used.", {
-                            importName: value
+                    if (restrictedPaths.has(importName)) {
+                        context.report({
+                            node,
+                            message: "'{{importName}}' import is restricted from being used.",
+                            data: { importName }
+                        });
+                    }
+                    if (restrictedPatterns.length > 0 && ig.ignores(importName)) {
+                        context.report({
+                            node,
+                            message: "'{{importName}}' import is restricted from being used by a pattern.",
+                            data: { importName }
                         });
                     }
                 }

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

@@ -8,6 +8,16 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
+const ignore = require("ignore");
+
+const arrayOfStrings = {
+    type: "array",
+    items: {
+        type: "string"
+    },
+    uniqueItems: true
+};
+
 module.exports = {
     meta: {
         docs: {
@@ -17,24 +27,37 @@ module.exports = {
         },
 
         schema: {
-            type: "array",
-            items: {
-                type: "string"
-            },
-            uniqueItems: true
+            anyOf: [
+                arrayOfStrings,
+                {
+                    type: "array",
+                    items: [{
+                        type: "object",
+                        properties: {
+                            paths: arrayOfStrings,
+                            patterns: arrayOfStrings
+                        },
+                        additionalProperties: false
+                    }],
+                    additionalItems: false
+                }
+            ]
         }
     },
 
     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 || [];
 
-        // trim restricted module names
-        const restrictedModules = context.options;
-
-        // if no modules are restricted we don't need to check the CallExpressions
-        if (restrictedModules.length === 0) {
+        // if no imports are restricted we don"t need to check
+        if (restrictedPaths.size === 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.
@@ -53,36 +76,30 @@ module.exports = {
             return node.callee.type === "Identifier" && node.callee.name === "require";
         }
 
-        /**
-         * Function to check if a node has an argument that is an restricted module and return its name.
-         * @param {ASTNode} node The node to check
-         * @returns {undefined|string} restricted module name or undefined if node argument isn't restricted.
-         */
-        function getRestrictedModuleName(node) {
-            let moduleName;
-
-            // node has arguments and first argument is string
-            if (node.arguments.length && isString(node.arguments[0])) {
-                const argumentValue = node.arguments[0].value.trim();
-
-                // check if argument value is in restricted modules array
-                if (restrictedModules.indexOf(argumentValue) !== -1) {
-                    moduleName = argumentValue;
-                }
-            }
-
-            return moduleName;
-        }
-
         return {
             CallExpression(node) {
                 if (isRequireCall(node)) {
-                    const restrictedModuleName = getRestrictedModuleName(node);
 
-                    if (restrictedModuleName) {
-                        context.report(node, "'{{moduleName}}' module is restricted from being used.", {
-                            moduleName: restrictedModuleName
-                        });
+                    // node has arguments and first argument is string
+                    if (node.arguments.length && isString(node.arguments[0])) {
+                        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 (restrictedPatterns.length > 0 && ig.ignores(moduleName)) {
+                            context.report({
+                                node,
+                                message: "'{{moduleName}}' module is restricted from being used by a pattern.",
+                                data: { moduleName }
+                            });
+                        }
                     }
                 }
             }