Add support for template codemods

commands/local/generate/codemod.js

@@ -2,12 +2,19 @@ module.exports.command = 'codemod <codemod-name>';
 module.exports.desc = 'Generate a new codemod file';
 
 module.exports.builder = function builder(yargs) {
-  yargs.positional('codemod-name', {
-    describe: 'the name of the codemod to generate',
-  });
+  yargs
+    .positional('codemod-name', {
+      describe: 'the name of the codemod to generate',
+    })
+    .option('type', {
+      alias: 't',
+      describe: 'choose the transform type',
+      choices: ['js', 'hbs'],
+      default: 'js',
+    });
 };
 
-module.exports.handler = function handler(options) {
+function jsHandler(options) {
   const fs = require('fs-extra');
   const { stripIndent } = require('common-tags');
   const importCwd = require('import-cwd');
@@ -36,7 +43,9 @@ module.exports.handler = function handler(options) {
               .join('');
           })
           .toSource();
-      }
+      };
+
+      module.exports.type = 'js';
   `,
     'utf8'
   );
@@ -47,8 +56,7 @@ module.exports.handler = function handler(options) {
 
       const { runTransformTest } = require('codemod-cli');
 
-      runTransformTest({
-        type: 'jscodeshift',
+      runTransformTest({ 
         name: '${codemodName}',
       });
     `,
@@ -86,5 +94,95 @@ module.exports.handler = function handler(options) {
     'utf8'
   );
 
-  generateFixture({ codemodName, fixtureName: 'basic' });
+  generateFixture({ codemodName, fixtureName: 'basic', type: options.type });
+}
+
+function hbsHandler(options) {
+  const fs = require('fs-extra');
+  const { stripIndent } = require('common-tags');
+  const importCwd = require('import-cwd');
+  const generateFixture = require('./fixture').handler;
+
+  let { codemodName } = options;
+  let projectName = importCwd('./package.json').name;
+  let codemodDir = `${process.cwd()}/transforms/${codemodName}`;
+
+  fs.outputFileSync(
+    `${codemodDir}/index.js`,
+    stripIndent`
+      module.exports = function ({ source /*, path*/ }, { parse, visit }) {
+        const ast = parse(source);
+
+        return visit(ast, (env) => {
+          let { builders: b } = env.syntax;
+
+          return {
+            MustacheStatement() {
+              return b.mustache(b.path('wat-wat'));
+            },
+          };
+        });
+      };
+
+      module.exports.type = 'hbs';
+  `,
+    'utf8'
+  );
+  fs.outputFileSync(
+    `${codemodDir}/test.js`,
+    stripIndent`
+      'use strict';
+
+      const { runTransformTest } = require('codemod-cli');
+
+      runTransformTest({
+        name: '${codemodName}',
+      });
+    `,
+    'utf8'
+  );
+  fs.outputFileSync(
+    `${codemodDir}/README.md`,
+    stripIndent`
+      # ${codemodName}\n
+
+      ## Usage
+
+      \`\`\`
+      npx ${projectName} ${codemodName} path/of/files/ or/some**/*glob.hbs
+
+      # or
+
+      yarn global add ${projectName}
+      ${projectName} ${codemodName} path/of/files/ or/some**/*glob.hbs
+      \`\`\`
+
+      ## Local Usage
+      \`\`\`
+      node ./bin/cli.js ${codemodName} path/of/files/ or/some**/*glob.hbs
+      \`\`\`
+
+      ## Input / Output
+
+      <!--FIXTURES_TOC_START-->
+      <!--FIXTURES_TOC_END-->
+
+      <!--FIXTURES_CONTENT_START-->
+      <!--FIXTURES_CONTENT_END-->
+    `,
+    'utf8'
+  );
+
+  generateFixture({ codemodName, fixtureName: 'basic', type: options.type });
+}
+
+module.exports.handler = function handler(options) {
+  switch (options.type) {
+    case 'js':
+      return jsHandler(options);
+    case 'hbs':
+      return hbsHandler(options);
+    default:
+      throw new Error(`Unknown type: "${options.type}"`);
+  }
 };

commands/local/generate/fixture.js

@@ -13,11 +13,15 @@ module.exports.builder = function builder(yargs) {
 
 module.exports.handler = function handler(options) {
   const fs = require('fs-extra');
+  const { getTransformType } = require('../../../src/transform-support');
 
   let { codemodName, fixtureName } = options;
   let codemodDir = `${process.cwd()}/transforms/${codemodName}`;
+  let codemodTransform = `${codemodDir}/index.js`;
   let fixturePath = `${codemodDir}/__testfixtures__/${fixtureName}`;
 
-  fs.outputFileSync(`${fixturePath}.input.js`, '');
-  fs.outputFileSync(`${fixturePath}.output.js`, '');
+  let transformType = getTransformType(codemodTransform);
+
+  fs.outputFileSync(`${fixturePath}.input.${transformType}`, '');
+  fs.outputFileSync(`${fixturePath}.output.${transformType}`, '');
 };

package.json

@@ -38,6 +38,7 @@
     "@babel/parser": "^7.6.0",
     "chalk": "^2.4.2",
     "common-tags": "^1.8.0",
+    "ember-template-recast": "^4.1.4",
     "execa": "^2.0.4",
     "fs-extra": "^8.1.0",
     "globby": "^10.0.1",

src/bin-support.js

@@ -1,8 +1,14 @@
 'use strict';
 
-const DEFAULT_EXTENSIONS = 'js,ts';
+const DEFAULT_JS_EXTENSIONS = 'js,ts';
 
-async function runTransform(binRoot, transformName, args, extensions = DEFAULT_EXTENSIONS) {
+function getTransformPath(binRoot, transformName) {
+  const path = require('path');
+
+  return path.join(binRoot, '..', 'transforms', transformName, 'index.js');
+}
+
+async function runJsTransform(binRoot, transformName, args, extensions = DEFAULT_JS_EXTENSIONS) {
   const globby = require('globby');
   const execa = require('execa');
   const chalk = require('chalk');
@@ -15,7 +21,7 @@ async function runTransform(binRoot, transformName, args, extensions = DEFAULT_E
     let foundPaths = await globby(paths, {
       expandDirectories: { extensions: extensions.split(',') },
     });
-    let transformPath = path.join(binRoot, '..', 'transforms', transformName, 'index.js');
+    let transformPath = getTransformPath(binRoot, transformName);
 
     let jscodeshiftPkg = require('jscodeshift/package');
     let jscodeshiftPath = path.dirname(require.resolve('jscodeshift/package'));
@@ -37,6 +43,48 @@ async function runTransform(binRoot, transformName, args, extensions = DEFAULT_E
   }
 }
 
+async function runTemplateTransform(binRoot, transformName, args) {
+  const execa = require('execa');
+  const chalk = require('chalk');
+  const { parseTransformArgs } = require('./options-support');
+
+  let { paths, options } = parseTransformArgs(args);
+
+  try {
+    let transformPath = getTransformPath(binRoot, transformName);
+    let binOptions = ['-t', transformPath, ...paths];
+
+    return execa('ember-template-recast', binOptions, {
+      stdio: 'inherit',
+      preferLocal: true,
+      env: {
+        CODEMOD_CLI_ARGS: JSON.stringify(options),
+      },
+    });
+  } catch (error) {
+    console.error(chalk.red(error.stack)); // eslint-disable-line no-console
+    process.exitCode = 1;
+
+    throw error;
+  }
+}
+
+async function runTransform(binRoot, transformName, args, extensions) {
+  const { getTransformType } = require('./transform-support');
+
+  let transformPath = getTransformPath(binRoot, transformName);
+  let type = getTransformType(transformPath);
+
+  switch (type) {
+    case 'js':
+      return runJsTransform(binRoot, transformName, args, extensions);
+    case 'hbs':
+      return runTemplateTransform(binRoot, transformName, args);
+    default:
+      throw new Error(`Unknown type passed to runTransform: "${type}"`);
+  }
+}
+
 module.exports = {
   runTransform,
 };

src/test-support.js

@@ -1,79 +1,19 @@
 'use strict';
 
-/* global it, describe, beforeEach, afterEach */
+const jscodeshiftTest = require('./test-support/jscodeshift');
+const templateTest = require('./test-support/template');
+const { transformDetails } = require('./test-support/utils');
 
-const { runInlineTest } = require('jscodeshift/dist/testUtils');
-const fs = require('fs-extra');
-const path = require('path');
-const globby = require('globby');
-
-function transformDetails(options) {
-  let root = process.cwd() + `/transforms/${options.name}/`;
-
-  return {
-    name: options.name,
-    root,
-    transformPath: root + 'index',
-    fixtureDir: root + '__testfixtures__/',
-  };
-}
-
-function jscodeshiftTest(options) {
+function runTransformTest(options) {
   let details = transformDetails(options);
 
-  let transform = require(details.transformPath);
-
-  describe(details.name, function() {
-    globby
-      .sync('**/*.input.*', {
-        cwd: details.fixtureDir,
-        absolute: true,
-      })
-      .map(entry => entry.slice(entry.indexOf('__testfixtures__') + '__testfixtures__'.length + 1))
-      .forEach(filename => {
-        let extension = path.extname(filename);
-        let testName = filename.replace(`.input${extension}`, '');
-        let testInputPath = path.join(details.fixtureDir, `${testName}${extension}`);
-        let inputPath = path.join(details.fixtureDir, `${testName}.input${extension}`);
-        let outputPath = path.join(details.fixtureDir, `${testName}.output${extension}`);
-        let optionsPath = path.join(details.fixtureDir, `${testName}.options.json`);
-        let options = fs.pathExistsSync(optionsPath) ? fs.readFileSync(optionsPath) : '{}';
-
-        describe(testName, function() {
-          beforeEach(function() {
-            process.env.CODEMOD_CLI_ARGS = options;
-          });
-
-          afterEach(function() {
-            process.env.CODEMOD_CLI_ARGS = '';
-          });
-
-          it('transforms correctly', function() {
-            runInlineTest(
-              transform,
-              {},
-              { path: testInputPath, source: fs.readFileSync(inputPath, 'utf8') },
-              fs.readFileSync(outputPath, 'utf8')
-            );
-          });
-
-          it('is idempotent', function() {
-            runInlineTest(
-              transform,
-              {},
-              { path: testInputPath, source: fs.readFileSync(outputPath, 'utf8') },
-              fs.readFileSync(outputPath, 'utf8')
-            );
-          });
-        });
-      });
-  });
-}
-
-function runTransformTest(options) {
-  switch (options.type) {
-    case 'jscodeshift':
+  switch (details.transformType) {
+    case 'js':
       return jscodeshiftTest(options);
+    case 'hbs':
+      return templateTest(options);
+    default:
+      throw new Error(`Unknown type of transform: "${details.transformType}"`);
   }
 }
 

src/test-support/jscodeshift.js

@@ -0,0 +1,61 @@
+'use strict';
+
+/* global it, describe, beforeEach, afterEach */
+
+const { runInlineTest } = require('jscodeshift/dist/testUtils');
+const fs = require('fs-extra');
+const path = require('path');
+const globby = require('globby');
+const { transformDetails } = require('./utils');
+
+module.exports = function jscodeshiftTest(options) {
+  let details = transformDetails(options);
+
+  let transform = require(details.transformPath);
+
+  describe(details.name, function() {
+    globby
+      .sync('**/*.input.*', {
+        cwd: details.fixtureDir,
+        absolute: true,
+      })
+      .map(entry => entry.slice(entry.indexOf('__testfixtures__') + '__testfixtures__'.length + 1))
+      .forEach(filename => {
+        let extension = path.extname(filename);
+        let testName = filename.replace(`.input${extension}`, '');
+        let testInputPath = path.join(details.fixtureDir, `${testName}${extension}`);
+        let inputPath = path.join(details.fixtureDir, `${testName}.input${extension}`);
+        let outputPath = path.join(details.fixtureDir, `${testName}.output${extension}`);
+        let optionsPath = path.join(details.fixtureDir, `${testName}.options.json`);
+        let options = fs.pathExistsSync(optionsPath) ? fs.readFileSync(optionsPath) : '{}';
+
+        describe(testName, function() {
+          beforeEach(function() {
+            process.env.CODEMOD_CLI_ARGS = options;
+          });
+
+          afterEach(function() {
+            process.env.CODEMOD_CLI_ARGS = '';
+          });
+
+          it('transforms correctly', function() {
+            runInlineTest(
+              transform,
+              {},
+              { path: testInputPath, source: fs.readFileSync(inputPath, 'utf8') },
+              fs.readFileSync(outputPath, 'utf8')
+            );
+          });
+
+          it('is idempotent', function() {
+            runInlineTest(
+              transform,
+              {},
+              { path: testInputPath, source: fs.readFileSync(outputPath, 'utf8') },
+              fs.readFileSync(outputPath, 'utf8')
+            );
+          });
+        });
+      });
+  });
+};