Chore: unify logic for parsing context.report() arguments

Author: not-an-aardvark

Diff for: lib/rules/no-deprecated-report-api.js

@@ -47,32 +47,15 @@ module.exports = {
             fix (fixer) {
               const openingParen = sourceCode.getTokenBefore(node.arguments[0]);
               const closingParen = sourceCode.getLastToken(node);
+              const reportInfo = utils.getReportInfo(node.arguments);
 
-              // If there is exactly one argument, the API expects an object.
-              // Otherwise, if the second argument is a string, the arguments are interpreted as
-              // ['node', 'message', 'data', 'fix'].
-              // Otherwise, the arguments are interpreted as ['node', 'loc', 'message', 'data', 'fix'].
-
-              let keys;
-              if (
-                (node.arguments[1].type === 'Literal' && typeof node.arguments[1].value === 'string') ||
-                node.arguments[1].type === 'TemplateLiteral'
-              ) {
-                keys = ['node', 'message', 'data', 'fix'];
-              } else if (
-                node.arguments[1].type === 'ObjectExpression' ||
-                node.arguments[1].type === 'ArrayExpression' ||
-                (node.arguments[1].type === 'Literal' && typeof node.arguments[1].value !== 'string')
-              ) {
-                keys = ['node', 'loc', 'message', 'data', 'fix'];
-              } else {
-                // Otherwise, we can't statically determine what argument means what, so no safe fix is possible.
+              if (!reportInfo) {
                 return null;
               }
 
               return fixer.replaceTextRange(
                 [openingParen.range[1], closingParen.range[0]],
-                `{${node.arguments.slice(0, 5).map((arg, index) => `${keys[index]}: ${sourceCode.getText(arg)}`).join(', ')}}`
+                `{${Object.keys(reportInfo).map(key => `${key}: ${sourceCode.getText(reportInfo[key])}`).join(', ')}}`
               );
             },
           });

Diff for: lib/rules/report-message-format.js

@@ -42,20 +42,11 @@ module.exports = {
           contextIdentifiers.has(node.callee.object) &&
           node.callee.property.type === 'Identifier' && node.callee.property.name === 'report'
         ) {
-          if (!node.arguments.length || (node.arguments.length === 1 && node.arguments[0].type !== 'ObjectExpression')) {
-            return;
-          }
+          const reportInfo = utils.getReportInfo(node.arguments);
+          const message = reportInfo && reportInfo.message;
 
-          let message;
-
-          if (node.arguments.length === 1) {
-            const messageProp = node.arguments[0].properties.find(prop => utils.getKeyName(prop) === 'message');
-            if (!messageProp) {
-              return;
-            }
-            message = messageProp.value;
-          } else {
-            message = node.arguments[1];
+          if (!message) {
+            return;
           }
 
           if (

Diff for: lib/utils.js

@@ -184,4 +184,55 @@ module.exports = {
         };
       });
   },
+
+  /**
+  * Gets information on a report, given the arguments passed to context.report().
+  * @param {ASTNode[]} reportArgs The arguments passed to context.report()
+  */
+  getReportInfo (reportArgs) {
+    // If there is exactly one argument, the API expects an object.
+    // Otherwise, if the second argument is a string, the arguments are interpreted as
+    // ['node', 'message', 'data', 'fix'].
+    // Otherwise, the arguments are interpreted as ['node', 'loc', 'message', 'data', 'fix'].
+
+    if (!reportArgs.length) {
+      return null;
+    }
+
+    if (reportArgs.length === 1) {
+      if (reportArgs[0].type === 'ObjectExpression') {
+        return reportArgs[0].properties.reduce((reportInfo, property) => {
+          const propName = module.exports.getKeyName(property);
+
+          if (propName !== null) {
+            return Object.assign(reportInfo, { [propName]: property.value });
+          }
+          return reportInfo;
+        }, {});
+      }
+      return null;
+    }
+
+    let keys;
+
+    if (
+      (reportArgs[1].type === 'Literal' && typeof reportArgs[1].value === 'string') ||
+      reportArgs[1].type === 'TemplateLiteral'
+    ) {
+      keys = ['node', 'message', 'data', 'fix'];
+    } else if (
+      reportArgs[1].type === 'ObjectExpression' ||
+      reportArgs[1].type === 'ArrayExpression' ||
+      (reportArgs[1].type === 'Literal' && typeof reportArgs[1].value !== 'string')
+    ) {
+      keys = ['node', 'loc', 'message', 'data', 'fix'];
+    } else {
+      // Otherwise, we can't statically determine what argument means what, so no safe fix is possible.
+      return null;
+    }
+
+    return keys
+      .slice(0, reportArgs.length)
+      .reduce((reportInfo, key, index) => Object.assign(reportInfo, { [key]: reportArgs[index] }), {});
+  },
 };

Diff for: tests/lib/utils.js

@@ -287,4 +287,37 @@ describe('utils', () => {
       });
     });
   });
+
+  describe('getReportInfo', () => {
+    const CASES = new Map([
+      [[], () => null],
+      [['foo', 'bar'], () => null],
+      [['foo', '"bar"', 'baz', 'qux', 'boop'], args => ({ node: args[0], message: args[1], data: args[2], fix: args[3] })],
+      [['foo', '`bar`', 'baz', 'qux', 'boop'], args => ({ node: args[0], message: args[1], data: args[2], fix: args[3] })],
+      [
+        ['foo', '{ bar: 1 }', 'baz', 'qux', 'boop'],
+        args => ({ node: args[0], loc: args[1], message: args[2], data: args[3], fix: args[4] }),
+      ],
+      [['foo', 'bar', 'baz'], () => null],
+      [
+        ['{ node, message }'],
+        () => ({
+          node: { type: 'Identifier', name: 'node', start: 17, end: 21 },
+          message: { type: 'Identifier', name: 'message', start: 23, end: 30 },
+        }),
+      ],
+    ]);
+
+    for (const args of CASES.keys()) {
+      it(args.join(', '), () => {
+        const parsedArgs = espree.parse(
+          `context.report(${args.join(', ')})`,
+          { ecmaVersion: 6, loc: false, range: false }
+        ).body[0].expression.arguments;
+        const reportInfo = utils.getReportInfo(parsedArgs);
+
+        assert.deepEqual(reportInfo, CASES.get(args)(parsedArgs));
+      });
+    }
+  });
 });