New: Initial commit

* add new-rule-format transform and initial repo structure

* add note to new-rule-format regarding ES6 modules not being supported

* New: add simple CLI and eslint-release tool

* Docs: remove "npm run" usage example from README

* Update: remove ES6 syntax

* Chore: remove es6-related npm packages that are not needed anymore

* Update: Use mocha+chai for tests instead of Jest

* Update: move transform call into it() so errors are caught properly

* Fix: handle rules that have the definition wrapped in a call expression

* Update: extract helper methods out of the main exported function

* Update: remove unecessary license info and obsolete jsdoc param

Author: vitorbal

.editorconfig

@@ -0,0 +1,12 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true
+end_of_line = lf
+insert_final_newline = true
+
+[package.json]
+indent_style = space
+indent_size = 2

.eslintrc.yml

@@ -0,0 +1,3 @@
+env:
+    node: true
+extends: "eslint-config-eslint"

.gitignore

@@ -0,0 +1,3 @@
+/node_modules
+npm-debug.log
+.DS_Store

LICENSE

@@ -0,0 +1,20 @@
+ESLint Transforms
+Copyright jQuery Foundation and other contributors, https://jquery.org/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -1,3 +1,50 @@
-# eslint-transforms
-Codemods for the ESLint ecosystem
+# ESLint Transforms
 
+A collection of jscodeshift transforms to help upgrade ESLint rules to new versions of [ESLint](https://github.com/eslint/eslint).
+
+## Installation
+
+You can install the ESLint transforms tool using [npm](https://npmjs.com):
+
+```
+$ npm install eslint-transforms --save-dev
+```
+
+## Usage
+
+```
+$ eslint-transforms <transform-name> <path>
+```
+
+Where:
+
+`transform-name` - Name of the transform you want to run (e.g. `new-rule-format`). See the [transforms](#transforms) section below for a list of available transforms.
+
+`path` - Files or directory to transform.
+
+
+For more information on jscodeshift, check their official [docs](https://github.com/facebook/jscodeshift).
+
+## Transforms
+
+### new-rule-format
+
+**Please note**: The transform will not work for rules that use ES6 modules syntax.
+
+Transform that migrates an ESLint rule definition from the old format:
+
+```javascript
+module.exports = function(context) { ... }
+```
+
+to the new format, introduced in ESLint 2.10.0:
+
+```javascript
+module.exports = {
+ meta: {
+     docs: {},
+     schema: []
+ },
+ create: function(context) { ... }
+};
+```

bin/eslint-transforms.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+
+"use strict";
+
+var nodeCLI = require("shelljs-nodecli");
+
+var argv = process.argv.slice(2);
+var args = argv.slice(1);
+var transform = argv[0];
+
+nodeCLI.exec(
+    "jscodeshift",
+    "-t", "./lib/" + transform + "/" + transform + ".js",
+    args.join(" ")
+);

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

@@ -0,0 +1,243 @@
+/**
+ * @fileoverview Transform that migrates an ESLint rule definitions from the old format:
+ *
+ * ```
+ * module.exports = function(context) { ... }
+ * ```
+ *
+ * to the new format:
+ *
+ * ```
+ * module.exports = {
+ *     meta: {
+ *         docs: {},
+ *         schema: []
+ *     },
+ *     create: function(context) { ... }
+ * };
+ * ```
+ * @author Vitor Balocco
+ */
+
+"use strict";
+
+var 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
+ */
+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" &&
+                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
+ */
+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
+ */
+function isOldFormatRuleDefinition(node) {
+    return isFunctionOrArrowFunctionExpression(node) || node.type === "CallExpression";
+}
+
+/**
+ * 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
+ * @returns {Object} node - rule definition expression node
+ */
+function getOldFormatRuleDefinition(rootNode) {
+    return rootNode
+        .find(j.AssignmentExpression)
+        .filter(function(node) {
+            return (
+                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
+ * @returns {Object} node - rule definition expression node
+ */
+function getOldFormatSchemaDefinition(rootNode) {
+    return rootNode
+        .find(j.AssignmentExpression)
+        .filter(function(node) {
+            return (
+                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
+*/
+function createMetaObjectExpression(schemaNode, schemaNodeComments, isRuleFixable) {
+    var properties = [
+        // For docs, create just an empty object
+        j.property("init", j.identifier("docs"), j.objectExpression([]))
+    ];
+
+    if (isRuleFixable) {
+        properties.push(
+            j.property("init", j.identifier("fixable"), j.literal("code"))
+        );
+    }
+
+    // The schema definition may not exist in some plugins
+    if (schemaNode) {
+        var 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);
+    }
+
+    return j.objectExpression(properties);
+}
+
+/**
+ * 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
+ * @returns {Object} ExpressionStatement
+ */
+function createExportsExpression(ruleDefinitionNode, ruleDefinitionNodeComments, ruleMetaDefinitionNode) {
+    var 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)
+                ])
+        )
+    );
+
+    // Restore comments that were removed when the old format node was removed
+    exportsExpression.comments = ruleDefinitionNodeComments;
+
+    return exportsExpression;
+}
+
+//------------------------------------------------------------------------------
+// Transform Definition
+//------------------------------------------------------------------------------
+
+/**
+ * @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);
+
+    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";
+    if (ruleDefinitionExpression.params && ruleDefinitionExpression.params.length > 0) {
+        identifierNameForContextObject = ruleDefinitionExpression.params[0].name;
+    }
+
+    // If the rule has a call for context.report and a property `fix` is being passed in,
+    // then we consider that the rule is fixable:
+    // context.report({
+    //     ...
+    //     fix: function() { ... }
+    // });
+    var isRuleFixable = root
+        .find(j.Identifier)
+        .filter(function(node) {
+            return (
+                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;
+    // 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;
+    // Store the comments too so we can attach it again later
+    var 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(
+        ruleDefinitionNode,
+        ruleDefinitionNodeComments,
+        createMetaObjectExpression(schemaNode, schemaNodeComments, isRuleFixable)
+    );
+
+    root.find(j.Program).get().value.body.push(newFormat);
+    return root.toSource();
+};

package.json

@@ -0,0 +1,42 @@
+{
+  "name": "eslint-transforms",
+  "version": "0.0.1",
+  "description": "Codemods for upgrading eslint rules",
+  "license": "MIT",
+  "author": "Vitor Balocco",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eslint/eslint-transforms"
+  },
+  "engines": {
+    "node": ">=0.10"
+  },
+  "bin": {
+    "eslint-transforms": "./bin/eslint-transforms.js"
+  },
+  "files": [
+    "bin",
+    "lib"
+  ],
+  "scripts": {
+    "lint": "eslint .",
+    "test": "npm run lint && mocha ./tests/lib/**/*.js",
+    "new-rule-format": "node ./bin/eslint-transforms.js -t ./lib/new-rule-format/new-rule-format.js"
+  },
+  "devDependencies": {
+    "chai": "^3.5.0",
+    "eslint": "^2.9.0",
+    "eslint-config-eslint": "^3.0.0",
+    "eslint-release": "^0.5.0",
+    "mocha": "^2.5.3"
+  },
+  "dependencies": {
+    "jscodeshift": "^0.3.20",
+    "shelljs-nodecli": "^0.1.1"
+  },
+  "keywords": [
+    "javascript",
+    "eslint",
+    "jscodeshift"
+  ]
+}