eslint 5.12.0 → 5.14.1

package/lib/rules/object-shorthand.js

@@ -57,7 +57,8 @@ module.exports = {
                             type: "object",
                             properties: {
                                 avoidQuotes: {
-                                    type: "boolean"
+                                    type: "boolean",
+                                    default: false
                                 }
                             },
                             additionalProperties: false
@@ -76,13 +77,16 @@ module.exports = {
                             type: "object",
                             properties: {
                                 ignoreConstructors: {
-                                    type: "boolean"
+                                    type: "boolean",
+                                    default: false
                                 },
                                 avoidQuotes: {
-                                    type: "boolean"
+                                    type: "boolean",
+                                    default: false
                                 },
                                 avoidExplicitReturnArrows: {
-                                    type: "boolean"
+                                    type: "boolean",
+                                    default: false
                                 }
                             },
                             additionalProperties: false
@@ -255,7 +259,7 @@ module.exports = {
                     keyPrefix + keyText + sourceCode.text.slice(tokenBeforeParams.range[1], node.value.range[1])
                 );
             }
-            const arrowToken = sourceCode.getTokens(node.value).find(token => token.value === "=>");
+            const arrowToken = sourceCode.getTokenBefore(node.value.body, { filter: token => token.value === "=>" });
             const tokenBeforeArrow = sourceCode.getTokenBefore(arrowToken);
             const hasParensAroundParameters = tokenBeforeArrow.type === "Punctuator" && tokenBeforeArrow.value === ")";
             const oldParamText = sourceCode.text.slice(sourceCode.getFirstToken(node.value, node.value.async ? 1 : 0).range[0], tokenBeforeArrow.range[1]);

package/lib/rules/one-var.js

@@ -32,16 +32,20 @@ module.exports = {
                         type: "object",
                         properties: {
                             separateRequires: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: false
                             },
                             var: {
-                                enum: ["always", "never", "consecutive"]
+                                enum: ["always", "never", "consecutive"],
+                                default: "always"
                             },
                             let: {
-                                enum: ["always", "never", "consecutive"]
+                                enum: ["always", "never", "consecutive"],
+                                default: "always"
                             },
                             const: {
-                                enum: ["always", "never", "consecutive"]
+                                enum: ["always", "never", "consecutive"],
+                                default: "always"
                             }
                         },
                         additionalProperties: false
@@ -76,42 +80,16 @@ module.exports = {
             options.let = { uninitialized: mode, initialized: mode };
             options.const = { uninitialized: mode, initialized: mode };
         } else if (typeof mode === "object") { // options configuration is an object
-            if (Object.prototype.hasOwnProperty.call(mode, "separateRequires")) {
-                options.separateRequires = !!mode.separateRequires;
-            }
-            if (Object.prototype.hasOwnProperty.call(mode, "var")) {
-                options.var = { uninitialized: mode.var, initialized: mode.var };
-            }
-            if (Object.prototype.hasOwnProperty.call(mode, "let")) {
-                options.let = { uninitialized: mode.let, initialized: mode.let };
-            }
-            if (Object.prototype.hasOwnProperty.call(mode, "const")) {
-                options.const = { uninitialized: mode.const, initialized: mode.const };
-            }
+            options.separateRequires = mode.separateRequires;
+            options.var = { uninitialized: mode.var, initialized: mode.var };
+            options.let = { uninitialized: mode.let, initialized: mode.let };
+            options.const = { uninitialized: mode.const, initialized: mode.const };
             if (Object.prototype.hasOwnProperty.call(mode, "uninitialized")) {
-                if (!options.var) {
-                    options.var = {};
-                }
-                if (!options.let) {
-                    options.let = {};
-                }
-                if (!options.const) {
-                    options.const = {};
-                }
                 options.var.uninitialized = mode.uninitialized;
                 options.let.uninitialized = mode.uninitialized;
                 options.const.uninitialized = mode.uninitialized;
             }
             if (Object.prototype.hasOwnProperty.call(mode, "initialized")) {
-                if (!options.var) {
-                    options.var = {};
-                }
-                if (!options.let) {
-                    options.let = {};
-                }
-                if (!options.const) {
-                    options.const = {};
-                }
                 options.var.initialized = mode.initialized;
                 options.let.initialized = mode.initialized;
                 options.const.initialized = mode.initialized;
@@ -257,7 +235,9 @@ module.exports = {
 
             if (currentOptions.uninitialized === MODE_ALWAYS && currentOptions.initialized === MODE_ALWAYS) {
                 if (currentScope.uninitialized || currentScope.initialized) {
-                    return false;
+                    if (!hasRequires) {
+                        return false;
+                    }
                 }
             }
 
@@ -268,7 +248,9 @@ module.exports = {
             }
             if (declarationCounts.initialized > 0) {
                 if (currentOptions.initialized === MODE_ALWAYS && currentScope.initialized) {
-                    return false;
+                    if (!hasRequires) {
+                        return false;
+                    }
                 }
             }
             if (currentScope.required && hasRequires) {
@@ -340,7 +322,11 @@ module.exports = {
                  *      y`
                  *      ^ afterComma
                  */
-                if (afterComma.loc.start.line > tokenAfterDeclarator.loc.end.line || afterComma.type === "Line" || afterComma.type === "Block") {
+                if (
+                    afterComma.loc.start.line > tokenAfterDeclarator.loc.end.line ||
+                    afterComma.type === "Line" ||
+                    afterComma.type === "Block"
+                ) {
                     let lastComment = afterComma;
 
                     while (lastComment.type === "Line" || lastComment.type === "Block") {
@@ -349,7 +335,7 @@ module.exports = {
 
                     return fixer.replaceTextRange(
                         [tokenAfterDeclarator.range[0], lastComment.range[0]],
-                        `;\n${sourceCode.text.slice(tokenAfterDeclarator.range[1], lastComment.range[0])}\n${declaration.kind} `
+                        `;${sourceCode.text.slice(tokenAfterDeclarator.range[1], lastComment.range[0])}${declaration.kind} `
                     );
                 }
 

package/lib/rules/operator-assignment.js

@@ -104,7 +104,11 @@ module.exports = {
             }
         ],
 
-        fixable: "code"
+        fixable: "code",
+        messages: {
+            replaced: "Assignment can be replaced with operator assignment.",
+            unexpected: "Unexpected operator assignment shorthand."
+        }
     },
 
     create(context) {
@@ -138,7 +142,7 @@ module.exports = {
                 if (same(left, expr.left)) {
                     context.report({
                         node,
-                        message: "Assignment can be replaced with operator assignment.",
+                        messageId: "replaced",
                         fix(fixer) {
                             if (canBeFixed(left)) {
                                 const equalsToken = getOperatorToken(node);
@@ -160,7 +164,7 @@ module.exports = {
                      */
                     context.report({
                         node,
-                        message: "Assignment can be replaced with operator assignment."
+                        messageId: "replaced"
                     });
                 }
             }
@@ -175,7 +179,7 @@ module.exports = {
             if (node.operator !== "=") {
                 context.report({
                     node,
-                    message: "Unexpected operator assignment shorthand.",
+                    messageId: "unexpected",
                     fix(fixer) {
                         if (canBeFixed(node.left)) {
                             const operatorToken = getOperatorToken(node);

package/lib/rules/padded-blocks.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../util/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -45,32 +51,45 @@ module.exports = {
                         minProperties: 1
                     }
                 ]
+            },
+            {
+                type: "object",
+                properties: {
+                    allowSingleLineBlocks: {
+                        type: "boolean"
+                    }
+                }
             }
         ]
     },
 
     create(context) {
         const options = {};
-        const config = context.options[0] || "always";
+        const typeOptions = context.options[0] || "always";
+        const exceptOptions = context.options[1] || {};
 
-        if (typeof config === "string") {
-            const shouldHavePadding = config === "always";
+        if (typeof typeOptions === "string") {
+            const shouldHavePadding = typeOptions === "always";
 
             options.blocks = shouldHavePadding;
             options.switches = shouldHavePadding;
             options.classes = shouldHavePadding;
         } else {
-            if (Object.prototype.hasOwnProperty.call(config, "blocks")) {
-                options.blocks = config.blocks === "always";
+            if (Object.prototype.hasOwnProperty.call(typeOptions, "blocks")) {
+                options.blocks = typeOptions.blocks === "always";
             }
-            if (Object.prototype.hasOwnProperty.call(config, "switches")) {
-                options.switches = config.switches === "always";
+            if (Object.prototype.hasOwnProperty.call(typeOptions, "switches")) {
+                options.switches = typeOptions.switches === "always";
             }
-            if (Object.prototype.hasOwnProperty.call(config, "classes")) {
-                options.classes = config.classes === "always";
+            if (Object.prototype.hasOwnProperty.call(typeOptions, "classes")) {
+                options.classes = typeOptions.classes === "always";
             }
         }
 
+        if (Object.prototype.hasOwnProperty.call(exceptOptions, "allowSingleLineBlocks")) {
+            options.allowSingleLineBlocks = exceptOptions.allowSingleLineBlocks === true;
+        }
+
         const ALWAYS_MESSAGE = "Block must be padded by blank lines.",
             NEVER_MESSAGE = "Block must not be padded by blank lines.";
 
@@ -177,6 +196,10 @@ module.exports = {
                 blockHasTopPadding = isPaddingBetweenTokens(tokenBeforeFirst, firstBlockToken),
                 blockHasBottomPadding = isPaddingBetweenTokens(lastBlockToken, tokenAfterLast);
 
+            if (options.allowSingleLineBlocks && astUtils.isTokenOnSameLine(tokenBeforeFirst, tokenAfterLast)) {
+                return;
+            }
+
             if (requirePaddingFor(node)) {
                 if (!blockHasTopPadding) {
                     context.report({

package/lib/rules/prefer-arrow-callback.js

@@ -146,10 +146,12 @@ module.exports = {
                 type: "object",
                 properties: {
                     allowNamedFunctions: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     allowUnboundThis: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     }
                 },
                 additionalProperties: false

package/lib/rules/prefer-const.js

@@ -345,12 +345,15 @@ module.exports = {
             {
                 type: "object",
                 properties: {
-                    destructuring: { enum: ["any", "all"] },
-                    ignoreReadBeforeAssign: { type: "boolean" }
+                    destructuring: { enum: ["any", "all"], default: "any" },
+                    ignoreReadBeforeAssign: { type: "boolean", default: false }
                 },
                 additionalProperties: false
             }
-        ]
+        ],
+        messages: {
+            useConst: "'{{name}}' is never reassigned. Use 'const' instead."
+        }
     },
 
     create(context) {
@@ -445,7 +448,7 @@ module.exports = {
                 nodesToReport.forEach(node => {
                     context.report({
                         node,
-                        message: "'{{name}}' is never reassigned. Use 'const' instead.",
+                        messageId: "useConst",
                         data: node,
                         fix: shouldFix ? fixer => fixer.replaceText(sourceCode.getFirstToken(varDeclParent), "const") : null
                     });

package/lib/rules/prefer-destructuring.js

@@ -19,6 +19,8 @@ module.exports = {
             url: "https://eslint.org/docs/rules/prefer-destructuring"
         },
 
+        fixable: "code",
+
         schema: [
             {
 
@@ -34,10 +36,12 @@ module.exports = {
                                 type: "object",
                                 properties: {
                                     array: {
-                                        type: "boolean"
+                                        type: "boolean",
+                                        default: true
                                     },
                                     object: {
-                                        type: "boolean"
+                                        type: "boolean",
+                                        default: true
                                     }
                                 },
                                 additionalProperties: false
@@ -46,10 +50,12 @@ module.exports = {
                                 type: "object",
                                 properties: {
                                     array: {
-                                        type: "boolean"
+                                        type: "boolean",
+                                        default: true
                                     },
                                     object: {
-                                        type: "boolean"
+                                        type: "boolean",
+                                        default: true
                                     }
                                 },
                                 additionalProperties: false
@@ -61,10 +67,12 @@ module.exports = {
                         type: "object",
                         properties: {
                             array: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: true
                             },
                             object: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: true
                             }
                         },
                         additionalProperties: false
@@ -75,7 +83,8 @@ module.exports = {
                 type: "object",
                 properties: {
                     enforceForRenamedProperties: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
@@ -130,10 +139,55 @@ module.exports = {
          *
          * @param {ASTNode} reportNode the node to report
          * @param {string} type the type of destructuring that should have been done
+         * @param {Function|null} fix the fix function or null to pass to context.report
          * @returns {void}
          */
-        function report(reportNode, type) {
-            context.report({ node: reportNode, message: "Use {{type}} destructuring.", data: { type } });
+        function report(reportNode, type, fix) {
+            context.report({
+                node: reportNode,
+                message: "Use {{type}} destructuring.",
+                data: { type },
+                fix
+            });
+        }
+
+        /**
+         * Determines if a node should be fixed into object destructuring
+         *
+         * The fixer only fixes the simplest case of object destructuring,
+         * like: `let x = a.x`;
+         *
+         * Assignment expression is not fixed.
+         * Array destructuring is not fixed.
+         * Renamed property is not fixed.
+         *
+         * @param {ASTNode} node the the node to evaluate
+         * @returns {boolean} whether or not the node should be fixed
+         */
+        function shouldFix(node) {
+            return node.type === "VariableDeclarator" &&
+                node.id.type === "Identifier" &&
+                node.init.type === "MemberExpression" &&
+                node.id.name === node.init.property.name;
+        }
+
+        /**
+         * Fix a node into object destructuring.
+         * This function only handles the simplest case of object destructuring,
+         * see {@link shouldFix}.
+         *
+         * @param {SourceCodeFixer} fixer the fixer object
+         * @param {ASTNode} node the node to be fixed.
+         * @returns {Object} a fix for the node
+         */
+        function fixIntoObjectDestructuring(fixer, node) {
+            const rightNode = node.init;
+            const sourceCode = context.getSourceCode();
+
+            return fixer.replaceText(
+                node,
+                `{${rightNode.property.name}} = ${sourceCode.getText(rightNode.object)}`
+            );
         }
 
         /**
@@ -155,13 +209,17 @@ module.exports = {
 
             if (isArrayIndexAccess(rightNode)) {
                 if (shouldCheck(reportNode.type, "array")) {
-                    report(reportNode, "array");
+                    report(reportNode, "array", null);
                 }
                 return;
             }
 
+            const fix = shouldFix(reportNode)
+                ? fixer => fixIntoObjectDestructuring(fixer, reportNode)
+                : null;
+
             if (shouldCheck(reportNode.type, "object") && enforceForRenamedProperties) {
-                report(reportNode, "object");
+                report(reportNode, "object", fix);
                 return;
             }
 
@@ -172,7 +230,7 @@ module.exports = {
                     (property.type === "Literal" && leftNode.name === property.value) ||
                     (property.type === "Identifier" && leftNode.name === property.name && !rightNode.computed)
                 ) {
-                    report(reportNode, "object");
+                    report(reportNode, "object", fix);
                 }
             }
         }

package/lib/rules/prefer-promise-reject-errors.js

@@ -27,7 +27,7 @@ module.exports = {
             {
                 type: "object",
                 properties: {
-                    allowEmptyReject: { type: "boolean" }
+                    allowEmptyReject: { type: "boolean", default: false }
                 },
                 additionalProperties: false
             }

package/lib/rules/prefer-spread.js

@@ -59,7 +59,7 @@ module.exports = {
         },
 
         schema: [],
-        fixable: "code"
+        fixable: null
     },
 
     create(context) {
@@ -78,18 +78,7 @@ module.exports = {
                 if (isValidThisArg(expectedThis, thisArg, sourceCode)) {
                     context.report({
                         node,
-                        message: "Use the spread operator instead of '.apply()'.",
-                        fix(fixer) {
-                            if (expectedThis && expectedThis.type !== "Identifier") {
-
-                                // Don't fix cases where the `this` value could be a computed expression.
-                                return null;
-                            }
-
-                            const propertyDot = sourceCode.getFirstTokenBetween(applied, node.callee.property, token => token.value === ".");
-
-                            return fixer.replaceTextRange([propertyDot.range[0], node.range[1]], `(...${sourceCode.getText(node.arguments[1])})`);
-                        }
+                        message: "Use the spread operator instead of '.apply()'."
                     });
                 }
             }

package/lib/rules/quote-props.js

@@ -32,7 +32,8 @@ module.exports = {
                     type: "array",
                     items: [
                         {
-                            enum: ["always", "as-needed", "consistent", "consistent-as-needed"]
+                            enum: ["always", "as-needed", "consistent", "consistent-as-needed"],
+                            default: "always"
                         }
                     ],
                     minItems: 0,
@@ -42,19 +43,23 @@ module.exports = {
                     type: "array",
                     items: [
                         {
-                            enum: ["always", "as-needed", "consistent", "consistent-as-needed"]
+                            enum: ["always", "as-needed", "consistent", "consistent-as-needed"],
+                            default: "always"
                         },
                         {
                             type: "object",
                             properties: {
                                 keywords: {
-                                    type: "boolean"
+                                    type: "boolean",
+                                    default: false
                                 },
                                 unnecessary: {
-                                    type: "boolean"
+                                    type: "boolean",
+                                    default: true
                                 },
                                 numbers: {
-                                    type: "boolean"
+                                    type: "boolean",
+                                    default: false
                                 }
                             },
                             additionalProperties: false

package/lib/rules/quotes.js

@@ -100,10 +100,12 @@ module.exports = {
                         type: "object",
                         properties: {
                             avoidEscape: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: false
                             },
                             allowTemplateLiterals: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: false
                             }
                         },
                         additionalProperties: false

package/lib/rules/require-jsdoc.js

@@ -23,22 +23,28 @@ module.exports = {
                         type: "object",
                         properties: {
                             ClassDeclaration: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: false
                             },
                             MethodDefinition: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: false
                             },
                             FunctionDeclaration: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: true
                             },
                             ArrowFunctionExpression: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: false
                             },
                             FunctionExpression: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: false
                             }
                         },
-                        additionalProperties: false
+                        additionalProperties: false,
+                        default: {}
                     }
                 },
                 additionalProperties: false
@@ -58,7 +64,7 @@ module.exports = {
             ArrowFunctionExpression: false,
             FunctionExpression: false
         };
-        const options = Object.assign(DEFAULT_OPTIONS, context.options[0] && context.options[0].require || {});
+        const options = Object.assign(DEFAULT_OPTIONS, context.options[0] && context.options[0].require);
 
         /**
          * Report the error message

package/lib/rules/semi-spacing.js

@@ -29,10 +29,12 @@ module.exports = {
                 type: "object",
                 properties: {
                     before: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     after: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     }
                 },
                 additionalProperties: false
@@ -48,12 +50,8 @@ module.exports = {
             requireSpaceAfter = true;
 
         if (typeof config === "object") {
-            if (Object.prototype.hasOwnProperty.call(config, "before")) {
-                requireSpaceBefore = config.before;
-            }
-            if (Object.prototype.hasOwnProperty.call(config, "after")) {
-                requireSpaceAfter = config.after;
-            }
+            requireSpaceBefore = config.before;
+            requireSpaceAfter = config.after;
         }
 
         /**

package/lib/rules/semi.js

@@ -40,7 +40,8 @@ module.exports = {
                             type: "object",
                             properties: {
                                 beforeStatementContinuationChars: {
-                                    enum: ["always", "any", "never"]
+                                    enum: ["always", "any", "never"],
+                                    default: "any"
                                 }
                             },
                             additionalProperties: false
@@ -58,7 +59,7 @@ module.exports = {
                         {
                             type: "object",
                             properties: {
-                                omitLastInOneLineBlock: { type: "boolean" }
+                                omitLastInOneLineBlock: { type: "boolean", default: false }
                             },
                             additionalProperties: false
                         }
@@ -75,8 +76,8 @@ module.exports = {
         const OPT_OUT_PATTERN = /^[-[(/+`]/; // One of [(/+-`
         const options = context.options[1];
         const never = context.options[0] === "never";
-        const exceptOneLine = Boolean(options && options.omitLastInOneLineBlock);
-        const beforeStatementContinuationChars = (options && options.beforeStatementContinuationChars) || "any";
+        const exceptOneLine = options && options.omitLastInOneLineBlock;
+        const beforeStatementContinuationChars = options && options.beforeStatementContinuationChars;
         const sourceCode = context.getSourceCode();
 
         //--------------------------------------------------------------------------