Updated update-docs command to respect mixed file type extensions

- This is needed when working on transforms that require different i/o file types
- The regex is used to only process files with 'input.' or 'output.' in their filename. For some reason lookbehind groups are deemed invalid by eslint, which should be supported in these v
ersions of node, but I wasn't able to get eslint to accept it. It would provide an additional layer of accuracy by ensuring a '.input.' pattern, but I feel confident that the lookahead is
safe to use given the relatively structured nature of fixture filenames.

Author: Joshua Lawrence

commands/local/update-docs.js

@@ -40,30 +40,46 @@ function updateTransformREADME(transformName) {
     return;
   }
 
-  fs.readdirSync(fixtureDir)
-    .filter(filename => /\.input$/.test(path.basename(filename, path.extname(filename))))
-    .forEach(filename => {
-      let extension = path.extname(filename);
-      let testName = filename.replace(`.input${extension}`, '');
-      let inputPath = path.join(fixtureDir, `${testName}.input${extension}`);
-      let outputPath = path.join(fixtureDir, `${testName}.output${extension}`);
-
-      toc.push(`* [${testName}](#${testName})`);
-      details.push(
-        '---',
-        `<a id="${testName}">**${testName}**</a>`,
-        '',
-        `**Input** (<small>[${testName}.input${extension}](${inputPath})</small>):`,
-        '```' + extension.slice(1),
-        fs.readFileSync(inputPath),
-        '```',
-        '',
-        `**Output** (<small>[${testName}.output${extension}](${outputPath})</small>):`,
-        '```' + extension.slice(1),
-        fs.readFileSync(outputPath),
-        '```'
-      );
-    });
+  const testMap = fs.readdirSync(fixtureDir).reduce((_hash, filename) => {
+    const extension = path.extname(filename);
+    const validFilename = path.basename(filename).match(/input|output+(?=\.)/);
+    if (!validFilename) {
+      return _hash;
+    }
+    const testName = filename.slice(0, validFilename.index - 1);
+    const testType = validFilename[0];
+
+    if (!_hash[testName]) {
+      _hash[testName] = {};
+    }
+
+    _hash[testName][testType] = `${testName}.${testType}${extension}`;
+
+    return _hash;
+  }, {});
+
+  Object.entries(testMap).forEach(([testName, testPaths]) => {
+    let inputExtension = path.extname(testPaths.input);
+    let outputExtension = path.extname(testPaths.output);
+    let inputPath = path.join(fixtureDir, testPaths.input);
+    let outputPath = path.join(fixtureDir, testPaths.output);
+
+    toc.push(`* [${testName}](#${testName})`);
+    details.push(
+      '---',
+      `<a id="${testName}">**${testName}**</a>`,
+      '',
+      `**Input** (<small>[${testPaths.input}](${inputPath})</small>):`,
+      '```' + inputExtension.slice(1),
+      fs.readFileSync(inputPath),
+      '```',
+      '',
+      `**Output** (<small>[${testPaths.output}](${outputPath})</small>):`,
+      '```' + outputExtension.slice(1),
+      fs.readFileSync(outputPath),
+      '```'
+    );
+  });
 
   let transformREADMEPath = `transforms/${transformName}/README.md`;
 

tests/cli-test.js

@@ -105,6 +105,37 @@ QUnit.module('codemod-cli', function(hooks) {
       assert.ok(README.includes('* [foo](transforms/foo/README.md'), 'foo link');
       assert.ok(README.includes('* [bar](transforms/bar/README.md'), 'bar link');
     });
+
+    QUnit.test('should allow different input/output extensions', async function(assert) {
+      codemodProject.write({
+        transforms: {
+          main: {
+            __testfixtures__: {
+              'basic.input.js': '"starting content";',
+              'basic.output.hbs': '"different content";',
+            },
+            'README.md': `
+              <!--FIXTURES_TOC_START-->
+              <!--FIXTURES_TOC_END-->
+              <!--FIXTURES_CONTENT_START-->
+              <!--FIXTURES_CONTENT_END-->
+            `,
+          },
+        },
+      });
+
+      await execa(EXECUTABLE_PATH, ['update-docs']);
+
+      let README = fs.readFileSync(codemodProject.path('transforms/main/README.md'), 'utf8');
+      assert.ok(
+        README.includes('[basic.input.js](transforms/main/__testfixtures__/basic.input.js)'),
+        'input link'
+      );
+      assert.ok(
+        README.includes('[basic.output.hbs](transforms/main/__testfixtures__/basic.output.hbs)'),
+        'output link'
+      );
+    });
   });
 
   QUnit.module('generate', function(hooks) {
@@ -687,18 +718,18 @@ QUnit.module('codemod-cli', function(hooks) {
                   module.exports = function ({ source /*, path*/ }, { parse, visit }) {
                     const ast = parse(source);
                     const options = getOptions();
-                  
+
                     return visit(ast, (env) => {
                       let { builders: b } = env.syntax;
-                  
+
                       return {
                         MustacheStatement() {
                           return b.mustache(b.path(options.biz + options.baz));
                         },
                       };
                     });
                   };
-                  
+
                   module.exports.type = 'hbs';
               `,
             },