john-test-upgrade/lib/index.js

Upgrade tool for Babel

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } } function _next(value) { step("next", value); } function _throw(err) { step("throw", err); } _next(); }); }; }

var globby = require('globby');

var path = require('path');

var readPkgUp = require('read-pkg-up');

var sortKeys = require('sort-keys');

var fs = require('fs');

var pify = require('pify');

var JSON5 = require('json5');

var writeJsonFile = require('write-json-file');

var semver = require('semver');

var writeFile = require('write');

var upgradeDeps = require('./upgradeDeps');

var upgradeConfig = require('./upgradeConfig');

var installDeps = require('./installDeps');

function isAcceptedNodeVersion() {
  return semver.satisfies(process.version, '>= 4');
}

function getLatestVersion() {
  return "7.0.0-beta.39";
}

function replaceMocha(str) {
  return str.replace('--compilers js:babel-core/register', '--compilers js:@babel/register').replace('--compilers js:babel-register', '--compilers js:@babel/register').replace('--require babel-register', '--require @babel/register').replace('--require babel-polyfill', '--require @babel/polyfill');
}

function upgradeScripts(scripts) {
  var _arr = Object.keys(scripts);

  for (var _i = 0; _i < _arr.length; _i++) {
    var script = _arr[_i];
    scripts[script] = replaceMocha(scripts[script]);
  }

  return scripts;
}

function updatePackageJSON(_x) {
  return _updatePackageJSON.apply(this, arguments);
}

function _updatePackageJSON() {
  _updatePackageJSON = _asyncToGenerator(
  /*#__PURE__*/
  regeneratorRuntime.mark(function _callee(pkg) {
    var flowConfigs, upgradeDepOptions, devDeps;
    return regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            if (process.env.NODE_ENV !== 'test') {
              console.log("Updating closest package.json dependencies");
            }

            if (!pkg) {
              console.log("package.json not found");
              process.exit(1);
            }

            if (pkg.scripts) {
              pkg.scripts = upgradeScripts(pkg.scripts);

              if (Object.values(pkg.scripts).some(function (s) {
                return s.includes('babel-node');
              })) {
                if (pkg.devDependencies) {
                  pkg.devDependencies["@babel/node"] = getLatestVersion();
                }
              }
            }

            _context.next = 5;
            return globby(['**/.flowconfig', '!./node_modules/**']);

          case 5:
            flowConfigs = _context.sent;
            upgradeDepOptions = {
              hasFlow: flowConfigs.length > 0
            };

            if (pkg.devDependencies) {
              pkg.devDependencies = upgradeDeps(pkg.devDependencies, getLatestVersion(), upgradeDepOptions);
              devDeps = Object.keys(pkg.devDependencies); // use babel-bridge for jest
              // maybe should do this for other tools?

              if (devDeps.includes("jest") && !devDeps.includes("babel-core")) {
                pkg.devDependencies["babel-core"] = "^7.0.0-bridge.0";
              }

              pkg.devDependencies = sortKeys(pkg.devDependencies);
            }

            if (pkg.dependencies) {
              pkg.dependencies = sortKeys(upgradeDeps(pkg.dependencies, getLatestVersion(), upgradeDepOptions));
            }

            return _context.abrupt("return", pkg);

          case 10:
          case "end":
            return _context.stop();
        }
      }
    }, _callee, this);
  }));
  return _updatePackageJSON.apply(this, arguments);
}

function writePackageJSON() {
  return _writePackageJSON.apply(this, arguments);
}

function _writePackageJSON() {
  _writePackageJSON = _asyncToGenerator(
  /*#__PURE__*/
  regeneratorRuntime.mark(function _callee2() {
    var _ref, pkg, path;

    return regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            _context2.next = 2;
            return readPkgUp({
              normalize: false
            });

          case 2:
            _ref = _context2.sent;
            pkg = _ref.pkg;
            path = _ref.path;
            _context2.next = 7;
            return updatePackageJSON(pkg);

          case 7:
            pkg = _context2.sent;

            if (pkg.babel) {
              console.log("Updating package.json 'babel' config");
              pkg.babel = upgradeConfig(pkg.babel);
            }

            _context2.next = 11;
            return writeJsonFile(path, pkg, {
              detectIndent: true
            });

          case 11:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2, this);
  }));
  return _writePackageJSON.apply(this, arguments);
}

function readBabelRC(_x2) {
  return _readBabelRC.apply(this, arguments);
}

function _readBabelRC() {
  _readBabelRC = _asyncToGenerator(
  /*#__PURE__*/
  regeneratorRuntime.mark(function _callee3(configPath) {
    var rawFile;
    return regeneratorRuntime.wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            _context3.prev = 0;
            _context3.next = 3;
            return pify(fs.readFile)(configPath);

          case 3:
            rawFile = _context3.sent.toString('utf8');
            return _context3.abrupt("return", JSON5.parse(rawFile));

          case 7:
            _context3.prev = 7;
            _context3.t0 = _context3["catch"](0);
            throw new Error(`babel-upgrade: ${configPath} does not contain a valid .babelrc file. ${_context3.t0.stack}`);

          case 10:
          case "end":
            return _context3.stop();
        }
      }
    }, _callee3, this, [[0, 7]]);
  }));
  return _readBabelRC.apply(this, arguments);
}

function writeBabelRC(_x3) {
  return _writeBabelRC.apply(this, arguments);
}

function _writeBabelRC() {
  _writeBabelRC = _asyncToGenerator(
  /*#__PURE__*/
  regeneratorRuntime.mark(function _callee4(configPath) {
    var json;
    return regeneratorRuntime.wrap(function _callee4$(_context4) {
      while (1) {
        switch (_context4.prev = _context4.next) {
          case 0:
            _context4.prev = 0;
            _context4.next = 3;
            return readBabelRC(configPath);

          case 3:
            json = _context4.sent;
            _context4.next = 8;
            break;

          case 6:
            _context4.prev = 6;
            _context4.t0 = _context4["catch"](0);

          case 8:
            if (!json) {
              _context4.next = 13;
              break;
            }

            console.log(`Updating .babelrc config at ${configPath}`);
            json = upgradeConfig(json);
            _context4.next = 13;
            return writeJsonFile(configPath, json, {
              detectIndent: true
            });

          case 13:
          case "end":
            return _context4.stop();
        }
      }
    }, _callee4, this, [[0, 6]]);
  }));
  return _writeBabelRC.apply(this, arguments);
}

function writeMochaOpts(_x4) {
  return _writeMochaOpts.apply(this, arguments);
}

function _writeMochaOpts() {
  _writeMochaOpts = _asyncToGenerator(
  /*#__PURE__*/
  regeneratorRuntime.mark(function _callee5(configPath) {
    var rawFile;
    return regeneratorRuntime.wrap(function _callee5$(_context5) {
      while (1) {
        switch (_context5.prev = _context5.next) {
          case 0:
            _context5.next = 2;
            return pify(fs.readFile)(configPath);

          case 2:
            rawFile = _context5.sent.toString('utf8');
            _context5.next = 5;
            return writeFile(configPath, replaceMocha(rawFile));

          case 5:
          case "end":
            return _context5.stop();
        }
      }
    }, _callee5, this);
  }));
  return _writeMochaOpts.apply(this, arguments);
}

module.exports = {
  isAcceptedNodeVersion,
  updatePackageJSON,
  writePackageJSON,
  readBabelRC,
  writeBabelRC,
  getLatestVersion,
  writeMochaOpts,
  installDeps
};