eslint 5.12.0 → 5.14.1

package/lib/rules/valid-jsdoc.js

@@ -42,22 +42,27 @@ module.exports = {
                         }
                     },
                     requireReturn: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     },
                     requireParamDescription: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     },
                     requireReturnDescription: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     },
                     matchDescription: {
                         type: "string"
                     },
                     requireReturnType: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     },
                     requireParamType: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     }
                 },
                 additionalProperties: false
@@ -65,6 +70,22 @@ module.exports = {
         ],
 
         fixable: "code",
+        messages: {
+            unexpectedTag: "Unexpected @{{title}} tag; function has no return statement.",
+            expected: "Expected JSDoc for '{{name}}' but found '{{jsdocName}}'.",
+            use: "Use @{{name}} instead.",
+            useType: "Use '{{expectedTypeName}}' instead of '{{currentTypeName}}'.",
+            syntaxError: "JSDoc syntax error.",
+            missingBrace: "JSDoc type missing brace.",
+            missingParamDesc: "Missing JSDoc parameter description for '{{name}}'.",
+            missingParamType: "Missing JSDoc parameter type for '{{name}}'.",
+            missingReturnType: "Missing JSDoc return type.",
+            missingReturnDesc: "Missing JSDoc return description.",
+            missingReturn: "Missing JSDoc @{{returns}} for function.",
+            missingParam: "Missing JSDoc for parameter '{{name}}'.",
+            duplicateParam: "Duplicate JSDoc parameter '{{name}}'.",
+            unsatisfiedDesc: "JSDoc description does not satisfy the regex pattern."
+        },
 
         deprecated: true,
         replacedBy: []
@@ -231,7 +252,7 @@ module.exports = {
                     typeToCheck.expectedTypeName !== typeToCheck.currentType.name) {
                     context.report({
                         node: jsdocNode,
-                        message: "Use '{{expectedTypeName}}' instead of '{{currentTypeName}}'.",
+                        messageId: "useType",
                         loc: getAbsoluteRange(jsdocNode, typeToCheck.currentType),
                         data: {
                             currentTypeName: typeToCheck.currentType.name,
@@ -280,9 +301,9 @@ module.exports = {
                 } catch (ex) {
 
                     if (/braces/i.test(ex.message)) {
-                        context.report({ node: jsdocNode, message: "JSDoc type missing brace." });
+                        context.report({ node: jsdocNode, messageId: "missingBrace" });
                     } else {
-                        context.report({ node: jsdocNode, message: "JSDoc syntax error." });
+                        context.report({ node: jsdocNode, messageId: "syntaxError" });
                     }
 
                     return;
@@ -332,7 +353,7 @@ module.exports = {
 
                         context.report({
                             node: jsdocNode,
-                            message: "Use @{{name}} instead.",
+                            messageId: "use",
                             loc: {
                                 start: entireTagRange.start,
                                 end: {
@@ -363,7 +384,7 @@ module.exports = {
                     if (requireParamType && !param.type) {
                         context.report({
                             node: jsdocNode,
-                            message: "Missing JSDoc parameter type for '{{name}}'.",
+                            messageId: "missingParamType",
                             loc: getAbsoluteRange(jsdocNode, param),
                             data: { name: param.name }
                         });
@@ -371,7 +392,7 @@ module.exports = {
                     if (!param.description && requireParamDescription) {
                         context.report({
                             node: jsdocNode,
-                            message: "Missing JSDoc parameter description for '{{name}}'.",
+                            messageId: "missingParamDesc",
                             loc: getAbsoluteRange(jsdocNode, param),
                             data: { name: param.name }
                         });
@@ -379,7 +400,7 @@ module.exports = {
                     if (paramTagsByName[param.name]) {
                         context.report({
                             node: jsdocNode,
-                            message: "Duplicate JSDoc parameter '{{name}}'.",
+                            messageId: "duplicateParam",
                             loc: getAbsoluteRange(jsdocNode, param),
                             data: { name: param.name }
                         });
@@ -392,7 +413,7 @@ module.exports = {
                     if (!requireReturn && !functionData.returnPresent && (returnsTag.type === null || !isValidReturnType(returnsTag)) && !isAbstract) {
                         context.report({
                             node: jsdocNode,
-                            message: "Unexpected @{{title}} tag; function has no return statement.",
+                            messageId: "unexpectedTag",
                             loc: getAbsoluteRange(jsdocNode, returnsTag),
                             data: {
                                 title: returnsTag.title
@@ -400,11 +421,11 @@ module.exports = {
                         });
                     } else {
                         if (requireReturnType && !returnsTag.type) {
-                            context.report({ node: jsdocNode, message: "Missing JSDoc return type." });
+                            context.report({ node: jsdocNode, messageId: "missingReturnType" });
                         }
 
                         if (!isValidReturnType(returnsTag) && !returnsTag.description && requireReturnDescription) {
-                            context.report({ node: jsdocNode, message: "Missing JSDoc return description." });
+                            context.report({ node: jsdocNode, messageId: "missingReturnDesc" });
                         }
                     }
                 }
@@ -416,7 +437,7 @@ module.exports = {
                     if (requireReturn || (functionData.returnPresent && !node.async)) {
                         context.report({
                             node: jsdocNode,
-                            message: "Missing JSDoc @{{returns}} for function.",
+                            messageId: "missingReturn",
                             data: {
                                 returns: prefer.returns || "returns"
                             }
@@ -440,7 +461,7 @@ module.exports = {
                             if (jsdocParamNames[paramsIndex] && (name !== jsdocParamNames[paramsIndex])) {
                                 context.report({
                                     node: jsdocNode,
-                                    message: "Expected JSDoc for '{{name}}' but found '{{jsdocName}}'.",
+                                    messageId: "expected",
                                     loc: getAbsoluteRange(jsdocNode, paramTagsByName[jsdocParamNames[paramsIndex]]),
                                     data: {
                                         name,
@@ -450,7 +471,7 @@ module.exports = {
                             } else if (!paramTagsByName[name] && !isOverride) {
                                 context.report({
                                     node: jsdocNode,
-                                    message: "Missing JSDoc for parameter '{{name}}'.",
+                                    messageId: "missingParam",
                                     data: {
                                         name
                                     }
@@ -464,7 +485,7 @@ module.exports = {
                     const regex = new RegExp(options.matchDescription);
 
                     if (!regex.test(jsdoc.description)) {
-                        context.report({ node: jsdocNode, message: "JSDoc description does not satisfy the regex pattern." });
+                        context.report({ node: jsdocNode, messageId: "unsatisfiedDesc" });
                     }
                 }
 

package/lib/rules/valid-typeof.js

@@ -24,12 +24,17 @@ module.exports = {
                 type: "object",
                 properties: {
                     requireStringLiterals: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
             }
-        ]
+        ],
+        messages: {
+            invalidValue: "Invalid typeof comparison value.",
+            notString: "Typeof comparisons should be to string literals."
+        }
     },
 
     create(context) {
@@ -65,10 +70,10 @@ module.exports = {
                             const value = sibling.type === "Literal" ? sibling.value : sibling.quasis[0].value.cooked;
 
                             if (VALID_TYPES.indexOf(value) === -1) {
-                                context.report({ node: sibling, message: "Invalid typeof comparison value." });
+                                context.report({ node: sibling, messageId: "invalidValue" });
                             }
                         } else if (requireStringLiterals && !isTypeofExpression(sibling)) {
-                            context.report({ node: sibling, message: "Typeof comparisons should be to string literals." });
+                            context.report({ node: sibling, messageId: "notString" });
                         }
                     }
                 }

package/lib/rules/vars-on-top.js

@@ -20,11 +20,13 @@ module.exports = {
             url: "https://eslint.org/docs/rules/vars-on-top"
         },
 
-        schema: []
+        schema: [],
+        messages: {
+            top: "All 'var' declarations must be at the top of the function scope."
+        }
     },
 
     create(context) {
-        const errorMessage = "All 'var' declarations must be at the top of the function scope.";
 
         //--------------------------------------------------------------------------
         // Helpers
@@ -103,7 +105,7 @@ module.exports = {
          */
         function globalVarCheck(node, parent) {
             if (!isVarOnTop(node, parent.body)) {
-                context.report({ node, message: errorMessage });
+                context.report({ node, messageId: "top" });
             }
         }
 
@@ -118,7 +120,7 @@ module.exports = {
             if (!(/Function/.test(grandParent.type) &&
                     parent.type === "BlockStatement" &&
                     isVarOnTop(node, parent.body))) {
-                context.report({ node, message: errorMessage });
+                context.report({ node, messageId: "top" });
             }
         }
 

package/lib/rules/wrap-iife.js

@@ -34,20 +34,26 @@ module.exports = {
                 type: "object",
                 properties: {
                     functionPrototypeMethods: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
             }
         ],
 
-        fixable: "code"
+        fixable: "code",
+        messages: {
+            wrapInvocation: "Wrap an immediate function invocation in parentheses.",
+            wrapExpression: "Wrap only the function expression in parens.",
+            moveInvocation: "Move the invocation into the parens that contain the function."
+        }
     },
 
     create(context) {
 
         const style = context.options[0] || "outside";
-        const includeFunctionPrototypeMethods = (context.options[1] && context.options[1].functionPrototypeMethods) || false;
+        const includeFunctionPrototypeMethods = context.options[1] && context.options[1].functionPrototypeMethods;
 
         const sourceCode = context.getSourceCode();
 
@@ -99,7 +105,7 @@ module.exports = {
                 if (!callExpressionWrapped && !functionExpressionWrapped) {
                     context.report({
                         node,
-                        message: "Wrap an immediate function invocation in parentheses.",
+                        messageId: "wrapInvocation",
                         fix(fixer) {
                             const nodeToSurround = style === "inside" ? innerNode : node;
 
@@ -109,7 +115,7 @@ module.exports = {
                 } else if (style === "inside" && !functionExpressionWrapped) {
                     context.report({
                         node,
-                        message: "Wrap only the function expression in parens.",
+                        messageId: "wrapExpression",
                         fix(fixer) {
 
                             /*
@@ -129,7 +135,7 @@ module.exports = {
                 } else if (style === "outside" && !callExpressionWrapped) {
                     context.report({
                         node,
-                        message: "Move the invocation into the parens that contain the function.",
+                        messageId: "moveInvocation",
                         fix(fixer) {
 
                             /*

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

@@ -31,14 +31,20 @@ module.exports = {
                     {
                         type: "object",
                         properties: {
-                            before: { type: "boolean" },
-                            after: { type: "boolean" }
+                            before: { type: "boolean", default: false },
+                            after: { type: "boolean", default: true }
                         },
                         additionalProperties: false
                     }
                 ]
             }
-        ]
+        ],
+        messages: {
+            missingBefore: "Missing space before *.",
+            missingAfter: "Missing space after *.",
+            unexpectedBefore: "Unexpected space before *.",
+            unexpectedAfter: "Unexpected space after *."
+        }
     },
 
     create(context) {
@@ -70,16 +76,17 @@ module.exports = {
                 const after = leftToken.value === "*";
                 const spaceRequired = mode[side];
                 const node = after ? leftToken : rightToken;
-                const type = spaceRequired ? "Missing" : "Unexpected";
-                const message = "{{type}} space {{side}} *.";
+                let messageId = "";
+
+                if (spaceRequired) {
+                    messageId = side === "before" ? "missingBefore" : "missingAfter";
+                } else {
+                    messageId = side === "before" ? "unexpectedBefore" : "unexpectedAfter";
+                }
 
                 context.report({
                     node,
-                    message,
-                    data: {
-                        type,
-                        side
-                    },
+                    messageId,
                     fix(fixer) {
                         if (spaceRequired) {
                             if (after) {

package/lib/rules/yoda.js

@@ -169,17 +169,22 @@ module.exports = {
                 type: "object",
                 properties: {
                     exceptRange: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     onlyEquality: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
             }
         ],
 
-        fixable: "code"
+        fixable: "code",
+        messages: {
+            expected: "Expected literal to be on the {{expectedSide}} side of {{operator}}."
+        }
     },
 
     create(context) {
@@ -297,7 +302,7 @@ module.exports = {
                 ) {
                     context.report({
                         node,
-                        message: "Expected literal to be on the {{expectedSide}} side of {{operator}}.",
+                        messageId: "expected",
                         data: {
                             operator: node.operator,
                             expectedSide: always ? "left" : "right"

package/lib/rules.js

@@ -10,8 +10,8 @@
 //------------------------------------------------------------------------------
 
 const lodash = require("lodash");
-const loadRules = require("./load-rules");
 const ruleReplacements = require("../conf/replacements").rules;
+const builtInRules = require("./built-in-rules-index");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -59,8 +59,9 @@ function normalizeRule(rule) {
 class Rules {
     constructor() {
         this._rules = Object.create(null);
-
-        this.load();
+        Object.keys(builtInRules).forEach(ruleId => {
+            this.define(ruleId, builtInRules[ruleId]);
+        });
     }
 
     /**
@@ -73,37 +74,6 @@ class Rules {
         this._rules[ruleId] = normalizeRule(ruleModule);
     }
 
-    /**
-     * Loads and registers all rules from passed rules directory.
-     * @param {string} [rulesDir] Path to rules directory, may be relative. Defaults to `lib/rules`.
-     * @param {string} cwd Current working directory
-     * @returns {void}
-     */
-    load(rulesDir, cwd) {
-        const newRules = loadRules(rulesDir, cwd);
-
-        Object.keys(newRules).forEach(ruleId => {
-            this.define(ruleId, newRules[ruleId]);
-        });
-    }
-
-    /**
-     * Registers all given rules of a plugin.
-     * @param {Object} plugin The plugin object to import.
-     * @param {string} pluginName The name of the plugin without prefix (`eslint-plugin-`).
-     * @returns {void}
-     */
-    importPlugin(plugin, pluginName) {
-        if (plugin.rules) {
-            Object.keys(plugin.rules).forEach(ruleId => {
-                const qualifiedRuleId = `${pluginName}/${ruleId}`,
-                    rule = plugin.rules[ruleId];
-
-                this.define(qualifiedRuleId, rule);
-            });
-        }
-    }
-
     /**
      * Access rule handler by id (file name).
      * @param {string} ruleId Rule id (file name).

package/lib/util/ajv.js

@@ -17,6 +17,7 @@ const Ajv = require("ajv"),
 
 const ajv = new Ajv({
     meta: false,
+    useDefaults: true,
     validateSchema: false,
     missingRefs: "ignore",
     verbose: true,

package/lib/util/config-comment-parser.js

@@ -26,14 +26,14 @@ const debug = require("debug")("eslint:config-comment-parser");
 module.exports = class ConfigCommentParser {
 
     /**
-     * Parses a list of "name:boolean_value" or/and "name" options divided by comma or
+     * Parses a list of "name:string_value" or/and "name" options divided by comma or
      * whitespace. Used for "global" and "exported" comments.
      * @param {string} string The string to parse.
      * @param {Comment} comment The comment node which has the string.
-     * @returns {Object} Result map object of names and boolean values
+     * @returns {Object} Result map object of names and string values, or null values if no value was provided
      */
-    parseBooleanConfig(string, comment) {
-        debug("Parsing Boolean config");
+    parseStringConfig(string, comment) {
+        debug("Parsing String config");
 
         const items = {};
 
@@ -45,13 +45,10 @@ module.exports = class ConfigCommentParser {
                 return;
             }
 
-            // value defaults to "false" (if not provided), e.g: "foo" => ["foo", "false"]
-            const [key, value = "false"] = name.split(":");
+            // value defaults to null (if not provided), e.g: "foo" => ["foo", null]
+            const [key, value = null] = name.split(":");
 
-            items[key] = {
-                value: value === "true",
-                comment
-            };
+            items[key] = { value, comment };
         });
         return items;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "5.12.0",
+  "version": "5.14.1",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -36,53 +36,53 @@
   "bugs": "https://github.com/eslint/eslint/issues/",
   "dependencies": {
     "@babel/code-frame": "^7.0.0",
-    "ajv": "^6.5.3",
+    "ajv": "^6.9.1",
     "chalk": "^2.1.0",
     "cross-spawn": "^6.0.5",
     "debug": "^4.0.1",
-    "doctrine": "^2.1.0",
+    "doctrine": "^3.0.0",
     "eslint-scope": "^4.0.0",
     "eslint-utils": "^1.3.1",
     "eslint-visitor-keys": "^1.0.0",
-    "espree": "^5.0.0",
+    "espree": "^5.0.1",
     "esquery": "^1.0.1",
     "esutils": "^2.0.2",
-    "file-entry-cache": "^2.0.0",
+    "file-entry-cache": "^5.0.1",
     "functional-red-black-tree": "^1.0.1",
     "glob": "^7.1.2",
     "globals": "^11.7.0",
     "ignore": "^4.0.6",
     "import-fresh": "^3.0.0",
     "imurmurhash": "^0.1.4",
-    "inquirer": "^6.1.0",
+    "inquirer": "^6.2.2",
     "js-yaml": "^3.12.0",
     "json-stable-stringify-without-jsonify": "^1.0.1",
     "levn": "^0.3.0",
-    "lodash": "^4.17.5",
+    "lodash": "^4.17.11",
     "minimatch": "^3.0.4",
     "mkdirp": "^0.5.1",
     "natural-compare": "^1.4.0",
     "optionator": "^0.8.2",
     "path-is-inside": "^1.0.2",
-    "pluralize": "^7.0.0",
     "progress": "^2.0.0",
     "regexpp": "^2.0.1",
     "semver": "^5.5.1",
     "strip-ansi": "^4.0.0",
     "strip-json-comments": "^2.0.1",
-    "table": "^5.0.2",
+    "table": "^5.2.3",
     "text-table": "^0.2.0"
   },
   "devDependencies": {
-    "babel-core": "^6.26.3",
-    "babel-polyfill": "^6.26.0",
-    "babel-preset-es2015": "^6.24.1",
-    "babelify": "^8.0.0",
+    "@babel/core": "^7.2.2",
+    "@babel/polyfill": "^7.2.5",
+    "@babel/preset-env": "^7.3.1",
+    "babelify": "^10.0.0",
     "beefy": "^2.1.8",
     "brfs": "^2.0.0",
     "browserify": "^16.2.2",
     "chai": "^4.0.1",
     "cheerio": "^0.22.0",
+    "common-tags": "^1.8.0",
     "coveralls": "^3.0.1",
     "dateformat": "^3.0.3",
     "ejs": "^2.6.1",
@@ -91,26 +91,26 @@
     "eslint-plugin-rulesdir": "^0.1.0",
     "eslint-release": "^1.2.0",
     "eslint-rule-composer": "^0.3.0",
-    "eslump": "^1.6.2",
+    "eslump": "^2.0.0",
     "esprima": "^4.0.1",
     "istanbul": "^0.4.5",
     "jsdoc": "^3.5.5",
-    "karma": "^3.0.0",
-    "karma-babel-preprocessor": "^7.0.0",
+    "karma": "^3.1.4",
+    "karma-babel-preprocessor": "^8.0.0",
     "karma-chrome-launcher": "^2.2.0",
     "karma-mocha": "^1.3.0",
     "karma-mocha-reporter": "^2.2.3",
     "leche": "^2.2.3",
     "load-perf": "^0.2.0",
-    "markdownlint": "^0.11.0",
+    "markdownlint": "^0.12.0",
     "mocha": "^5.0.5",
-    "mock-fs": "^4.6.0",
+    "mock-fs": "^4.8.0",
     "npm-license": "^0.3.3",
     "proxyquire": "^2.0.1",
-    "puppeteer": "^1.9.0",
+    "puppeteer": "^1.12.2",
     "shelljs": "^0.8.2",
     "sinon": "^3.3.0",
-    "temp": "^0.8.3",
+    "temp": "^0.9.0",
     "through": "^2.3.8"
   },
   "keywords": [