add babel-doctor

packages/babel-cli/src/babel-doctor/index.js

@@ -0,0 +1,94 @@
+import chalk from "chalk";
+import path from "path";
+import fs from "fs";
+import * as rules from "./rules";
+import symbols from "log-symbols";
+
+let didError = false;
+let lastWasSep = false;
+
+function sep() {
+  if (lastWasSep) return;
+  lastWasSep = true;
+
+  console.log();
+}
+
+function log(msg) {
+  lastWasSep = false;
+  console.log(msg);
+}
+
+//
+
+log("\n" + chalk.underline.yellow("Babel Doctor"));
+log("Running sanity checks on your system. This may take a few minutes...\n");
+
+//
+
+let packages = [];
+
+let nodeModulesDirectories = [
+  path.join(process.cwd(), "node_modules")
+];
+
+while (nodeModulesDirectories.length) {
+  let loc = nodeModulesDirectories.shift();
+  if (!fs.existsSync(loc)) continue;
+
+  let packagesNames: Array<string> = fs.readdirSync(loc);
+
+  for (let packageName of packagesNames) {
+    if (packageName[0] === ".") continue;
+
+    let packageLoc = path.join(loc, packageName);
+
+    packages.push({
+      name: packageName,
+      loc: packageLoc,
+      version: require(path.join(packageLoc, "package.json")).version
+    });
+
+    nodeModulesDirectories.push(path.join(packageLoc, "node_modules"));
+  }
+}
+
+//
+
+async function run() {
+  let promises = [];
+
+  for (let key in rules) {
+    if (key[0] === "_") continue;
+
+    let fn = rules[key];
+    promises.push(fn(packages));
+  }
+
+  let results = await Promise.all(promises);
+
+  for (let [success, message] of results) {
+    if (!success) didError = true;
+    let multiline = message.indexOf("\n") >= 0;
+    if (multiline) sep();
+    log(`${success ? symbols.success : symbols.error} ${message}`);
+    if (multiline) sep();
+  }
+
+  sep();
+
+  if (didError) {
+    log(chalk.red("Found potential issues on your machine :("));
+  } else {
+    log(chalk.green("Everything looks all right!"));
+  }
+
+  sep();
+}
+
+run().then(function () {
+  process.exit(0);
+}, function (err) {
+  console.error(err.stack);
+  process.exit(1);
+});

packages/babel-cli/src/babel-doctor/rules/deduped.js

@@ -0,0 +1,34 @@
+import path from "path";
+import fs from "fs";
+
+export default async function (packages) {
+  let foundDeps = {};
+  let foundDuplicated = false;
+  let duplicatedPackages = {};
+
+  function checkDep(name) {
+    if (name.indexOf("babel-") === 0 && foundDeps[name]) {
+      foundDuplicated = true;
+      duplicatedPackages[name] = (duplicatedPackages[name] || 0) + 1;
+    }
+
+    foundDeps[name] = true;
+  }
+
+  for (let pkg of packages) {
+    checkDep(pkg.name);
+  }
+
+  if (foundDuplicated) {
+    let msg = "Found these duplicate packages:\n\n";
+
+    for (let name in duplicatedPackages) {
+      msg += `- ${name} x ${duplicatedPackages[name]}\n`;
+    }
+
+    msg += "\nRecommend running `npm dedupe`";
+    return [false, msg];
+  } else {
+    return [true, "No duplicate babel packages found"];
+  }
+}

packages/babel-cli/src/babel-doctor/rules/has-config.js

@@ -0,0 +1,30 @@
+import path from "path";
+import fs from "fs";
+
+export default async function () {
+  let cwd = process.cwd();
+  let parts = cwd.split(path.sep);
+
+  let found = false;
+
+  do {
+    let loc = parts.join(path.sep);
+
+    let babelrc = path.join(loc, ".babelrc");
+    if (fs.existsSync(babelrc)) {
+      return [true, `Found config at ${babelrc}`];
+    }
+
+    let packagejson = path.join(loc, "package.json");
+    if (fs.existsSync(packagejson)) {
+      let pkg = require(packagejson);
+      if (pkg.babel) {
+        return [true, `Found config at ${packagejson}`];
+      }
+    }
+
+    parts.pop();
+  } while(parts.length);
+
+  return [false, "Found no .babelrc config"];
+}

packages/babel-cli/src/babel-doctor/rules/index.js

@@ -0,0 +1,3 @@
+export { default as hasConfig } from "./has-config";
+export { default as deduped } from "./deduped";
+export { default as latestPackages } from "./latest-packages";

packages/babel-cli/src/babel-doctor/rules/latest-packages.js

@@ -0,0 +1,53 @@
+import request from "request";
+import path from "path";
+
+let cache = {};
+
+function getInfo(packageName) {
+  if (cache[packageName]) {
+    return cache[packageName];
+  } else {
+    return cache[packageName] = new Promise(function (resolve, reject) {
+      request.get({
+        url: `https://registry.npmjs.org/${packageName}/latest`,
+        json: true
+      }, function (err, res, body) {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(cache[packageName] = body);
+        }
+      });
+    });
+  }
+}
+
+export default async function (packages) {
+  let filteredPackages = [];
+  let promises = [];
+
+  for (let pkg of packages) {
+    if (pkg.name.indexOf("babel-") !== 0) continue;
+
+    promises.push(getInfo(pkg.name));
+    filteredPackages.push(pkg);
+  }
+
+  let infos = await Promise.all(promises);
+  let messages = [];
+
+  for (let i = 0; i < infos.length; i++) {
+    let info = infos[i];
+    let pkg = filteredPackages[i];
+
+    if (info.version !== pkg.version) {
+      messages.push(`${pkg.name} - Latest is ${info.version}. Local version is ${pkg.version}`);
+    }
+  }
+
+  if (messages.length) {
+    return [false, `We found some outdated packages:\n\n- ${messages.join("\n- ")}`];
+  } else {
+    return [true, "All babel packages appear to be up to date"];
+  }
+}