eslint 7.0.0-alpha.1 → 7.0.0

package/lib/init/config-file.js

@@ -45,7 +45,7 @@ function sortByKey(a, b) {
 function writeJSONConfigFile(config, filePath) {
     debug(`Writing JSON config file: ${filePath}`);
 
-    const content = stringify(config, { cmp: sortByKey, space: 4 });
+    const content = `${stringify(config, { cmp: sortByKey, space: 4 })}\n`;
 
     fs.writeFileSync(filePath, content, "utf8");
 }
@@ -80,7 +80,7 @@ function writeJSConfigFile(config, filePath) {
     debug(`Writing JS config file: ${filePath}`);
 
     let contentToWrite;
-    const stringifiedContent = `module.exports = ${stringify(config, { cmp: sortByKey, space: 4 })};`;
+    const stringifiedContent = `module.exports = ${stringify(config, { cmp: sortByKey, space: 4 })};\n`;
 
     try {
         const { CLIEngine } = require("../cli-engine");

package/lib/init/config-initializer.js

@@ -15,6 +15,7 @@ const util = require("util"),
     inquirer = require("inquirer"),
     ProgressBar = require("progress"),
     semver = require("semver"),
+    espree = require("espree"),
     recConfig = require("../../conf/eslint-recommended"),
     ConfigOps = require("../shared/config-ops"),
     log = require("../shared/logging"),
@@ -31,8 +32,6 @@ const debug = require("debug")("eslint:config-initializer");
 // Private
 //------------------------------------------------------------------------------
 
-const DEFAULT_ECMA_VERSION = 2018;
-
 /* istanbul ignore next: hard to test fs function */
 /**
  * Create .eslintrc file in the current working directory
@@ -265,8 +264,7 @@ function processAnswers(answers) {
         extends: []
     };
 
-    // set the latest ECMAScript version
-    config.parserOptions.ecmaVersion = DEFAULT_ECMA_VERSION;
+    config.parserOptions.ecmaVersion = espree.latestEcmaVersion;
     config.env.es6 = true;
     config.globals = {
         Atomics: "readonly",

package/lib/init/source-code-utils.js

@@ -23,7 +23,7 @@ const { CLIEngine } = require("../cli-engine");
  * TODO1: Expose the API that enumerates target files.
  * TODO2: Extract the creation logic of `SourceCode` from `Linter` class.
  */
-const { getCLIEngineInternalSlots } = require("../cli-engine/cli-engine"); // eslint-disable-line no-restricted-modules
+const { getCLIEngineInternalSlots } = require("../cli-engine/cli-engine"); // eslint-disable-line node/no-restricted-require
 
 const debug = require("debug")("eslint:source-code-utils");
 
@@ -97,7 +97,7 @@ function getSourceCodeOfFiles(patterns, options, callback) {
             sourceCodes[filename] = sourceCode;
         }
         if (callback) {
-            callback(filenames.length); // eslint-disable-line callback-return
+            callback(filenames.length); // eslint-disable-line node/callback-return
         }
     });
 

package/lib/linter/node-event-generator.js

@@ -159,8 +159,8 @@ function tryParseSelector(rawSelector) {
     try {
         return esquery.parse(rawSelector.replace(/:exit$/u, ""));
     } catch (err) {
-        if (typeof err.offset === "number") {
-            throw new SyntaxError(`Syntax error in selector "${rawSelector}" at position ${err.offset}: ${err.message}`);
+        if (err.location && err.location.start && typeof err.location.start.offset === "number") {
+            throw new SyntaxError(`Syntax error in selector "${rawSelector}" at position ${err.location.start.offset}: ${err.message}`);
         }
         throw err;
     }

package/lib/options.js

@@ -46,7 +46,6 @@ module.exports = optionator({
         {
             option: "ext",
             type: "[String]",
-            default: ".js",
             description: "Specify JavaScript file extensions"
         },
         {

package/lib/rule-tester/rule-tester.js

@@ -45,16 +45,20 @@ const
     path = require("path"),
     util = require("util"),
     lodash = require("lodash"),
+    Traverser = require("../../lib/shared/traverser"),
     { getRuleOptionsSchema, validate } = require("../shared/config-validator"),
     { Linter, SourceCodeFixer, interpolate } = require("../linter");
 
 const ajv = require("../shared/ajv")({ strictDefaults: true });
 
+const espreePath = require.resolve("espree");
 
 //------------------------------------------------------------------------------
 // Typedefs
 //------------------------------------------------------------------------------
 
+/** @typedef {import("../shared/types").Parser} Parser */
+
 /**
  * A test case that is expected to pass lint.
  * @typedef {Object} ValidTestCase
@@ -119,6 +123,33 @@ const RuleTesterParameters = [
     "output"
 ];
 
+/*
+ * All allowed property names in error objects.
+ */
+const errorObjectParameters = new Set([
+    "message",
+    "messageId",
+    "data",
+    "type",
+    "line",
+    "column",
+    "endLine",
+    "endColumn",
+    "suggestions"
+]);
+const friendlyErrorObjectParameterList = `[${[...errorObjectParameters].map(key => `'${key}'`).join(", ")}]`;
+
+/*
+ * All allowed property names in suggestion objects.
+ */
+const suggestionObjectParameters = new Set([
+    "desc",
+    "messageId",
+    "data",
+    "output"
+]);
+const friendlySuggestionObjectParameterList = `[${[...suggestionObjectParameters].map(key => `'${key}'`).join(", ")}]`;
+
 const hasOwnProperty = Function.call.bind(Object.hasOwnProperty);
 
 /**
@@ -179,6 +210,70 @@ function sanitize(text) {
     );
 }
 
+/**
+ * Define `start`/`end` properties as throwing error.
+ * @param {string} objName Object name used for error messages.
+ * @param {ASTNode} node The node to define.
+ * @returns {void}
+ */
+function defineStartEndAsError(objName, node) {
+    Object.defineProperties(node, {
+        start: {
+            get() {
+                throw new Error(`Use ${objName}.range[0] instead of ${objName}.start`);
+            },
+            configurable: true,
+            enumerable: false
+        },
+        end: {
+            get() {
+                throw new Error(`Use ${objName}.range[1] instead of ${objName}.end`);
+            },
+            configurable: true,
+            enumerable: false
+        }
+    });
+}
+
+/**
+ * Define `start`/`end` properties of all nodes of the given AST as throwing error.
+ * @param {ASTNode} ast The root node to errorize `start`/`end` properties.
+ * @param {Object} [visitorKeys] Visitor keys to be used for traversing the given ast.
+ * @returns {void}
+ */
+function defineStartEndAsErrorInTree(ast, visitorKeys) {
+    Traverser.traverse(ast, { visitorKeys, enter: defineStartEndAsError.bind(null, "node") });
+    ast.tokens.forEach(defineStartEndAsError.bind(null, "token"));
+    ast.comments.forEach(defineStartEndAsError.bind(null, "token"));
+}
+
+/**
+ * Wraps the given parser in order to intercept and modify return values from the `parse` and `parseForESLint` methods, for test purposes.
+ * In particular, to modify ast nodes, tokens and comments to throw on access to their `start` and `end` properties.
+ * @param {Parser} parser Parser object.
+ * @returns {Parser} Wrapped parser object.
+ */
+function wrapParser(parser) {
+    if (typeof parser.parseForESLint === "function") {
+        return {
+            parseForESLint(...args) {
+                const ret = parser.parseForESLint(...args);
+
+                defineStartEndAsErrorInTree(ret.ast, ret.visitorKeys);
+                return ret;
+            }
+        };
+    }
+    return {
+        parse(...args) {
+            const ast = parser.parse(...args);
+
+            defineStartEndAsErrorInTree(ast);
+            return ast;
+        }
+    };
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -423,9 +518,12 @@ class RuleTester {
 
             if (typeof config.parser === "string") {
                 assert(path.isAbsolute(config.parser), "Parsers provided as strings to RuleTester must be absolute paths");
-                linter.defineParser(config.parser, require(config.parser));
+            } else {
+                config.parser = espreePath;
             }
 
+            linter.defineParser(config.parser, wrapParser(require(config.parser)));
+
             if (schema) {
                 ajv.validateSchema(schema);
 
@@ -456,20 +554,21 @@ class RuleTester {
 
             // Verify the code.
             const messages = linter.verify(code, config, filename);
+            const fatalErrorMessage = messages.find(m => m.fatal);
 
-            // Ignore syntax errors for backward compatibility if `errors` is a number.
-            if (typeof item.errors !== "number") {
-                const errorMessage = messages.find(m => m.fatal);
-
-                assert(!errorMessage, `A fatal parsing error occurred: ${errorMessage && errorMessage.message}`);
-            }
+            assert(!fatalErrorMessage, `A fatal parsing error occurred: ${fatalErrorMessage && fatalErrorMessage.message}`);
 
             // Verify if autofix makes a syntax error or not.
             if (messages.some(m => m.fix)) {
                 output = SourceCodeFixer.applyFixes(code, messages).output;
                 const errorMessageInFix = linter.verify(output, config, filename).find(m => m.fatal);
 
-                assert(!errorMessageInFix, `A fatal parsing error occurred in autofix: ${errorMessageInFix && errorMessageInFix.message}`);
+                assert(!errorMessageInFix, [
+                    "A fatal parsing error occurred in autofix.",
+                    `Error: ${errorMessageInFix && errorMessageInFix.message}`,
+                    "Autofix output:",
+                    output
+                ].join("\n"));
             } else {
                 output = code;
             }
@@ -545,10 +644,12 @@ class RuleTester {
             assert.ok(item.errors || item.errors === 0,
                 `Did not specify errors for an invalid test of ${ruleName}`);
 
+            const ruleHasMetaMessages = hasOwnProperty(rule, "meta") && hasOwnProperty(rule.meta, "messages");
+            const friendlyIDList = ruleHasMetaMessages ? `[${Object.keys(rule.meta.messages).map(key => `'${key}'`).join(", ")}]` : null;
+
             const result = runRuleForItem(item);
             const messages = result.messages;
 
-
             if (typeof item.errors === "number") {
                 assert.strictEqual(messages.length, item.errors, util.format("Should have %d error%s but had %d: %s",
                     item.errors, item.errors === 1 ? "" : "s", messages.length, util.inspect(messages)));
@@ -573,25 +674,31 @@ class RuleTester {
 
                         // Just an error message.
                         assertMessageMatches(message.message, error);
-                    } else if (typeof error === "object") {
+                    } else if (typeof error === "object" && error !== null) {
 
                         /*
                          * Error object.
                          * This may have a message, messageId, data, node type, line, and/or
                          * column.
                          */
+
+                        Object.keys(error).forEach(propertyName => {
+                            assert.ok(
+                                errorObjectParameters.has(propertyName),
+                                `Invalid error property name '${propertyName}'. Expected one of ${friendlyErrorObjectParameterList}.`
+                            );
+                        });
+
                         if (hasOwnProperty(error, "message")) {
                             assert.ok(!hasOwnProperty(error, "messageId"), "Error should not specify both 'message' and a 'messageId'.");
                             assert.ok(!hasOwnProperty(error, "data"), "Error should not specify both 'data' and 'message'.");
                             assertMessageMatches(message.message, error.message);
                         } else if (hasOwnProperty(error, "messageId")) {
                             assert.ok(
-                                hasOwnProperty(rule, "meta") && hasOwnProperty(rule.meta, "messages"),
+                                ruleHasMetaMessages,
                                 "Error can not use 'messageId' if rule under test doesn't define 'meta.messages'."
                             );
                             if (!hasOwnProperty(rule.meta.messages, error.messageId)) {
-                                const friendlyIDList = `[${Object.keys(rule.meta.messages).map(key => `'${key}'`).join(", ")}]`;
-
                                 assert(false, `Invalid messageId '${error.messageId}'. Expected one of ${friendlyIDList}.`);
                             }
                             assert.strictEqual(
@@ -654,20 +761,62 @@ class RuleTester {
                                 assert.strictEqual(message.suggestions.length, error.suggestions.length, `Error should have ${error.suggestions.length} suggestions. Instead found ${message.suggestions.length} suggestions`);
 
                                 error.suggestions.forEach((expectedSuggestion, index) => {
+                                    assert.ok(
+                                        typeof expectedSuggestion === "object" && expectedSuggestion !== null,
+                                        "Test suggestion in 'suggestions' array must be an object."
+                                    );
+                                    Object.keys(expectedSuggestion).forEach(propertyName => {
+                                        assert.ok(
+                                            suggestionObjectParameters.has(propertyName),
+                                            `Invalid suggestion property name '${propertyName}'. Expected one of ${friendlySuggestionObjectParameterList}.`
+                                        );
+                                    });
+
                                     const actualSuggestion = message.suggestions[index];
+                                    const suggestionPrefix = `Error Suggestion at index ${index} :`;
+
+                                    if (hasOwnProperty(expectedSuggestion, "desc")) {
+                                        assert.ok(
+                                            !hasOwnProperty(expectedSuggestion, "data"),
+                                            `${suggestionPrefix} Test should not specify both 'desc' and 'data'.`
+                                        );
+                                        assert.strictEqual(
+                                            actualSuggestion.desc,
+                                            expectedSuggestion.desc,
+                                            `${suggestionPrefix} desc should be "${expectedSuggestion.desc}" but got "${actualSuggestion.desc}" instead.`
+                                        );
+                                    }
 
-                                    /**
-                                     * Tests equality of a suggestion key if that key is defined in the expected output.
-                                     * @param {string} key Key to validate from the suggestion object
-                                     * @returns {void}
-                                     */
-                                    function assertSuggestionKeyEquals(key) {
-                                        if (hasOwnProperty(expectedSuggestion, key)) {
-                                            assert.deepStrictEqual(actualSuggestion[key], expectedSuggestion[key], `Error suggestion at index: ${index} should have desc of: "${actualSuggestion[key]}"`);
+                                    if (hasOwnProperty(expectedSuggestion, "messageId")) {
+                                        assert.ok(
+                                            ruleHasMetaMessages,
+                                            `${suggestionPrefix} Test can not use 'messageId' if rule under test doesn't define 'meta.messages'.`
+                                        );
+                                        assert.ok(
+                                            hasOwnProperty(rule.meta.messages, expectedSuggestion.messageId),
+                                            `${suggestionPrefix} Test has invalid messageId '${expectedSuggestion.messageId}', the rule under test allows only one of ${friendlyIDList}.`
+                                        );
+                                        assert.strictEqual(
+                                            actualSuggestion.messageId,
+                                            expectedSuggestion.messageId,
+                                            `${suggestionPrefix} messageId should be '${expectedSuggestion.messageId}' but got '${actualSuggestion.messageId}' instead.`
+                                        );
+                                        if (hasOwnProperty(expectedSuggestion, "data")) {
+                                            const unformattedMetaMessage = rule.meta.messages[expectedSuggestion.messageId];
+                                            const rehydratedDesc = interpolate(unformattedMetaMessage, expectedSuggestion.data);
+
+                                            assert.strictEqual(
+                                                actualSuggestion.desc,
+                                                rehydratedDesc,
+                                                `${suggestionPrefix} Hydrated test desc "${rehydratedDesc}" does not match received desc "${actualSuggestion.desc}".`
+                                            );
                                         }
+                                    } else {
+                                        assert.ok(
+                                            !hasOwnProperty(expectedSuggestion, "data"),
+                                            `${suggestionPrefix} Test must specify 'messageId' if 'data' is used.`
+                                        );
                                     }
-                                    assertSuggestionKeyEquals("desc");
-                                    assertSuggestionKeyEquals("messageId");
 
                                     if (hasOwnProperty(expectedSuggestion, "output")) {
                                         const codeWithAppliedSuggestion = SourceCodeFixer.applyFixes(item.code, [actualSuggestion]).output;
@@ -695,6 +844,12 @@ class RuleTester {
                 } else {
                     assert.strictEqual(result.output, item.output, "Output is incorrect.");
                 }
+            } else {
+                assert.strictEqual(
+                    result.output,
+                    item.code,
+                    "The rule fixed the code. Please add 'output' property."
+                );
             }
 
             assertASTDidntChange(result.beforeAST, result.afterAST);

package/lib/rules/accessor-pairs.js

@@ -171,7 +171,7 @@ module.exports = {
                 },
                 enforceForClassMembers: {
                     type: "boolean",
-                    default: false
+                    default: true
                 }
             },
             additionalProperties: false
@@ -190,7 +190,7 @@ module.exports = {
         const config = context.options[0] || {};
         const checkGetWithoutSet = config.getWithoutSet === true;
         const checkSetWithoutGet = config.setWithoutGet !== false;
-        const enforceForClassMembers = config.enforceForClassMembers === true;
+        const enforceForClassMembers = config.enforceForClassMembers !== false;
         const sourceCode = context.getSourceCode();
 
         /**

package/lib/rules/array-callback-return.js

@@ -29,22 +29,6 @@ function isReachable(segment) {
     return segment.reachable;
 }
 
-/**
- * Gets a readable location.
- *
- * - FunctionExpression -> the function name or `function` keyword.
- * - ArrowFunctionExpression -> `=>` token.
- * @param {ASTNode} node A function node to get.
- * @param {SourceCode} sourceCode A source code to get tokens.
- * @returns {ASTNode|Token} The node or the token of a location.
- */
-function getLocation(node, sourceCode) {
-    if (node.type === "ArrowFunctionExpression") {
-        return sourceCode.getTokenBefore(node.body);
-    }
-    return node.id || node;
-}
-
 /**
  * Checks a given node is a MemberExpression node which has the specified name's
  * property.
@@ -179,6 +163,7 @@ module.exports = {
     create(context) {
 
         const options = context.options[0] || { allowImplicit: false, checkForEach: false };
+        const sourceCode = context.getSourceCode();
 
         let funcInfo = {
             arrayMethodName: null,
@@ -217,12 +202,12 @@ module.exports = {
             }
 
             if (messageId) {
-                let name = astUtils.getFunctionNameWithKind(funcInfo.node);
+                let name = astUtils.getFunctionNameWithKind(node);
 
                 name = messageId === "expectedNoReturnValue" ? lodash.upperFirst(name) : name;
                 context.report({
                     node,
-                    loc: getLocation(node, context.getSourceCode()).loc.start,
+                    loc: astUtils.getFunctionHeadLoc(node, sourceCode),
                     messageId,
                     data: { name }
                 });

package/lib/rules/arrow-body-style.js

@@ -91,7 +91,7 @@ module.exports = {
          * @returns {Token} The found closing parenthesis token.
          */
         function findClosingParen(token) {
-            let node = sourceCode.getNodeByRangeIndex(token.range[1]);
+            let node = sourceCode.getNodeByRangeIndex(token.range[0]);
 
             while (!astUtils.isParenthesised(sourceCode, node)) {
                 node = node.parent;
@@ -206,24 +206,35 @@ module.exports = {
                         fix(fixer) {
                             const fixes = [];
                             const arrowToken = sourceCode.getTokenBefore(arrowBody, astUtils.isArrowToken);
-                            const firstBodyToken = sourceCode.getTokenAfter(arrowToken);
-                            const lastBodyToken = sourceCode.getLastToken(node);
+                            const [firstTokenAfterArrow, secondTokenAfterArrow] = sourceCode.getTokensAfter(arrowToken, { count: 2 });
+                            const lastToken = sourceCode.getLastToken(node);
                             const isParenthesisedObjectLiteral =
-                                astUtils.isOpeningParenToken(firstBodyToken) &&
-                                astUtils.isOpeningBraceToken(sourceCode.getTokenAfter(firstBodyToken));
-
-                            // Wrap the value by a block and a return statement.
-                            fixes.push(
-                                fixer.insertTextBefore(firstBodyToken, "{return "),
-                                fixer.insertTextAfter(lastBodyToken, "}")
-                            );
+                                astUtils.isOpeningParenToken(firstTokenAfterArrow) &&
+                                astUtils.isOpeningBraceToken(secondTokenAfterArrow);
 
                             // If the value is object literal, remove parentheses which were forced by syntax.
                             if (isParenthesisedObjectLiteral) {
-                                fixes.push(
-                                    fixer.remove(firstBodyToken),
-                                    fixer.remove(findClosingParen(firstBodyToken))
-                                );
+                                const openingParenToken = firstTokenAfterArrow;
+                                const openingBraceToken = secondTokenAfterArrow;
+
+                                if (astUtils.isTokenOnSameLine(openingParenToken, openingBraceToken)) {
+                                    fixes.push(fixer.replaceText(openingParenToken, "{return "));
+                                } else {
+
+                                    // Avoid ASI
+                                    fixes.push(
+                                        fixer.replaceText(openingParenToken, "{"),
+                                        fixer.insertTextBefore(openingBraceToken, "return ")
+                                    );
+                                }
+
+                                // Closing paren for the object doesn't have to be lastToken, e.g.: () => ({}).foo()
+                                fixes.push(fixer.remove(findClosingParen(openingBraceToken)));
+                                fixes.push(fixer.insertTextAfter(lastToken, "}"));
+
+                            } else {
+                                fixes.push(fixer.insertTextBefore(firstTokenAfterArrow, "{return "));
+                                fixes.push(fixer.insertTextAfter(lastToken, "}"));
                             }
 
                             return fixes;

package/lib/rules/callback-return.js

@@ -10,6 +10,10 @@
 
 module.exports = {
     meta: {
+        deprecated: true,
+
+        replacedBy: ["node/callback-return"],
+
         type: "suggestion",
 
         docs: {

package/lib/rules/camelcase.js

@@ -125,6 +125,40 @@ module.exports = {
             return false;
         }
 
+        /**
+         * Checks whether the given node represents assignment target property in destructuring.
+         *
+         * For examples:
+         *    ({a: b.foo} = c);  // => true for `foo`
+         *    ([a.foo] = b);     // => true for `foo`
+         *    ([a.foo = 1] = b); // => true for `foo`
+         *    ({...a.foo} = b);  // => true for `foo`
+         * @param {ASTNode} node An Identifier node to check
+         * @returns {boolean} True if the node is an assignment target property in destructuring.
+         */
+        function isAssignmentTargetPropertyInDestructuring(node) {
+            if (
+                node.parent.type === "MemberExpression" &&
+                node.parent.property === node &&
+                !node.parent.computed
+            ) {
+                const effectiveParent = node.parent.parent;
+
+                return (
+                    effectiveParent.type === "Property" &&
+                    effectiveParent.value === node.parent &&
+                    effectiveParent.parent.type === "ObjectPattern" ||
+                    effectiveParent.type === "ArrayPattern" ||
+                    effectiveParent.type === "RestElement" ||
+                    (
+                        effectiveParent.type === "AssignmentPattern" &&
+                        effectiveParent.left === node.parent
+                    )
+                );
+            }
+            return false;
+        }
+
         /**
          * Reports an AST node as a rule violation.
          * @param {ASTNode} node The node to report.
@@ -170,6 +204,9 @@ module.exports = {
                     // Report AssignmentExpressions only if they are the left side of the assignment
                     } else if (effectiveParent.type === "AssignmentExpression" && nameIsUnderscored && (effectiveParent.right.type !== "MemberExpression" || effectiveParent.left.type === "MemberExpression" && effectiveParent.left.property.name === node.name)) {
                         report(node);
+
+                    } else if (isAssignmentTargetPropertyInDestructuring(node) && nameIsUnderscored) {
+                        report(node);
                     }
 
                 /*
@@ -186,7 +223,7 @@ module.exports = {
 
                         const assignmentKeyEqualsValue = node.parent.key.name === node.parent.value.name;
 
-                        if (isUnderscored(name) && node.parent.computed) {
+                        if (nameIsUnderscored && node.parent.computed) {
                             report(node);
                         }
 

package/lib/rules/comma-style.js

@@ -146,10 +146,7 @@ module.exports = {
                 // lone comma
                 context.report({
                     node: reportItem,
-                    loc: {
-                        line: commaToken.loc.end.line,
-                        column: commaToken.loc.start.column
-                    },
+                    loc: commaToken.loc,
                     messageId: "unexpectedLineBeforeAndAfterComma",
                     fix: getFixerFunction(styleType, previousItemToken, commaToken, currentItemToken)
                 });
@@ -158,6 +155,7 @@ module.exports = {
 
                 context.report({
                     node: reportItem,
+                    loc: commaToken.loc,
                     messageId: "expectedCommaFirst",
                     fix: getFixerFunction(style, previousItemToken, commaToken, currentItemToken)
                 });
@@ -166,10 +164,7 @@ module.exports = {
 
                 context.report({
                     node: reportItem,
-                    loc: {
-                        line: commaToken.loc.end.line,
-                        column: commaToken.loc.end.column
-                    },
+                    loc: commaToken.loc,
                     messageId: "expectedCommaLast",
                     fix: getFixerFunction(style, previousItemToken, commaToken, currentItemToken)
                 });

package/lib/rules/computed-property-spacing.js

@@ -32,7 +32,7 @@ module.exports = {
                 properties: {
                     enforceForClassMembers: {
                         type: "boolean",
-                        default: false
+                        default: true
                     }
                 },
                 additionalProperties: false
@@ -51,7 +51,7 @@ module.exports = {
     create(context) {
         const sourceCode = context.getSourceCode();
         const propertyNameMustBeSpaced = context.options[0] === "always"; // default is "never"
-        const enforceForClassMembers = context.options[1] && context.options[1].enforceForClassMembers;
+        const enforceForClassMembers = !context.options[1] || context.options[1].enforceForClassMembers;
 
         //--------------------------------------------------------------------------
         // Helpers