Update: class-methods-use-this: exceptions option (fixes #7085) (#…

…7120)
eslint · Sep 13, 2016 · 22edd8a · 22edd8a
1 parent afd132a
commit 22edd8a
Show file tree

Hide file tree

Showing 3 changed files with 76 additions and 3 deletions.
diff --git a/docs/rules/class-methods-use-this.md b/docs/rules/class-methods-use-this.md
@@ -83,3 +83,35 @@ class A {
     }
 }
 ```
+
+## Options
+
+### Exceptions
+
+```
+"class-methods-use-this": [<enabled>, { "exceptions": [<...exceptions>] }]
+```
+
+The `exceptions` option allows you to pass an array of method names for which you would like to ignore warnings.
+
+Examples of **incorrect** code for this rule when used without exceptions:
+
+```js
+/*eslint class-methods-use-this: "error"*/
+
+class A {
+    foo() {
+    }
+}
+```
+
+Examples of **correct** code for this rule when used with exceptions:
+
+```js
+/*eslint class-methods-use-this: ["error", { "exceptions": ["foo"] }] */
+
+class A {
+    foo() {
+    }
+}
+```
diff --git a/lib/rules/class-methods-use-this.js b/lib/rules/class-methods-use-this.js
@@ -16,9 +16,23 @@ module.exports = {
             category: "Best Practices",
             recommended: false
         },
-        schema: []
+        schema: [{
+            type: "object",
+            properties: {
+                exceptMethods: {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    }
+                }
+            },
+            additionalProperties: false
+        }]
     },
     create(context) {
+        const config = context.options[0] ? Object.assign({}, context.options[0]) : {};
+        const exceptMethods = new Set(config.exceptMethods || []);
+
         const stack = [];
 
         /**
@@ -41,6 +55,16 @@ module.exports = {
             return !node.static && node.kind !== "constructor" && node.type === "MethodDefinition";
         }
 
+        /**
+         * Check if the node is an instance method not excluded by config
+         * @param {ASTNode} node - node to check
+         * @returns {boolean} True if it is an instance method, and not excluded by config
+         * @private
+         */
+        function isIncludedInstanceMethod(node) {
+            return isInstanceMethod(node) && !exceptMethods.has(node.key.name);
+        }
+
         /**
          * Checks if we are leaving a function that is a method, and reports if 'this' has not been used.
          * Static methods and the constructor are exempt.
@@ -52,7 +76,7 @@ module.exports = {
         function exitFunction(node) {
             const methodUsesThis = stack.pop();
 
-            if (isInstanceMethod(node.parent) && !methodUsesThis) {
+            if (isIncludedInstanceMethod(node.parent) && !methodUsesThis) {
                 context.report({
                     node,
                     message: "Expected 'this' to be used by class method '{{classMethod}}'.",

diff --git a/tests/lib/rules/class-methods-use-this.js b/tests/lib/rules/class-methods-use-this.js
@@ -29,7 +29,8 @@ ruleTester.run("class-methods-use-this", rule, {
         {code: "class A { static foo() {} }", parserOptions: { ecmaVersion: 6 }},
         {code: "({ a(){} });", parserOptions: { ecmaVersion: 6 }},
         {code: "class A { foo() { () => this; } }", parserOptions: { ecmaVersion: 6 }},
-        {code: "({ a: function () {} });", parserOptions: { ecmaVersion: 6 }}
+        {code: "({ a: function () {} });", parserOptions: { ecmaVersion: 6 }},
+        {code: "class A { foo() {this} bar() {} }", parserOptions: { ecmaVersion: 6 }, options: [{ exceptMethods: ["bar"] }]}
     ],
     invalid: [
         {
@@ -80,6 +81,22 @@ ruleTester.run("class-methods-use-this", rule, {
             errors: [
                 {type: "FunctionExpression", line: 1, column: 14, message: "Expected 'this' to be used by class method 'foo'."}
             ]
+        },
+        {
+            code: "class A { foo() {} bar() {} }",
+            parserOptions: { ecmaVersion: 6 },
+            options: [{ exceptMethods: ["bar"] }],
+            errors: [
+                {type: "FunctionExpression", line: 1, column: 14, message: "Expected 'this' to be used by class method 'foo'."},
+            ]
+        },
+        {
+            code: "class A { foo() {} hasOwnProperty() {} }",
+            parserOptions: { ecmaVersion: 6 },
+            options: [{ exceptMethods: ["foo"] }],
+            errors: [
+                {type: "FunctionExpression", line: 1, column: 34, message: "Expected 'this' to be used by class method 'hasOwnProperty'."}
+            ]
         }
     ]
 });