New: no-deprecated-report-api rule

Author: not-an-aardvark

README.md

@@ -36,11 +36,13 @@ Then configure the rules you want to use under the rules section.
 ```json
 {
     "rules": {
-        "eslint-plugin/new-report-api": "error"
+        "eslint-plugin/no-deprecated-report-api": "error"
     }
 }
 ```
 
 ## Supported Rules
 
-* None yet
+🛠 indicates that a rule is fixable.
+
+* 🛠 [no-deprecated-report-api](https://github.com/not-an-aardvark/eslint-plugin-eslint-plugin/blob/master/docs/rules/no-deprecated-report-api.md): Prohibits the deprecated `context.report(node, message)` API

docs/rules/no-deprecated-report-api.md

@@ -0,0 +1,44 @@
+# disallow use of the deprecated context.report() API (no-deprecated-report-api)
+
+(fixable) The `--fix` option on the [command line](../user-guide/command-line-interface#fix) automatically fixes problems reported by this rule.
+
+ESLint has two APIs that rules can use to report problems. The [deprecated API](http://eslint.org/docs/developer-guide/working-with-rules-deprecated) accepts multiple arguments: `context.report(node, [loc], message)`. The ["new API"](http://eslint.org/docs/developer-guide/working-with-rules#contextreport) accepts a single argument: an object containing information about the reported problem. It is recommended that all rules use the new API.
+
+## Rule Details
+
+This rule aims to disallow use of the deprecated `context.report(node, [loc], message)` API.
+
+The following patterns are considered warnings:
+
+```js
+module.exports = {
+  create(context) {
+
+    context.report(node, 'This node is bad.');
+
+    context.report(node, loc, 'This node is bad.');
+
+  }
+};
+
+```
+
+The following patterns are not warnings:
+
+```js
+module.exports = {
+  create(context) {
+
+    context.report({ node, message: 'This node is bad.' });
+
+    context.report({ node, loc, message: 'This node is bad.' });
+
+  }
+};
+```
+
+
+## Further Reading
+
+* [Deprecated rule API](http://eslint.org/docs/developer-guide/working-with-rules-deprecated)
+* [New rule API](http://eslint.org/docs/developer-guide/working-with-rules)

lib/rules/no-deprecated-report-api.js

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview disallow use of the deprecated context.report() API
+ * @author Teddy Katz
+ */
+
+'use strict';
+
+const utils = require('../utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'disallow use of the deprecated context.report() API',
+      category: 'Rules',
+      recommended: false,
+    },
+    fixable: 'code',  // or "code" or "whitespace"
+    schema: [],
+  },
+
+  create (context) {
+    const sourceCode = context.getSourceCode();
+    const ruleInfo = utils.getRuleInfo(sourceCode.ast);
+
+    if (!ruleInfo || !ruleInfo.create.params.length) {
+      return {};
+    }
+
+    if (ruleInfo.create.params[0].type !== 'Identifier') {
+      // TODO: Make the rule detect `module.exports = { create({report}) { report(foo, bar); } };`
+      return {};
+    }
+
+    const contextIdentifiers = new WeakSet();
+
+        // ----------------------------------------------------------------------
+        // Public
+        // ----------------------------------------------------------------------
+
+    return {
+      [ruleInfo.create.type] (node) {
+        if (node === ruleInfo.create) {
+          context.getDeclaredVariables(node)
+            .find(variable => variable.name === node.params[0].name)
+            .references
+            .map(ref => ref.identifier)
+            .forEach(identifier => contextIdentifiers.add(identifier));
+        }
+      },
+      CallExpression (node) {
+        if (
+          node.callee.type === 'MemberExpression' &&
+          contextIdentifiers.has(node.callee.object) &&
+          node.callee.property.type === 'Identifier' && node.callee.property.name === 'report' &&
+          node.arguments.length > 1
+        ) {
+          context.report({
+            node,
+            message: 'Use the new-style context.report() API.',
+            fix (fixer) {
+              const openingParen = sourceCode.getTokenBefore(node.arguments[0]);
+              const closingParen = sourceCode.getLastToken(node);
+              const keyNames = node.arguments.length === 5
+                ? ['node', 'loc', 'message', 'data', 'fix']
+                : ['node', 'message', 'data', 'fix'];
+
+              return fixer.replaceTextRange(
+                [openingParen.range[1], closingParen.range[0]],
+                '{' + node.arguments.map((arg, index) => `${keyNames[index]}: ${sourceCode.getText(arg)}`).join(', ') + '}'
+              );
+            },
+          });
+        }
+      },
+    };
+  },
+};

lib/utils.js

@@ -0,0 +1,88 @@
+'use strict';
+
+/**
+* Determines whether a node is a 'normal' (i.e. non-async, non-generator) function expression.
+* @param {ASTNode} node The node in question
+* @returns {boolean} `true` if the node is a normal function expression
+*/
+function isNormalFunctionExpression (node) {
+  return (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') && !node.generator && !node.async;
+}
+
+module.exports = {
+
+  /**
+  * Performs static analysis on an AST to try to determine the final value of `module.exports`.
+  * @param {ASTNode} ast The `Program` AST node
+  * @returns {Object} An object with keys `meta`, `create`, and `isNewStyle`. `meta` and `create` correspond to the AST nodes
+  for the final values of `module.exports.meta` and `module.exports.create`. `isNewStyle` will be `true` if `module.exports`
+  is an object, and `false` if module.exports is just the `create` function. If no valid ESLint rule info can be extracted
+  from the file, the return value will be `null`.
+  */
+  getRuleInfo (ast) {
+    const INTERESTING_KEYS = ['create', 'meta'];
+    let exportsVarOverridden = false;
+    let exportsIsFunction = false;
+
+    const exportNodes = ast.body
+      .filter(statement => statement.type === 'ExpressionStatement')
+      .map(statement => statement.expression)
+      .filter(expression => expression.type === 'AssignmentExpression')
+      .filter(expression => expression.left.type === 'MemberExpression')
+      .reduce((currentExports, node) => {
+        if (
+          node.left.object.type === 'Identifier' && node.left.object.name === 'module' &&
+          node.left.property.type === 'Identifier' && node.left.property.name === 'exports'
+        ) {
+          exportsVarOverridden = true;
+
+          if (isNormalFunctionExpression(node.right)) {
+            // Check `module.exports = function () {}`
+
+            exportsIsFunction = true;
+            return { create: node.right, meta: null };
+          } else if (node.right.type === 'ObjectExpression') {
+            // Check `module.exports = { create: function () {}, meta: {} }`
+
+            exportsIsFunction = false;
+            return node.right.properties.reduce((parsedProps, prop) => {
+              const keyValue = prop.key.type === 'Literal'
+                ? prop.key.value
+                : prop.key.type === 'Identifier'
+                  ? prop.key.name
+                  : null;
+
+              if (INTERESTING_KEYS.indexOf(keyValue) !== -1) {
+                parsedProps[keyValue] = prop.value;
+              }
+              return parsedProps;
+            }, {});
+          }
+          return {};
+        } else if (
+          !exportsIsFunction &&
+          node.left.object.type === 'MemberExpression' &&
+          node.left.object.object.type === 'Identifier' && node.left.object.object.name === 'module' &&
+          node.left.object.property.type === 'Identifier' && node.left.object.property.name === 'exports' &&
+          node.left.property.type === 'Identifier' && INTERESTING_KEYS.indexOf(node.left.property.name) !== -1
+        ) {
+          // Check `module.exports.create = () => {}`
+
+          currentExports[node.left.property.name] = node.right;
+        } else if (
+          !exportsVarOverridden &&
+          node.left.object.type === 'Identifier' && node.left.object.name === 'exports' &&
+          node.left.property.type === 'Identifier' && INTERESTING_KEYS.indexOf(node.left.property.name) !== -1
+        ) {
+          // Check `exports.create = () => {}`
+
+          currentExports[node.left.property.name] = node.right;
+        }
+        return currentExports;
+      }, {});
+
+    return Object.prototype.hasOwnProperty.call(exportNodes, 'create') && isNormalFunctionExpression(exportNodes.create)
+      ? Object.assign({ isNewStyle: !exportsIsFunction, meta: null }, exportNodes)
+      : null;
+  },
+};

package.json

@@ -28,9 +28,13 @@
   "homepage": "https://github.com/not-an-aardvark/eslint-plugin-eslint-plugin#readme",
   "dependencies": {},
   "devDependencies": {
+    "chai": "^3.5.0",
+    "dirty-chai": "^1.2.2",
     "eslint": "^3.12.1",
     "eslint-config-not-an-aardvark": "^2.0.0",
     "eslint-plugin-node": "^3.0.5",
+    "espree": "^3.3.2",
+    "lodash": "^4.17.2",
     "mocha": "^2.4.5"
   },
   "peerDependencies": {

tests/.eslintrc.yml

@@ -0,0 +1,2 @@
+env:
+  mocha: true