feat!: Drop Node < 12, switch to eslint flat config (#16)

* refactor: switch to eslint flat config

* chore: apply eslint autofix

* chore: up node version requirement

* chore: fix eslint errors manually

* revert: fixtures change

* chore: ignore package-lock.json

.gitignore

@@ -2,3 +2,4 @@
 npm-debug.log
 .DS_Store
 .eslint-release-info.json
+package-lock.json

bin/eslint-transforms.js

@@ -2,35 +2,36 @@
 
 "use strict";
 
-var execSync = require("child_process").execSync;
-var path = require("path");
+const execSync = require("child_process").execSync;
+const path = require("path");
 
-var argv = process.argv.slice(2);
-var args = argv.slice(1);
-var transform = argv[0];
+const argv = process.argv.slice(2);
+const args = argv.slice(1);
+const transform = argv[0];
 
 /**
  * Add possible node_modules/.bin paths to env and run the command passed in.
- *
  * @param {string} cmd The command to run
  * @returns {void}
  */
 function execWithNodeModules(cmd) {
- var SEPARATOR = process.platform === "win32" ? ";" : ":",
+ const SEPARATOR = process.platform === "win32" ? ";" : ":",
  env = Object.assign({}, process.env);
 
  env.PATH = [
+
  // Covers case when npm flattens dependencies and the jscodeshift bin will be directly under the root
  // node_modules folder
  path.resolve("./node_modules/.bin"),
+
  // Covers case when dependencies are not flattened and the jscodeshift bin can be found under the
  // node_modules folder of our package
  path.resolve(__dirname, "../node_modules/.bin"),
  env.PATH
  ].join(SEPARATOR);
 
  execSync(cmd, {
- env: env,
+ env,
  cwd: process.cwd(),
  stdio: "inherit"
  });
@@ -39,6 +40,6 @@ function execWithNodeModules(cmd) {
 execWithNodeModules([
  "jscodeshift",
  "-t",
- path.resolve(__dirname, "../lib/" + transform + "/" + transform + ".js"),
+ path.resolve(__dirname, `../lib/${transform}/${transform}.js`),
  args.join(" ")
 ].join(" "));

eslint.config.js

@@ -0,0 +1,19 @@
+"use strict";
+
+const eslintConfig = require("eslint-config-eslint");
+const globals = require("globals");
+
+module.exports = [
+ {
+ ignores: ["tests/fixtures/"]
+ },
+ ...eslintConfig,
+ {
+ files: ["tests/**/*"],
+ languageOptions: {
+ globals: {
+ ...globals.mocha
+ }
+ }
+ }
+];

lib/new-rule-format/new-rule-format.js

@@ -21,51 +21,47 @@
 
 "use strict";
 
-var j = require("jscodeshift");
+const j = require("jscodeshift");
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
 /**
  * Returns `true` if the rule is already in the new format
- *
- * @param {Object} rootNode - where to look for the rule definition
- * @returns {Boolean} `true` if rule is already in the new format
+ * @param {Object} rootNode where to look for the rule definition
+ * @returns {boolean} `true` if rule is already in the new format
  */
 function isAlreadyInNewFormat(rootNode) {
+
  // If there's already a module.exports.meta property, we assume the rule
  // is already in the new format.
  return rootNode
  .find(j.Property)
- .filter(function(node) {
- return (
- node.value.key.name === "meta" &&
+ .filter(node => (
+ node.value.key.name === "meta" &&
  node.parent.value.type === "ObjectExpression" &&
  node.parent.parent.value.type === "AssignmentExpression" &&
  node.parent.parent.value.left.type === "MemberExpression" &&
  node.parent.parent.value.left.object.name === "module" &&
  node.parent.parent.value.left.property.name === "exports"
- );
- })
+ ))
  .size() > 0;
 }
 
 /**
  * Checks if the node passed is a function expression or an arrow function expression
- *
- * @param {Object} node - node to check
- * @returns {Boolean} - `true` if node is a function or arrow function expression
+ * @param {Object} node node to check
+ * @returns {boolean} - `true` if node is a function or arrow function expression
  */
 function isFunctionOrArrowFunctionExpression(node) {
  return node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
 }
 
 /**
  * Checks if the node passed can be an "old format" rule definition
- *
- * @param {Object} node - node to check
- * @returns {Boolean} - `true` if node looks like an "old format" rule definition
+ * @param {Object} node node to check
+ * @returns {boolean} - `true` if node looks like an "old format" rule definition
  */
 function isOldFormatRuleDefinition(node) {
  return isFunctionOrArrowFunctionExpression(node) || node.type === "CallExpression";
@@ -75,55 +71,49 @@ function isOldFormatRuleDefinition(node) {
  * Returns the node in `rootNode` that is the rule definition in the old format,
  * which will be in the format:
  * module.exports = function(context) { ... };
- *
- * @param {Object} rootNode - where to look for the rule definition node
+ * @param {Object} rootNode where to look for the rule definition node
  * @returns {Object} node - rule definition expression node
  */
 function getOldFormatRuleDefinition(rootNode) {
  return rootNode
  .find(j.AssignmentExpression)
- .filter(function(node) {
- return (
- node.value.left.type === "MemberExpression" &&
+ .filter(node => (
+ node.value.left.type === "MemberExpression" &&
  node.value.left.property.name === "exports" &&
  node.value.left.object.name === "module" &&
  isOldFormatRuleDefinition(node.value.right)
- );
- });
+ ));
 }
 
 /**
  * Returns the node in `rootNode` that is the schema definition in the old format,
  * which will be in the format:
  * module.exports.schema = [ ... ];
- *
- * @param {Object} rootNode - where to look for the rule definition node
+ * @param {Object} rootNode where to look for the rule definition node
  * @returns {Object} node - rule definition expression node
  */
 function getOldFormatSchemaDefinition(rootNode) {
  return rootNode
  .find(j.AssignmentExpression)
- .filter(function(node) {
- return (
- node.value.left.type === "MemberExpression" &&
+ .filter(node => (
+ node.value.left.type === "MemberExpression" &&
  node.value.left.property.name === "schema" &&
  node.value.left.object.type === "MemberExpression" &&
  node.value.left.object.object.name === "module" &&
  node.value.left.object.property.name === "exports"
- );
- });
+ ));
 }
 
 /**
-* Creates the object expression node that will be the `meta` property of this rule
-*
-* @param {Object} schemaNode - node that was the schema definition in the old rule format
-* @param {Object} schemaNodeComments - comments that were above the old schema node
-* @param {Boolean} isRuleFixable - `true` if the rule is fixable
-* @returns {Object} ObjectExpression node
-*/
+ * Creates the object expression node that will be the `meta` property of this rule
+ * @param {Object} schemaNode node that was the schema definition in the old rule format
+ * @param {Object} schemaNodeComments comments that were above the old schema node
+ * @param {boolean} isRuleFixable `true` if the rule is fixable
+ * @returns {Object} ObjectExpression node
+ */
 function createMetaObjectExpression(schemaNode, schemaNodeComments, isRuleFixable) {
- var properties = [
+ const properties = [
+
  // For docs, create just an empty object
  j.property("init", j.identifier("docs"), j.objectExpression([]))
  ];
@@ -136,7 +126,9 @@ function createMetaObjectExpression(schemaNode, schemaNodeComments, isRuleFixabl
 
  // The schema definition may not exist in some plugins
  if (schemaNode) {
- var schemaNodeProperty = j.property("init", j.identifier("schema"), schemaNode);
+ const schemaNodeProperty = j.property("init", j.identifier("schema"), schemaNode);
+
+
  // Restore comments that were removed when the old format node was removed
  schemaNodeProperty.comments = schemaNodeComments;
  properties.push(schemaNodeProperty);
@@ -147,21 +139,20 @@ function createMetaObjectExpression(schemaNode, schemaNodeComments, isRuleFixabl
 
 /**
  * Creates the `exports` expression that wil contain the rule definition in the new format
- *
- * @param {Object} ruleDefinitionNode - node that was the rule definition in the old rule format
- * @param {Object} ruleDefinitionNodeComments - comments that were above the old schema rule definition
- * @param {Object} ruleMetaDefinitionNode - node that will be the meta definition expression
+ * @param {Object} ruleDefinitionNode node that was the rule definition in the old rule format
+ * @param {Object} ruleDefinitionNodeComments comments that were above the old schema rule definition
+ * @param {Object} ruleMetaDefinitionNode node that will be the meta definition expression
  * @returns {Object} ExpressionStatement
  */
 function createExportsExpression(ruleDefinitionNode, ruleDefinitionNodeComments, ruleMetaDefinitionNode) {
- var exportsExpression = j.expressionStatement(
+ const exportsExpression = j.expressionStatement(
  j.assignmentExpression(
-  "=",
-  j.memberExpression(j.identifier("module"), j.identifier("exports"), false),
-  j.objectExpression([
-  j.property("init", j.identifier("meta"), ruleMetaDefinitionNode),
-  j.property("init", j.identifier("create"), ruleDefinitionNode)
-  ])
+ "=",
+ j.memberExpression(j.identifier("module"), j.identifier("exports"), false),
+ j.objectExpression([
+ j.property("init", j.identifier("meta"), ruleMetaDefinitionNode),
+ j.property("init", j.identifier("create"), ruleDefinitionNode)
+ ])
  )
  );
 
@@ -176,22 +167,25 @@ function createExportsExpression(ruleDefinitionNode, ruleDefinitionNodeComments,
 //------------------------------------------------------------------------------
 
 /**
- * @param {Object} fileInfo - holds information about the currently processed file.
- * @returns {String} the new source code, after being transformed.
+ * Transforms an ESLint rule from the old format to the new format.
+ * @param {Object} fileInfo holds information about the currently processed file.
+ * @returns {string} the new source code, after being transformed.
  */
 module.exports = function(fileInfo) {
- var root = j(fileInfo.source);
+ const root = j(fileInfo.source);
 
  if (isAlreadyInNewFormat(root)) {
+
  // don't do anything and return
  return root.toSource();
  }
 
  // for most plugins, the old format should be:
  // module.exports = function(context) { ... }
  // but maybe some plugins are using a diferent variable name instead of `context`
- var ruleDefinitionExpression = getOldFormatRuleDefinition(root).get().value.right;
- var identifierNameForContextObject = "context";
+ const ruleDefinitionExpression = getOldFormatRuleDefinition(root).get().value.right;
+ let identifierNameForContextObject = "context";
+
  if (ruleDefinitionExpression.params && ruleDefinitionExpression.params.length > 0) {
  identifierNameForContextObject = ruleDefinitionExpression.params[0].name;
  }
@@ -202,37 +196,40 @@ module.exports = function(fileInfo) {
  // ...
  // fix: function() { ... }
  // });
- var isRuleFixable = root
+ const isRuleFixable = root
  .find(j.Identifier)
- .filter(function(node) {
- return (
- node.value.name === "fix" &&
+ .filter(node => (
+ node.value.name === "fix" &&
  node.parent.value.type === "Property" &&
  node.parent.parent.parent.value.type === "CallExpression" &&
  node.parent.parent.parent.value.callee.type === "MemberExpression" &&
  node.parent.parent.parent.value.callee.object.name === identifierNameForContextObject &&
  node.parent.parent.parent.value.callee.property.name === "report"
- );
- })
+ ))
  .size() > 0;
 
- var oldFormatSchemaDefinition = getOldFormatSchemaDefinition(root);
- var schemaNode, schemaNodeComments;
+ const oldFormatSchemaDefinition = getOldFormatSchemaDefinition(root);
+ let schemaNode, schemaNodeComments;
+
+
  // The schema definition may not exist in some plugins
  if (oldFormatSchemaDefinition.size() > 0) {
  schemaNode = getOldFormatSchemaDefinition(root).get().value.right;
+
  // Store the comments too so we can attach it again later
  schemaNodeComments = getOldFormatSchemaDefinition(root).get().parent.value.leadingComments;
  getOldFormatSchemaDefinition(root).remove();
  }
 
- var ruleDefinitionNode = getOldFormatRuleDefinition(root).get().value.right;
+ const ruleDefinitionNode = getOldFormatRuleDefinition(root).get().value.right;
+
  // Store the comments too so we can attach it again later
- var ruleDefinitionNodeComments = getOldFormatRuleDefinition(root).get().parent.value.leadingComments;
+ const ruleDefinitionNodeComments = getOldFormatRuleDefinition(root).get().parent.value.leadingComments;
+
  getOldFormatRuleDefinition(root).remove();
 
  // Insert the rule definition in the new format at the end of the file
- var newFormat = createExportsExpression(
+ const newFormat = createExportsExpression(
  ruleDefinitionNode,
  ruleDefinitionNodeComments,
  createMetaObjectExpression(schemaNode, schemaNodeComments, isRuleFixable)

package.json

@@ -6,7 +6,7 @@
  "author": "Vitor Balocco",
  "repository": "eslint/eslint-transforms",
  "engines": {
- "node": ">=4"
+ "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
  },
  "bin": {
  "eslint-transforms": "./bin/eslint-transforms.js"
@@ -27,9 +27,10 @@
  },
  "devDependencies": {
  "chai": "^3.5.0",
- "eslint": "^2.9.0",
- "eslint-config-eslint": "^3.0.0",
+ "eslint": "^8.45.0",
+ "eslint-config-eslint": "^8.0.0",
  "eslint-release": "^1.0.0",
+ "globals": "^13.20.0",
  "mocha": "^2.5.3"
  },
  "dependencies": {