feat: allow methods on objects

Closes #15

Author: JamieMason

README.md

@@ -21,6 +21,7 @@ Add the plugin to the `plugins` section and the rule to the `rules` section in y
       {
         "allowedNames": [],
         "allowNamedFunctions": false,
+        "allowObjectProperties": false,
         "classPropertiesAllowed": false,
         "disallowPrototype": false,
         "returnStyle": "unchanged",
@@ -41,6 +42,16 @@ An optional array of function names to ignore. When set, the rule won't report n
 
 If set to true, the rule won't report named functions such as `function foo() {}`. Anonymous function such as `const foo = function() {}` will still be reported.
 
+### `allowObjectProperties`
+
+If set to true, the rule won't report named methods such as
+
+```js
+const myObj = {
+  hello() {}
+}
+```
+
 ### `classPropertiesAllowed`
 
 When `true`, functions defined as [class instance fields](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#Field_declarations) will be converted to arrow functions when doing so would not alter or break their behaviour.

src/config.ts

@@ -19,6 +19,7 @@ export interface Scope {
 export interface ActualOptions {
   allowedNames: string[];
   allowNamedFunctions: boolean;
+  allowObjectProperties: boolean;
   classPropertiesAllowed: boolean;
   disallowPrototype: boolean;
   returnStyle: 'explicit' | 'implicit' | 'unchanged';
@@ -28,6 +29,7 @@ export interface ActualOptions {
 export const DEFAULT_OPTIONS: ActualOptions = {
   allowedNames: [],
   allowNamedFunctions: false,
+  allowObjectProperties: false,
   classPropertiesAllowed: false,
   disallowPrototype: false,
   returnStyle: 'unchanged',

src/guard.ts

@@ -163,6 +163,15 @@ export class Guard {
     return this.isNamedFunction(fn) && this.options.allowedNames.includes(fn.id.name);
   }
 
+  isObjectProperty(fn: AnyFunction): boolean {
+    return this.sourceCode
+      .getAncestors(fn)
+      .reverse()
+      .some((ancestor) => {
+        return ancestor.type === AST_NODE_TYPES.Property;
+      });
+  }
+
   isSafeTransformation(fn: TSESTree.Node): fn is AnyFunction {
     const isSafe =
       this.isAnyFunction(fn) &&
@@ -178,6 +187,7 @@ export class Guard {
     if (this.options.allowNamedFunctions && this.isNamedFunction(fn)) return false;
     if (!this.options.disallowPrototype && this.isPrototypeAssignment(fn)) return false;
     if (this.options.singleReturnOnly && !this.returnsImmediately(fn)) return false;
+    if (this.isObjectProperty(fn) && this.options.allowObjectProperties) return false;
     if (this.hasNameAndIsExportedAsDefaultExport(fn)) return false;
     return true;
   }

src/rule.ts

@@ -30,6 +30,10 @@ export const preferArrowFunctions = createRule<Options, MessageId>({
             default: DEFAULT_OPTIONS.allowNamedFunctions,
             type: 'boolean',
           },
+          allowObjectProperties: {
+            default: DEFAULT_OPTIONS.allowObjectProperties,
+            type: 'boolean',
+          },
           classPropertiesAllowed: {
             default: DEFAULT_OPTIONS.classPropertiesAllowed,
             type: 'boolean',

test/rule.spec.ts

@@ -194,6 +194,35 @@ describe('when classPropertiesAllowed is true', () => {
   });
 });
 
+describe('allowObjectProperties', () => {
+  describe('when property can be converted to an arrow function', () => {
+    describe('leaves the method as is when allowObjectProperties is true', () => {
+      ruleTester.run('prefer-arrow-functions', rule, {
+        valid: [
+          {
+            code: 'const foo = { render(a, b) { console.log(3); } }',
+          },
+          {
+            code: 'export default { data(){ return 4 } }',
+          },
+        ].map(withOptions({ allowObjectProperties: true })),
+        invalid: [
+          {
+            code: 'const foo = { render(a, b) { return a + b; } }',
+            output: 'const foo = { render: (a, b) => a + b }',
+          },
+          {
+            code: 'export default { data(){ return 4 } }',
+            output: 'export default { data: () => 4 }',
+          },
+        ]
+          .map(withOptions({ allowObjectProperties: false }))
+          .map(withErrors(['USE_ARROW_WHEN_FUNCTION'])),
+      });
+    });
+  });
+});
+
 describe('when singleReturnOnly is true', () => {
   describe('when function should be an arrow function', () => {
     describe('when function does not contain only a return statement', () => {