Merge pull request #45 from ssutar/master

Add support for passing options to jscodeshift

Author: rwjblue

commands/local/generate/codemod.js

@@ -21,9 +21,11 @@ module.exports.handler = function handler(options) {
     `${codemodDir}/index.js`,
     stripIndent`
       const { getParser } = require('codemod-cli').jscodeshift;
+      const { getOptions } = require('codemod-cli');
 
       module.exports = function transformer(file, api) {
         const j = getParser(api);
+        const options = getOptions();
 
         return j(file.source)
           .find(j.Identifier)

src/bin-support.js

@@ -1,10 +1,13 @@
 'use strict';
 
-function runTransform(binRoot, transformName, paths) {
+function runTransform(binRoot, transformName, args) {
   const globby = require('globby');
   const execa = require('execa');
   const chalk = require('chalk');
   const path = require('path');
+  const { parseTransformArgs } = require('./options-support');
+
+  let { paths, options } = parseTransformArgs(args);
 
   return globby(paths)
     .then(paths => {
@@ -16,6 +19,9 @@ function runTransform(binRoot, transformName, paths) {
 
       return execa(binPath, ['-t', transformPath, '--extensions', 'js,ts', ...paths], {
         stdio: 'inherit',
+        env: {
+          CODEMOD_CLI_ARGS: JSON.stringify(options),
+        },
       });
     })
     .catch(error => {

src/index.js

@@ -3,9 +3,11 @@
 const TestSupport = require('./test-support');
 const BinSupport = require('./bin-support');
 const TransformSupport = require('./transform-support');
+const OptionsSupport = require('./options-support');
 
 module.exports = {
   runTransformTest: TestSupport.runTransformTest,
   runTransform: BinSupport.runTransform,
   jscodeshift: TransformSupport.jscodeshift,
+  getOptions: OptionsSupport.getOptions,
 };

src/options-support.js

@@ -0,0 +1,23 @@
+const yargs = require('yargs');
+
+function parseTransformArgs(args) {
+  let parsedArgs = yargs.parse(args);
+  let paths = parsedArgs._;
+  let options = Object.keys(parsedArgs).reduce((acc, key) => {
+    if (!['_', '$0', 'help', 'version'].includes(key)) {
+      acc[key] = parsedArgs[key];
+    }
+    return acc;
+  }, {});
+  return { paths, options };
+}
+
+function getOptions() {
+  try {
+    return JSON.parse(process.env.CODEMOD_CLI_ARGS);
+  } catch (e) {
+    return {};
+  }
+}
+
+module.exports = { parseTransformArgs, getOptions };

src/test-support.js

@@ -1,6 +1,6 @@
 'use strict';
 
-/* global it, describe */
+/* global it, describe, beforeEach, afterEach */
 
 const { runInlineTest } = require('jscodeshift/dist/testUtils');
 const fs = require('fs-extra');
@@ -36,8 +36,18 @@ function jscodeshiftTest(options) {
         let testName = filename.replace(`.input${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,

tests/cli-test.js

@@ -186,6 +186,46 @@ QUnit.module('codemod-cli', function(hooks) {
         })
       );
 
+      QUnit.test(
+        'transform should receive options from ${name}.options.json',
+        wrap(function*(assert) {
+          const expectedReplacement = 'AAAAHHHHHH';
+
+          yield execa(EXECUTABLE_PATH, ['generate', 'codemod', 'main']);
+
+          codemodProject.write({
+            transforms: {
+              main: {
+                'index.js': `
+                  const { getParser } = require('codemod-cli').jscodeshift;
+                  const { getOptions } = require('codemod-cli');
+                  module.exports = function transformer(file, api) {
+                    const options = getOptions();
+                    const j = getParser(api);
+                    return j(file.source)
+                    .find(j.Literal)
+                    .forEach(path => {
+                      path.replace(
+                        j.stringLiteral(options.replaceAll)
+                      );
+                    })
+                    .toSource();
+                  }
+                `,
+                __testfixtures__: {
+                  'basic.input.js': 'var foo = "foo";',
+                  'basic.output.js': `var foo = "${expectedReplacement}";`,
+                  'basic.options.json': `{ "replaceAll": "${expectedReplacement}" }`,
+                },
+              },
+            },
+          });
+
+          let result = yield execa(EXECUTABLE_PATH, ['test']);
+          assert.equal(result.code, 0, 'exited with zero');
+        })
+      );
+
       QUnit.test(
         'transform should receive a file path in tests',
         wrap(function*(assert) {
@@ -295,10 +335,7 @@ QUnit.module('codemod-cli', function(hooks) {
       'works with globs',
       wrap(function*(assert) {
         userProject.write({
-          foo: {
-            'something.js': 'let blah = bar',
-            'other.js': 'let blah = bar',
-          },
+          foo: { 'something.js': 'let blah = bar', 'other.js': 'let blah = bar' },
         });
 
         yield execa(codemodProject.path('bin/cli.js'), ['main', 'foo/*thing.js']);
@@ -356,6 +393,49 @@ QUnit.module('codemod-cli', function(hooks) {
         })
       );
 
+      QUnit.test(
+        'runs transform with options',
+        wrap(function*(assert) {
+          codemodProject.write({
+            transforms: {
+              main: {
+                'index.js': `
+                  const { getParser } = require('codemod-cli').jscodeshift;
+                  const { getOptions } = require('codemod-cli');
+                  module.exports = function transformer(file, api) {
+                    const options = getOptions();
+                    const j = getParser(api);
+                    return j(file.source)
+                    .find(j.Literal)
+                    .forEach(path => {
+                      path.replace(
+                        j.stringLiteral(options.biz + options.baz)
+                      );
+                    })
+                    .toSource();
+                  }
+              `,
+              },
+            },
+          });
+          userProject.write({
+            foo: { 'something.js': `let blah = "bar";` },
+          });
+
+          yield CodemodCLI.runTransform(codemodProject.path('bin'), 'main', [
+            '--biz',
+            'A',
+            '--baz',
+            'B',
+            'foo/*ing.[jt]s',
+          ]);
+
+          assert.deepEqual(userProject.read(), {
+            foo: { 'something.js': `let blah = "AB";` },
+          });
+        })
+      );
+
       QUnit.test(
         'runs transform against class syntax',
         wrap(function*(assert) {