Refactor CLI to use promises/async fns.

Author: loganfsmyth

packages/babel-cli/src/babel/dir.js

@@ -6,61 +6,62 @@ import fs from "fs";
 
 import * as util from "./util";
 
-let compiledFiles = 0;
-
-export default function({ cliOptions, babelOptions }) {
+export default async function({ cliOptions, babelOptions }) {
   const filenames = cliOptions.filenames;
 
-  function write(src, base, callback) {
+  async function write(src, base) {
     let relative = path.relative(base, src);
+
     if (!util.isCompilableExtension(relative, cliOptions.extensions)) {
-      return process.nextTick(callback);
+      return false;
     }
 
     // remove extension and then append back on .js
     relative = util.adjustRelative(relative, cliOptions.keepFileExtension);
 
     const dest = getDest(relative, base);
 
-    util.compile(
-      src,
-      defaults(
-        {
-          sourceFileName: slash(path.relative(dest + "/..", src)),
-        },
-        babelOptions,
-      ),
-      function(err, res) {
-        if (err && cliOptions.watch) {
-          console.error(err);
-          err = null;
-        }
-        if (err) return callback(err);
-        if (!res) return callback();
-
-        // we've requested explicit sourcemaps to be written to disk
-        if (
-          res.map &&
-          babelOptions.sourceMaps &&
-          babelOptions.sourceMaps !== "inline"
-        ) {
-          const mapLoc = dest + ".map";
-          res.code = util.addSourceMappingUrl(res.code, mapLoc);
-          res.map.file = path.basename(relative);
-          outputFileSync(mapLoc, JSON.stringify(res.map));
-        }
-
-        outputFileSync(dest, res.code);
-        util.chmod(src, dest);
-
-        compiledFiles += 1;
-
-        if (cliOptions.verbose) {
-          console.log(src + " -> " + dest);
-        }
-        return callback(null, true);
-      },
-    );
+    try {
+      const res = await util.compile(
+        src,
+        defaults(
+          {
+            sourceFileName: slash(path.relative(dest + "/..", src)),
+          },
+          babelOptions,
+        ),
+      );
+
+      if (!res) return false;
+
+      // we've requested explicit sourcemaps to be written to disk
+      if (
+        res.map &&
+        babelOptions.sourceMaps &&
+        babelOptions.sourceMaps !== "inline"
+      ) {
+        const mapLoc = dest + ".map";
+        res.code = util.addSourceMappingUrl(res.code, mapLoc);
+        res.map.file = path.basename(relative);
+        outputFileSync(mapLoc, JSON.stringify(res.map));
+      }
+
+      outputFileSync(dest, res.code);
+      util.chmod(src, dest);
+
+      if (cliOptions.verbose) {
+        console.log(src + " -> " + dest);
+      }
+
+      return true;
+    } catch (err) {
+      if (cliOptions.watch) {
+        console.error(err);
+        return false;
+      }
+
+      throw err;
+    }
   }
 
   function getDest(filename, base) {
@@ -77,84 +78,62 @@ export default function({ cliOptions, babelOptions }) {
     }
   }
 
-  function handleFile(src, base, callback) {
-    write(src, base, function(err, res) {
-      if (err) return callback(err);
-      if (!res && cliOptions.copyFiles) {
-        const filename = path.relative(base, src);
-        const dest = getDest(filename, base);
-        outputFileSync(dest, fs.readFileSync(src));
-        util.chmod(src, dest);
-      }
-
-      return callback();
-    });
-  }
-
-  function sequentialHandleFile(files, dirname, index, callback) {
-    if (files.length === 0) {
-      outputDestFolder(cliOptions.outDir);
-      return;
-    }
+  async function handleFile(src, base) {
+    const written = await write(src, base);
 
-    if (typeof index === "function") {
-      callback = index;
-      index = 0;
+    if (!written && cliOptions.copyFiles) {
+      const filename = path.relative(base, src);
+      const dest = getDest(filename, base);
+      outputFileSync(dest, fs.readFileSync(src));
+      util.chmod(src, dest);
     }
+    return written;
+  }
 
-    const filename = files[index];
-    const src = path.join(dirname, filename);
+  async function handle(filenameOrDir) {
+    if (!fs.existsSync(filenameOrDir)) return 0;
 
-    handleFile(src, dirname, function(err) {
-      if (err) return callback(err);
-      index++;
-      if (index !== files.length) {
-        sequentialHandleFile(files, dirname, index, callback);
-      } else {
-        callback();
-      }
-    });
-  }
+    const stat = fs.statSync(filenameOrDir);
 
-  function handle(filename, callback) {
-    if (!fs.existsSync(filename)) return;
+    if (stat.isDirectory(filenameOrDir)) {
+      const dirname = filenameOrDir;
 
-    const stat = fs.statSync(filename);
+      let count = 0;
 
-    if (stat.isDirectory(filename)) {
-      const dirname = filename;
+      const files = util.readdir(dirname, cliOptions.includeDotfiles);
+      for (const filename of files) {
+        const src = path.join(dirname, filename);
 
-      if (cliOptions.deleteDirOnStart) {
-        util.deleteDir(cliOptions.outDir);
+        const written = await handleFile(src, dirname);
+        if (written) count += 1;
       }
 
-      const files = util.readdir(dirname, cliOptions.includeDotfiles);
-      sequentialHandleFile(files, dirname, callback);
+      return count;
     } else {
-      write(filename, path.dirname(filename), callback);
-    }
-  }
+      const filename = filenameOrDir;
+      const written = await handleFile(filename, path.dirname(filename));
 
-  function sequentialHandle(filenames, index = 0) {
-    const filename = filenames[index];
-
-    handle(filename, function(err) {
-      if (err) throw new Error(err);
-      index++;
-      if (index !== filenames.length) {
-        sequentialHandle(filenames, index);
-      } else {
-        console.log(
-          `🎉  Successfully compiled ${compiledFiles} ${
-            compiledFiles > 1 ? "files" : "file"
-          } with Babel.`,
-        );
-      }
-    });
+      return written ? 1 : 0;
+    }
   }
 
   if (!cliOptions.skipInitialBuild) {
-    sequentialHandle(filenames);
+    if (cliOptions.deleteDirOnStart) {
+      util.deleteDir(cliOptions.outDir);
+    }
+
+    outputDestFolder(cliOptions.outDir);
+
+    let compiledFiles = 0;
+    for (const filename of cliOptions.filenames) {
+      compiledFiles += await handle(filename);
+    }
+
+    console.log(
+      `🎉  Successfully compiled ${compiledFiles} ${
+        compiledFiles !== 1 ? "files" : "file"
+      } with Babel.`,
+    );
   }
 
   if (cliOptions.watch) {
@@ -177,10 +156,9 @@ export default function({ cliOptions, babelOptions }) {
             filename === filenameOrDir
               ? path.dirname(filenameOrDir)
               : filenameOrDir,
-            function(err) {
-              if (err) console.error(err.stack);
-            },
-          );
+          ).catch(err => {
+            console.error(err);
+          });
         });
       });
     });