eslint 4.9.0 → 4.10.0

package/CHANGELOG.md

@@ -1,3 +1,64 @@
+v4.10.0 - October 27, 2017
+
+* bb6e60a Fix: Improve the doc for no-restricted-modules rule (fixes #9437) (#9495) (vibss2397)
+* c529de9 Docs: Amend rule document to correct and complete it (refs #6251). (#9498) (Jonathan Pool)
+* f9c6673 Chore: Add tests to cover array and object values and leading commas. (#9502) (Jonathan Pool)
+* 9169258 Chore: remove `npm run check-commit` script (#9513) (Teddy Katz)
+* 7d390b2 Docs: Revise contributor documentation on issue labels. (#9469) (Jonathan Pool)
+* d80b9d0 Fix: no-var don't fix globals (fixes #9520) (#9525) (Toru Nagashima)
+* b8aa071 Fix: allow linting the empty string from stdin (fixes #9515) (#9517) (Teddy Katz)
+* 350a72c Chore: regex.test => string.startsWith (#9518) (薛定谔的猫)
+* de0bef4 Chore: remove obsolete eslintbot templates (#9512) (Teddy Katz)
+* 720b6d5 Docs: Update ISSUE_TEMPLATE.md (#9504) (薛定谔的猫)
+* 2fa64b7 Fix: should not convert non-consecutive line comments to a single blo… (#9475) (薛定谔的猫)
+* 9725146 Fix: multiline-comment-style fix produces invalid code (fixes #9461). (#9463) (薛定谔的猫)
+* b12cff8 Fix: Expected order of jsdoc tags (fixes #9412) (#9451) (Orlando Wenzinger)
+* f054ab5 Docs: add `.md` to link (for github users) (#9501) (薛定谔的猫)
+* 5ed9cfc Docs: Correct violations of “Variable Declarations” in Code Conventions (#9447) (Jonathan Pool)
+* 3171097 Docs: Clears confusion on usage of global and local plugins.(#9492) (Vasili Sviridov)
+* 3204773 Chore: enable max-len. (#9414) (薛定谔的猫)
+* 0f71fef Docs: Unquote booleans in lines-between-class-members docs (#9497) (Brandon Mills)
+* b3d7532 Docs: use consistent terminology & fix link etc. (#9490) (薛定谔的猫)
+* 87db8ae Docs: Fix broken links (#9488) (gpiress)
+* 51bdb2f Docs: Incorrect link to related rule (#9477) (Gavin King)
+* 1a962e8 Docs: Add FAQ for when ESLint cannot find plugin (#9467) (Kevin Partington)
+* 8768b2d Fix: multiline-comment-style autofixer added trailing space (#9454) (Teddy Katz)
+* e830aa1 Fix: multiline-comment-style reports block comments followed by code (#9450) (Teddy Katz)
+* b12e5fe Docs: Repair broken links and add migration links. (#9473) (Jonathan Pool)
+* eca01ed Docs: Add missing info about special status of home-dir config files. (#9472) (Jonathan Pool)
+* eb8cfb1 Fix: change err report in constant condition (fixes #9398) (#9436) (Victor Hom)
+* da77eb4 Chore: Revise no-config-file test to prevent false failure. (#9443) (Jonathan Pool)
+* 47e5f6f Docs: ensure "good commit message" examples actually follow guidelines (#9466) (Teddy Katz)
+* ebb530d Update: Don't ignore comments (no-trailing-spaces) (#9416) (Chris van Marle)
+* 5012661 Build: fix `npm run profile` script (fixes #9397) (#9455) (Teddy Katz)
+* ecac0fd Docs: Remove blockBindings references (#9446) (Jan Pilzer)
+* 0b89865 Chore: ensure tests for internal rules get run (#9453) (Teddy Katz)
+* 052c504 Docs: suggest deleting branches after merging PRs (#9449) (Teddy Katz)
+* b31e55a Chore: move internal rules out of lib/ (#9448) (Teddy Katz)
+* a7521e3 Docs: improve examples for multiline-comment-style (#9440) (Teddy Katz)
+* 235c7dd 4.9.0 (ESLint Jenkins)
+* b6f31a9 Build: changelog update for 4.9.0 (ESLint Jenkins)
+* 85388fb Fix: Correct error and test messages to fit config search path (#9428) (Jonathan Pool)
+* 62a323c Fix: Add class options for `lines-around-comment` (fixes #8564) (#8565) (Ed Lee)
+* 8eb4aae New: multiline-comment-style rule (fixes #8320) (#9389) (薛定谔的猫)
+* db41408 Chore: avoid applying eslint-env comments twice (#9278) (Teddy Katz)
+* febb897 Chore: avoid loose equality assertions (#9415) (Teddy Katz)
+* 2247efa Update: Add FunctionExpression to require-jsdoc (fixes #5867) (#9395) (Kai Cataldo)
+* 6791d18 Docs: Corrected noun to verb. (#9438) (Jonathan Pool)
+* b02fbb6 Update: custom messages for no-restricted-* (refs #8400) (Maja Wichrowska)
+* 02732bd Docs: Reorganized to avoid misunderstandings. (#9434) (Jonathan Pool)
+* d9466b8 Docs: Correct time forecast for tests. (#9432) (Jonathan Pool)
+* f7ed84f Docs: Add instruction re home-directory config files (refs #7729) (#9426) (Jonathan Pool)
+* 30d018b Chore: Add Aladdin-ADD & VictorHom to README (#9424) (Kai Cataldo)
+* 2d8a303 Docs: fix examples for prefer-numeric-literals (#9155) (Lutz Lengemann)
+* d7610f5 Docs: Add jquery warning to prefer-destructuring (#9409) (Thomas Grainger)
+* e835dd1 Docs: clarify no-mixed-operators (fixes #8051) (Ruxandra Fediuc)
+* 51360c8 Docs: update block-spacing details (fixes #8743) (#9375) (Victor Hom)
+* 6767857 Update: fix ignored nodes in indent rule when using tabs (fixes #9392) (#9393) (Robin Houston)
+* 37dde77 Chore: Refactor SourceCode#getJSDocComment (#9403) (Kai Cataldo)
+* 9fedd51 Chore: Add missing space in blog post template (#9407) (Kevin Partington)
+* 7654c99 Docs: add installing prerequisites in readme. (#9401) (薛定谔的猫)
+
 v4.9.0 - October 14, 2017
 
 * 85388fb Fix: Correct error and test messages to fit config search path (#9428) (Jonathan Pool)

package/README.md

@@ -206,11 +206,23 @@ Maybe, depending on how much you need it. [JSCS has reached end of life](https:/
 
 If you are having issues with JSCS, you can try to move to ESLint. We are focusing our time and energy on JSCS compatibility issues.
 
-
 ### Is ESLint just linting or does it also check style?
 
 ESLint does both traditional linting (looking for problematic patterns) and style checking (enforcement of conventions). You can use it for both.
 
+### Why can't ESLint find my plugins?
+
+ESLint can be [globally or locally installed](#installation-and-usage). If you install ESLint globally, your plugins must also be installed globally; if you install ESLint locally, your plugins must also be installed locally.
+
+If you are trying to run globally, make sure your plugins are installed globally (use `npm ls -g`).
+
+If you are trying to run locally:
+
+* Make sure your plugins (and ESLint) are both in your project's `package.json` as devDependencies (or dependencies, if your project uses ESLint at runtime).
+* Make sure you have run `npm install` and all your dependencies are installed.
+
+In all cases, make sure your plugins' peerDependencies have been installed as well. You can use `npm view eslint-plugin-myplugin peerDepencies` to see what peer dependencies `eslint-plugin-myplugin` has.
+
 ### Does ESLint support JSX?
 
 Yes, ESLint natively supports parsing JSX syntax (this must be enabled in [configuration](https://eslint.org/docs/user-guide/configuring).). Please note that supporting JSX syntax *is not* the same as supporting React. React applies specific semantics to JSX syntax that ESLint doesn't recognize. We recommend using [eslint-plugin-react](https://www.npmjs.com/package/eslint-plugin-react) if you are using React and want React semantics.

package/lib/cli-engine.js

@@ -240,8 +240,8 @@ function processFile(filename, configHelper, options, linter) {
 function createIgnoreResult(filePath, baseDir) {
     let message;
     const isHidden = /^\./.test(path.basename(filePath));
-    const isInNodeModules = baseDir && /^node_modules/.test(path.relative(baseDir, filePath));
-    const isInBowerComponents = baseDir && /^bower_components/.test(path.relative(baseDir, filePath));
+    const isInNodeModules = baseDir && path.relative(baseDir, filePath).startsWith("node_modules");
+    const isInBowerComponents = baseDir && path.relative(baseDir, filePath).startsWith("bower_components");
 
     if (isHidden) {
         message = "File ignored by default.  Use a negated ignore pattern (like \"--ignore-pattern '!<relative/path/to/filename>'\") to override.";

package/lib/cli.js

@@ -144,6 +144,8 @@ const cli = {
 
         const files = currentOptions._;
 
+        const useStdin = typeof text === "string";
+
         if (currentOptions.version) { // version from package.json
 
             log.info(`v${require("../package.json").version}`);
@@ -153,7 +155,7 @@ const cli = {
                 log.error("The --print-config option must be used with exactly one file name.");
                 return 1;
             }
-            if (text) {
+            if (useStdin) {
                 log.error("The --print-config option is not available for piped-in code.");
                 return 1;
             }
@@ -164,27 +166,27 @@ const cli = {
 
             log.info(JSON.stringify(fileConfig, null, "  "));
             return 0;
-        } else if (currentOptions.help || (!files.length && !text)) {
+        } else if (currentOptions.help || (!files.length && !useStdin)) {
 
             log.info(options.generateHelp());
 
         } else {
 
-            debug(`Running on ${text ? "text" : "files"}`);
+            debug(`Running on ${useStdin ? "text" : "files"}`);
 
             if (currentOptions.fix && currentOptions.fixDryRun) {
                 log.error("The --fix option and the --fix-dry-run option cannot be used together.");
                 return 1;
             }
 
-            if (text && currentOptions.fix) {
+            if (useStdin && currentOptions.fix) {
                 log.error("The --fix option is not available for piped-in code; use --fix-dry-run instead.");
                 return 1;
             }
 
             const engine = new CLIEngine(translateOptions(currentOptions));
 
-            const report = text ? engine.executeOnText(text, currentOptions.stdinFilename, true) : engine.executeOnFiles(files);
+            const report = useStdin ? engine.executeOnText(text, currentOptions.stdinFilename, true) : engine.executeOnFiles(files);
 
             if (currentOptions.fix) {
                 debug("Fix mode enabled - applying fixes");

package/lib/rules/comma-style.js

@@ -208,7 +208,9 @@ module.exports = {
                     if (item) {
                         const tokenAfterItem = sourceCode.getTokenAfter(item, astUtils.isNotClosingParenToken);
 
-                        previousItemToken = tokenAfterItem ? sourceCode.getTokenBefore(tokenAfterItem) : sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1];
+                        previousItemToken = tokenAfterItem
+                            ? sourceCode.getTokenBefore(tokenAfterItem)
+                            : sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1];
                     }
                 });
 

package/lib/rules/generator-star-spacing.js

@@ -68,7 +68,7 @@ module.exports = {
 
         /**
          * Returns resolved option definitions based on an option and defaults
-         * 
+         *
          * @param {any} option - The option object or string value
          * @param {Object} defaults - The defaults to use if options are not present
          * @returns {Object} the resolved object definition
@@ -121,7 +121,7 @@ module.exports = {
 
         /**
          * Checks the spacing between two tokens before or after the star token.
-         * 
+         *
          * @param {string} kind Either "named", "anonymous", or "method"
          * @param {string} side Either "before" or "after".
          * @param {Token} leftToken `function` keyword token if side is "before", or
@@ -161,7 +161,7 @@ module.exports = {
 
         /**
          * Enforces the spacing around the star if node is a generator function.
-         * 
+         *
          * @param {ASTNode} node A function expression or declaration node.
          * @returns {void}
          */

package/lib/rules/indent-legacy.js

@@ -733,7 +733,9 @@ module.exports = {
                         } else if (parent.type === "ObjectExpression" || parent.type === "ArrayExpression") {
                             const parentElements = node.parent.type === "ObjectExpression" ? node.parent.properties : node.parent.elements;
 
-                            if (parentElements[0] && parentElements[0].loc.start.line === parent.loc.start.line && parentElements[0].loc.end.line !== parent.loc.start.line) {
+                            if (parentElements[0] &&
+                                    parentElements[0].loc.start.line === parent.loc.start.line &&
+                                    parentElements[0].loc.end.line !== parent.loc.start.line) {
 
                                 /*
                                  * If the first element of the array spans multiple lines, don't increase the expected indentation of the rest.
@@ -797,7 +799,8 @@ module.exports = {
                 }
             }
 
-            checkLastNodeLineIndent(node, nodeIndent + (isNodeInVarOnTop(node, parentVarNode) ? options.VariableDeclarator[parentVarNode.parent.kind] * indentSize : 0));
+            checkLastNodeLineIndent(node, nodeIndent +
+                (isNodeInVarOnTop(node, parentVarNode) ? options.VariableDeclarator[parentVarNode.parent.kind] * indentSize : 0));
         }
 
         /**

package/lib/rules/indent.js

@@ -1245,7 +1245,9 @@ module.exports = {
             NewExpression(node) {
 
                 // Only indent the arguments if the NewExpression has parens (e.g. `new Foo(bar)` or `new Foo()`, but not `new Foo`
-                if (node.arguments.length > 0 || astUtils.isClosingParenToken(sourceCode.getLastToken(node)) && astUtils.isOpeningParenToken(sourceCode.getLastToken(node, 1))) {
+                if (node.arguments.length > 0 ||
+                        astUtils.isClosingParenToken(sourceCode.getLastToken(node)) &&
+                        astUtils.isOpeningParenToken(sourceCode.getLastToken(node, 1))) {
                     addFunctionCallIndent(node);
                 }
             },

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

@@ -308,7 +308,10 @@ module.exports = {
                 nextLineNum = token.loc.end.line + 1,
                 commentIsNotAlone = codeAroundComment(token);
 
-            const blockStartAllowed = options.allowBlockStart && isCommentAtBlockStart(token) && !(options.allowClassStart === false && isCommentAtClassStart(token)),
+            const blockStartAllowed = options.allowBlockStart &&
+                    isCommentAtBlockStart(token) &&
+                    !(options.allowClassStart === false &&
+                    isCommentAtClassStart(token)),
                 blockEndAllowed = options.allowBlockEnd && isCommentAtBlockEnd(token) && !(options.allowClassEnd === false && isCommentAtClassEnd(token)),
                 classStartAllowed = options.allowClassStart && isCommentAtClassStart(token),
                 classEndAllowed = options.allowClassEnd && isCommentAtClassEnd(token),

package/lib/rules/multiline-comment-style.js

@@ -125,10 +125,12 @@ module.exports = {
                         },
                         message: EXPECTED_BLOCK_ERROR,
                         fix(fixer) {
-                            return fixer.replaceTextRange(
-                                [commentGroup[0].range[0], commentGroup[commentGroup.length - 1].range[1]],
-                                `/*${convertToStarredBlock(commentGroup[0], commentLines)}*/`
-                            );
+                            const range = [commentGroup[0].range[0], commentGroup[commentGroup.length - 1].range[1]];
+                            const starredBlock = `/*${convertToStarredBlock(commentGroup[0], commentLines)}*/`;
+
+                            return commentLines.some(value => value.startsWith("/"))
+                                ? null
+                                : fixer.replaceTextRange(range, starredBlock);
                         }
                     });
                 } else {
@@ -174,8 +176,12 @@ module.exports = {
                                     : MISSING_STAR_ERROR,
                                 fix(fixer) {
                                     const lineStartIndex = sourceCode.getIndexFromLoc({ line: lineNumber, column: 0 });
-                                    const commentStartIndex = lineStartIndex + lineText.match(/^\s*\*? ?/)[0].length;
-                                    const replacementText = lineNumber === block.loc.end.line ? expectedLinePrefix : `${expectedLinePrefix} `;
+                                    const linePrefixLength = lineText.match(/^\s*\*? ?/)[0].length;
+                                    const commentStartIndex = lineStartIndex + linePrefixLength;
+
+                                    const replacementText = lineNumber === block.loc.end.line || lineText.length === linePrefixLength
+                                        ? expectedLinePrefix
+                                        : `${expectedLinePrefix} `;
 
                                     return fixer.replaceTextRange([lineStartIndex, commentStartIndex], replacementText);
                                 }
@@ -188,6 +194,11 @@ module.exports = {
                 if (!isJSDoc(commentGroup) && commentGroup[0].type === "Block") {
                     const commentLines = getCommentLines(commentGroup);
                     const block = commentGroup[0];
+                    const tokenAfter = sourceCode.getTokenAfter(block, { includeComments: true });
+
+                    if (tokenAfter && block.loc.end.line === tokenAfter.loc.start.line) {
+                        return;
+                    }
 
                     context.report({
                         loc: {
@@ -260,10 +271,13 @@ module.exports = {
                         return !tokenBefore || tokenBefore.loc.end.line < comment.loc.start.line;
                     })
                     .reduce((commentGroups, comment, index, commentList) => {
+                        const tokenBefore = sourceCode.getTokenBefore(comment, { includeComments: true });
+
                         if (
                             comment.type === "Line" &&
                             index && commentList[index - 1].type === "Line" &&
-                            sourceCode.getTokenBefore(comment, { includeComments: true }) === commentList[index - 1]
+                            tokenBefore && tokenBefore.loc.end.line === comment.loc.start.line - 1 &&
+                            tokenBefore === commentList[index - 1]
                         ) {
                             commentGroups[commentGroups.length - 1].push(comment);
                         } else {

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

package/lib/rules/no-var.js

@@ -15,6 +15,15 @@ const astUtils = require("../ast-utils");
 // Helpers
 //------------------------------------------------------------------------------
 
+/**
+ * Check whether a given variable is a global variable or not.
+ * @param {eslint-scope.Variable} variable The variable to check.
+ * @returns {boolean} `true` if the variable is a global variable.
+ */
+function isGlobal(variable) {
+    return Boolean(variable.scope) && variable.scope.type === "global";
+}
+
 /**
  * Finds the nearest function scope or global scope walking up the scope
  * hierarchy.
@@ -203,6 +212,7 @@ module.exports = {
          * Checks whether it can fix a given variable declaration or not.
          * It cannot fix if the following cases:
          *
+         * - A variable is a global variable.
          * - A variable is declared on a SwitchCase node.
          * - A variable is redeclared.
          * - A variable is used from outside the scope.
@@ -256,6 +266,7 @@ module.exports = {
 
             if (node.parent.type === "SwitchCase" ||
                 node.declarations.some(hasSelfReferenceInTDZ) ||
+                variables.some(isGlobal) ||
                 variables.some(isRedeclared) ||
                 variables.some(isUsedFromOutsideOf(scopeNode))
             ) {

package/lib/rules/object-shorthand.js

@@ -215,8 +215,12 @@ module.exports = {
         * @returns {Object} A fix for this node
         */
         function makeFunctionShorthand(fixer, node) {
-            const firstKeyToken = node.computed ? sourceCode.getFirstToken(node, astUtils.isOpeningBracketToken) : sourceCode.getFirstToken(node.key);
-            const lastKeyToken = node.computed ? sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isClosingBracketToken) : sourceCode.getLastToken(node.key);
+            const firstKeyToken = node.computed
+                ? sourceCode.getFirstToken(node, astUtils.isOpeningBracketToken)
+                : sourceCode.getFirstToken(node.key);
+            const lastKeyToken = node.computed
+                ? sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isClosingBracketToken)
+                : sourceCode.getLastToken(node.key);
             const keyText = sourceCode.text.slice(firstKeyToken.range[0], lastKeyToken.range[1]);
             let keyPrefix = "";
 

package/lib/rules/operator-linebreak.js

@@ -87,7 +87,9 @@ module.exports = {
                 if (hasLinebreakBefore !== hasLinebreakAfter && desiredStyle !== "none") {
 
                     // If there is a comment before and after the operator, don't do a fix.
-                    if (sourceCode.getTokenBefore(operatorToken, { includeComments: true }) !== tokenBefore && sourceCode.getTokenAfter(operatorToken, { includeComments: true }) !== tokenAfter) {
+                    if (sourceCode.getTokenBefore(operatorToken, { includeComments: true }) !== tokenBefore &&
+                        sourceCode.getTokenAfter(operatorToken, { includeComments: true }) !== tokenAfter) {
+
                         return null;
                     }
 

package/lib/rules/sort-imports.js

@@ -151,7 +151,8 @@ module.exports = {
                             message: "Member '{{memberName}}' of the import declaration should be sorted alphabetically.",
                             data: { memberName: importSpecifiers[firstUnsortedIndex].local.name },
                             fix(fixer) {
-                                if (importSpecifiers.some(specifier => sourceCode.getCommentsBefore(specifier).length || sourceCode.getCommentsAfter(specifier).length)) {
+                                if (importSpecifiers.some(specifier =>
+                                    sourceCode.getCommentsBefore(specifier).length || sourceCode.getCommentsAfter(specifier).length)) {
 
                                     // If there are comments in the ImportSpecifier list, don't rearrange the specifiers.
                                     return null;

package/lib/rules/valid-jsdoc.js

@@ -226,8 +226,10 @@ module.exports = {
         function checkJSDoc(node) {
             const jsdocNode = sourceCode.getJSDocComment(node),
                 functionData = fns.pop(),
-                params = Object.create(null);
+                params = Object.create(null),
+                paramsTags = [];
             let hasReturns = false,
+                returnsTag,
                 hasConstructor = false,
                 isInterface = false,
                 isOverride = false,
@@ -261,43 +263,13 @@ module.exports = {
                         case "param":
                         case "arg":
                         case "argument":
-                            if (!tag.type) {
-                                context.report({ node: jsdocNode, message: "Missing JSDoc parameter type for '{{name}}'.", data: { name: tag.name } });
-                            }
-
-                            if (!tag.description && requireParamDescription) {
-                                context.report({ node: jsdocNode, message: "Missing JSDoc parameter description for '{{name}}'.", data: { name: tag.name } });
-                            }
-
-                            if (params[tag.name]) {
-                                context.report({ node: jsdocNode, message: "Duplicate JSDoc parameter '{{name}}'.", data: { name: tag.name } });
-                            } else if (tag.name.indexOf(".") === -1) {
-                                params[tag.name] = 1;
-                            }
+                            paramsTags.push(tag);
                             break;
 
                         case "return":
                         case "returns":
                             hasReturns = true;
-
-                            if (!requireReturn && !functionData.returnPresent && (tag.type === null || !isValidReturnType(tag)) && !isAbstract) {
-                                context.report({
-                                    node: jsdocNode,
-                                    message: "Unexpected @{{title}} tag; function has no return statement.",
-                                    data: {
-                                        title: tag.title
-                                    }
-                                });
-                            } else {
-                                if (requireReturnType && !tag.type) {
-                                    context.report({ node: jsdocNode, message: "Missing JSDoc return type." });
-                                }
-
-                                if (!isValidReturnType(tag) && !tag.description && requireReturnDescription) {
-                                    context.report({ node: jsdocNode, message: "Missing JSDoc return description." });
-                                }
-                            }
-
+                            returnsTag = tag;
                             break;
 
                         case "constructor":
@@ -333,6 +305,40 @@ module.exports = {
                     }
                 });
 
+                paramsTags.forEach(param => {
+                    if (!param.type) {
+                        context.report({ node: jsdocNode, message: "Missing JSDoc parameter type for '{{name}}'.", data: { name: param.name } });
+                    }
+                    if (!param.description && requireParamDescription) {
+                        context.report({ node: jsdocNode, message: "Missing JSDoc parameter description for '{{name}}'.", data: { name: param.name } });
+                    }
+                    if (params[param.name]) {
+                        context.report({ node: jsdocNode, message: "Duplicate JSDoc parameter '{{name}}'.", data: { name: param.name } });
+                    } else if (param.name.indexOf(".") === -1) {
+                        params[param.name] = 1;
+                    }
+                });
+
+                if (hasReturns) {
+                    if (!requireReturn && !functionData.returnPresent && (returnsTag.type === null || !isValidReturnType(returnsTag)) && !isAbstract) {
+                        context.report({
+                            node: jsdocNode,
+                            message: "Unexpected @{{title}} tag; function has no return statement.",
+                            data: {
+                                title: returnsTag.title
+                            }
+                        });
+                    } else {
+                        if (requireReturnType && !returnsTag.type) {
+                            context.report({ node: jsdocNode, message: "Missing JSDoc return type." });
+                        }
+
+                        if (!isValidReturnType(returnsTag) && !returnsTag.description && requireReturnDescription) {
+                            context.report({ node: jsdocNode, message: "Missing JSDoc return description." });
+                        }
+                    }
+                }
+
                 // check for functions missing @returns
                 if (!isOverride && !hasReturns && !hasConstructor && !isInterface &&
                     node.parent.kind !== "get" && node.parent.kind !== "constructor" &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "4.9.0",
+  "version": "4.10.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -20,8 +20,7 @@
     "browserify": "node Makefile.js browserify",
     "perf": "node Makefile.js perf",
     "profile": "beefy tests/bench/bench.js --open -- -t brfs -t ./tests/bench/xform-rules.js -r espree",
-    "coveralls": "cat ./coverage/lcov.info | coveralls",
-    "check-commit": "node Makefile.js checkGitCommit"
+    "coveralls": "cat ./coverage/lcov.info | coveralls"
   },
   "files": [
     "LICENSE",

package/lib/internal-rules/.eslintrc.yml

@@ -1,3 +0,0 @@
-rules:
-    internal-no-invalid-meta: "error"
-    internal-consistent-docs-description: "error"

package/lib/internal-rules/internal-consistent-docs-description.js

@@ -1,130 +0,0 @@
-/**
- * @fileoverview Internal rule to enforce meta.docs.description conventions.
- * @author Vitor Balocco
- */
-
-"use strict";
-
-const ALLOWED_FIRST_WORDS = [
-    "enforce",
-    "require",
-    "disallow"
-];
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Gets the property of the Object node passed in that has the name specified.
- *
- * @param {string} property Name of the property to return.
- * @param {ASTNode} node The ObjectExpression node.
- * @returns {ASTNode} The Property node or null if not found.
- */
-function getPropertyFromObject(property, node) {
-    const properties = node.properties;
-
-    for (let i = 0; i < properties.length; i++) {
-        if (properties[i].key.name === property) {
-            return properties[i];
-        }
-    }
-
-    return null;
-}
-
-/**
- * Verifies that the meta.docs.description property follows our internal conventions.
- *
- * @param {RuleContext} context The ESLint rule context.
- * @param {ASTNode} exportsNode ObjectExpression node that the rule exports.
- * @returns {void}
- */
-function checkMetaDocsDescription(context, exportsNode) {
-    if (exportsNode.type !== "ObjectExpression") {
-
-        // if the exported node is not the correct format, "internal-no-invalid-meta" will already report this.
-        return;
-    }
-
-    const metaProperty = getPropertyFromObject("meta", exportsNode);
-    const metaDocs = metaProperty && getPropertyFromObject("docs", metaProperty.value);
-    const metaDocsDescription = metaDocs && getPropertyFromObject("description", metaDocs.value);
-
-    if (!metaDocsDescription) {
-
-        // if there is no `meta.docs.description` property, "internal-no-invalid-meta" will already report this.
-        return;
-    }
-
-    const description = metaDocsDescription.value.value;
-
-    if (typeof description !== "string") {
-        context.report({
-            node: metaDocsDescription.value,
-            message: "`meta.docs.description` should be a string."
-        });
-        return;
-    }
-
-    if (description === "") {
-        context.report({
-            node: metaDocsDescription.value,
-            message: "`meta.docs.description` should not be empty."
-        });
-        return;
-    }
-
-    if (description.indexOf(" ") === 0) {
-        context.report({
-            node: metaDocsDescription.value,
-            message: "`meta.docs.description` should not start with whitespace."
-        });
-        return;
-    }
-
-    const firstWord = description.split(" ")[0];
-
-    if (ALLOWED_FIRST_WORDS.indexOf(firstWord) === -1) {
-        context.report({
-            node: metaDocsDescription.value,
-            message: "`meta.docs.description` should start with one of the following words: {{ allowedWords }}. Started with \"{{ firstWord }}\" instead.",
-            data: {
-                allowedWords: ALLOWED_FIRST_WORDS.join(", "),
-                firstWord
-            }
-        });
-    }
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = {
-    meta: {
-        docs: {
-            description: "enforce correct conventions of `meta.docs.description` property in core rules",
-            category: "Internal",
-            recommended: false
-        },
-
-        schema: []
-    },
-
-    create(context) {
-        return {
-            AssignmentExpression(node) {
-                if (node.left &&
-                    node.right &&
-                    node.left.type === "MemberExpression" &&
-                    node.left.object.name === "module" &&
-                    node.left.property.name === "exports") {
-
-                    checkMetaDocsDescription(context, node.right);
-                }
-            }
-        };
-    }
-};

package/lib/internal-rules/internal-no-invalid-meta.js

@@ -1,188 +0,0 @@
-/**
- * @fileoverview Internal rule to prevent missing or invalid meta property in core rules.
- * @author Vitor Balocco
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Gets the property of the Object node passed in that has the name specified.
- *
- * @param {string} property Name of the property to return.
- * @param {ASTNode} node The ObjectExpression node.
- * @returns {ASTNode} The Property node or null if not found.
- */
-function getPropertyFromObject(property, node) {
-    const properties = node.properties;
-
-    for (let i = 0; i < properties.length; i++) {
-        if (properties[i].key.name === property) {
-            return properties[i];
-        }
-    }
-
-    return null;
-}
-
-/**
- * Extracts the `meta` property from the ObjectExpression that all rules export.
- *
- * @param {ASTNode} exportsNode ObjectExpression node that the rule exports.
- * @returns {ASTNode} The `meta` Property node or null if not found.
- */
-function getMetaPropertyFromExportsNode(exportsNode) {
-    return getPropertyFromObject("meta", exportsNode);
-}
-
-/**
- * Whether this `meta` ObjectExpression has a `docs` property defined or not.
- *
- * @param {ASTNode} metaPropertyNode The `meta` ObjectExpression for this rule.
- * @returns {boolean} `true` if a `docs` property exists.
- */
-function hasMetaDocs(metaPropertyNode) {
-    return Boolean(getPropertyFromObject("docs", metaPropertyNode.value));
-}
-
-/**
- * Whether this `meta` ObjectExpression has a `docs.description` property defined or not.
- *
- * @param {ASTNode} metaPropertyNode The `meta` ObjectExpression for this rule.
- * @returns {boolean} `true` if a `docs.description` property exists.
- */
-function hasMetaDocsDescription(metaPropertyNode) {
-    const metaDocs = getPropertyFromObject("docs", metaPropertyNode.value);
-
-    return metaDocs && getPropertyFromObject("description", metaDocs.value);
-}
-
-/**
- * Whether this `meta` ObjectExpression has a `docs.category` property defined or not.
- *
- * @param {ASTNode} metaPropertyNode The `meta` ObjectExpression for this rule.
- * @returns {boolean} `true` if a `docs.category` property exists.
- */
-function hasMetaDocsCategory(metaPropertyNode) {
-    const metaDocs = getPropertyFromObject("docs", metaPropertyNode.value);
-
-    return metaDocs && getPropertyFromObject("category", metaDocs.value);
-}
-
-/**
- * Whether this `meta` ObjectExpression has a `docs.recommended` property defined or not.
- *
- * @param {ASTNode} metaPropertyNode The `meta` ObjectExpression for this rule.
- * @returns {boolean} `true` if a `docs.recommended` property exists.
- */
-function hasMetaDocsRecommended(metaPropertyNode) {
-    const metaDocs = getPropertyFromObject("docs", metaPropertyNode.value);
-
-    return metaDocs && getPropertyFromObject("recommended", metaDocs.value);
-}
-
-/**
- * Whether this `meta` ObjectExpression has a `schema` property defined or not.
- *
- * @param {ASTNode} metaPropertyNode The `meta` ObjectExpression for this rule.
- * @returns {boolean} `true` if a `schema` property exists.
- */
-function hasMetaSchema(metaPropertyNode) {
-    return getPropertyFromObject("schema", metaPropertyNode.value);
-}
-
-/**
- * Checks the validity of the meta definition of this rule and reports any errors found.
- *
- * @param {RuleContext} context The ESLint rule context.
- * @param {ASTNode} exportsNode ObjectExpression node that the rule exports.
- * @param {boolean} ruleIsFixable whether the rule is fixable or not.
- * @returns {void}
- */
-function checkMetaValidity(context, exportsNode) {
-    const metaProperty = getMetaPropertyFromExportsNode(exportsNode);
-
-    if (!metaProperty) {
-        context.report(exportsNode, "Rule is missing a meta property.");
-        return;
-    }
-
-    if (!hasMetaDocs(metaProperty)) {
-        context.report(metaProperty, "Rule is missing a meta.docs property.");
-        return;
-    }
-
-    if (!hasMetaDocsDescription(metaProperty)) {
-        context.report(metaProperty, "Rule is missing a meta.docs.description property.");
-        return;
-    }
-
-    if (!hasMetaDocsCategory(metaProperty)) {
-        context.report(metaProperty, "Rule is missing a meta.docs.category property.");
-        return;
-    }
-
-    if (!hasMetaDocsRecommended(metaProperty)) {
-        context.report(metaProperty, "Rule is missing a meta.docs.recommended property.");
-        return;
-    }
-
-    if (!hasMetaSchema(metaProperty)) {
-        context.report(metaProperty, "Rule is missing a meta.schema property.");
-    }
-}
-
-/**
- * Whether this node is the correct format for a rule definition or not.
- *
- * @param {ASTNode} node node that the rule exports.
- * @returns {boolean} `true` if the exported node is the correct format for a rule definition
- */
-function isCorrectExportsFormat(node) {
-    return node.type === "ObjectExpression";
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = {
-    meta: {
-        docs: {
-            description: "enforce correct use of `meta` property in core rules",
-            category: "Internal",
-            recommended: false
-        },
-
-        schema: []
-    },
-
-    create(context) {
-        let exportsNode;
-
-        return {
-            AssignmentExpression(node) {
-                if (node.left &&
-                    node.right &&
-                    node.left.type === "MemberExpression" &&
-                    node.left.object.name === "module" &&
-                    node.left.property.name === "exports") {
-
-                    exportsNode = node.right;
-                }
-            },
-
-            "Program:exit"() {
-                if (!isCorrectExportsFormat(exportsNode)) {
-                    context.report({ node: exportsNode, message: "Rule does not export an Object. Make sure the rule follows the new rule format." });
-                    return;
-                }
-
-                checkMetaValidity(context, exportsNode);
-            }
-        };
-    }
-};