invig/lib/Invig.js

'use strict';

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var scrolex = require('scrolex');
var globby = require('globby');
var debug = require('depurar')('invig');
var applyEachSeries = require('async/applyEachSeries');
var queue = require('async/queue');
var waterfall = require('async/waterfall');
var path = require('path');
var fs = require('fs');
var pkgUp = require('pkg-up');

var Invig = function () {
  function Invig() {
    var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

    _classCallCheck(this, Invig);

    this.opts = opts;
  }

  _createClass(Invig, [{
    key: 'initProject',
    value: function initProject(files, cb) {
      var projectPackage = require(this._projectPackagePath);
      var projectRoot = path.dirname(this._projectPackagePath);
      var projectRootRel = path.relative(process.cwd(), projectRoot) || '.';
      var invigRoot = __dirname + '/..';
      // const invigRootRel = path.relative(process.cwd(), invigRoot)
      var invigPackage = require(invigRoot + '/package.json');
      var npmInstallNeeded = [];

      scrolex.stick('Adding npm task project config', { components: 'invig>' + projectRootRel });
      if (this.opts.dryrun === false) {
        if (!projectPackage.scripts) {
          projectPackage.scripts = {};
        }
        if (!projectPackage.scripts.lint) {
          projectPackage.scripts.lint = 'eslint .';
        }
        if (!projectPackage.scripts.fix) {
          projectPackage.scripts.fix = 'eslint . --fix';
        }
        if (!projectPackage.scripts.build) {
          projectPackage.scripts.build = 'babel src --source-maps --out-dir lib';
          if (!projectPackage.scripts['build:watch']) {
            projectPackage.scripts['build:watch'] = 'babel src --watch --source-maps --out-dir lib';
          }
        }
      }

      scrolex.stick('Adding dependencies task project config', { components: 'invig>' + projectRootRel });
      if (this.opts.dryrun === false) {
        if (!projectPackage.dependencies) {
          projectPackage.dependencies = {};
        }
        if (!projectPackage.devDependencies) {
          projectPackage.devDependencies = {};
        }

        for (var name in invigPackage.dependencies) {
          if (name.match(/^(babel|eslint|es6-promise)/)) {
            if (projectPackage.devDependencies[name] !== invigPackage.dependencies[name]) {
              projectPackage.devDependencies[name] = invigPackage.dependencies[name];
              npmInstallNeeded.push('Add ' + name + ' to devDependencies');
            }
          }
        }

        var removeDeps = ['coffee-script', 'coffeelint'];
        removeDeps.forEach(function (name) {
          if (projectPackage.dependencies[name]) {
            delete projectPackage.dependencies[name];
            npmInstallNeeded.push('Remove ' + name + ' from dependencies');
          }
          if (projectPackage.devDependencies[name]) {
            delete projectPackage.devDependencies[name];
            npmInstallNeeded.push('Remove ' + name + ' from devDependencies');
          }
        });
      }

      scrolex.stick('Writing eslint project config', { components: 'invig>' + projectRootRel });
      if (this.opts.dryrun === false) {
        this.copySyncNoOverwrite(invigRoot + '/.eslintrc', projectRoot + '/.eslintrc');
      }

      scrolex.stick('Writing babel project config', { components: 'invig>' + projectRootRel });
      if (this.opts.dryrun === false) {
        this.copySyncNoOverwrite(invigRoot + '/.babelrc', projectRoot + '/.babelrc');
      }

      scrolex.stick('Writing eslint ignores', { components: 'invig>' + projectRootRel });
      if (this.opts.dryrun === false) {
        this.copySyncNoOverwrite(invigRoot + '/.eslintignore', projectRoot + '/.eslintignore');
      }

      scrolex.stick('Writing back project config ', { components: 'invig>' + projectRootRel });
      fs.writeFileSync(this._projectPackagePath, JSON.stringify(projectPackage, null, 2), 'utf-8');

      if (npmInstallNeeded.length > 0) {
        scrolex.stick('Running npm install to accomodate these changes: ' + npmInstallNeeded.join('. '), { components: 'invig>' + projectRootRel });
        var cmd = 'yarn || npm install';
        scrolex.exe(cmd, { cwd: this._projectDir, components: 'invig>' + projectRootRel }, function (err) {
          return cb(err, files);
        });
      } else {
        return cb(null, files);
      }
    }
  }, {
    key: 'toJs',
    value: function toJs(srcPath, cb) {
      var cmd = this.opts.npmBinDir + '/decaffeinate --loose-includes --loose-for-of --allow-invalid-constructors --keep-commonjs --prefer-const --loose-default-params ' + srcPath + ' && rm -f ' + srcPath;
      scrolex.exe(cmd, { cwd: this._projectDir, components: 'invig>' + path.relative(process.cwd(), srcPath) }, cb);
    }
  }, {
    key: 'toEs6',
    value: function toEs6(srcPath, cb) {
      srcPath = srcPath.replace(/\.coffee$/, '.js');
      var safe = ['arrow', 'for-of', 'for-each', 'arg-rest', 'arg-spread', 'obj-method', 'obj-shorthand', 'no-strict',
      // 'commonjs',
      // 'exponent',
      'multi-var'];
      var unsafe = ['let', 'class', 'template', 'default-param',
      // 'includes'
      'destruct-param'];

      var list = [].concat(safe, unsafe).join(',');

      var moveCommandWin = 'move /y ' + srcPath.replace(/\//g, '\\') + '.es6 ' + srcPath.replace(/\//g, '\\');
      var moveCommandOthers = 'mv -f ' + srcPath + '.es6 ' + srcPath;
      var moveCommand = /^win/.test(process.platform) ? moveCommandWin : moveCommandOthers;

      var cmd = this.opts.npmBinDir + '/lebab --transform=' + list + ' ' + srcPath + ' --out-file ' + srcPath + '.es6 && ' + moveCommand;

      scrolex.exe(cmd, { cwd: this._projectDir, components: 'invig>' + path.relative(process.cwd(), srcPath) }, cb);
    }
  }, {
    key: 'toPrettier',
    value: function toPrettier(srcPath, cb) {
      srcPath = srcPath.replace(/\.coffee$/, '.js');
      var cmd = this.opts.npmBinDir + '/prettier --single-quote --print-width 180 --write ' + srcPath;
      scrolex.exe(cmd, { cwd: this._projectDir, components: 'invig>' + path.relative(process.cwd(), srcPath) }, cb);
    }
  }, {
    key: 'toEslintStandard',
    value: function toEslintStandard(srcPath, cb) {
      srcPath = srcPath.replace(/\.coffee$/, '.js');
      var cmd = this.opts.npmBinDir + '/eslint --config ' + this._projectDir + '/.eslintrc --fix ' + srcPath;
      scrolex.exe(cmd, { cwd: this._projectDir, components: 'invig>' + path.relative(process.cwd(), srcPath) }, cb);
    }
  }, {
    key: 'convertFile',
    value: function convertFile(srcPath, cb) {
      var fns = [];
      var extension = path.extname(srcPath).toLowerCase();

      if (extension === '.coffee') {
        fns.push(this.toJs.bind(this));
      }
      fns.push(this.toEs6.bind(this));
      fns.push(this.toPrettier.bind(this));
      fns.push(this.toEslintStandard.bind(this));

      applyEachSeries(fns, srcPath, cb);
    }
  }, {
    key: 'findFiles',
    value: function findFiles(cb) {
      var files = [];
      var stat = {};
      try {
        stat = fs.lstatSync(this.opts.src);
      } catch (e) {
        stat = false;
      }

      // let relative
      if (stat && stat.isFile()) {
        // File
        var resolve = path.resolve(this.opts.src);
        files = [resolve];
      } else if (stat && stat.isDirectory()) {
        // Directory
        var _resolve = path.resolve(this.opts.src);
        files = globby.sync([_resolve + '/**/*.coffee', _resolve + '/**/*.es5', _resolve + '/**/*.es6', _resolve + '/**/*.js', '!' + _resolve + '/node_modules/**']);
      } else {
        // Pattern
        files = globby.sync(this.opts.src);
      }
      if (!files || files.length === 0) {
        return cb(new Error('Source argument: "' + this.opts.src + '" returned no input files to work on.'));
      }

      return cb(null, files);
    }
  }, {
    key: 'copySyncNoOverwrite',
    value: function copySyncNoOverwrite(src, dst) {
      if (!fs.existsSync(dst)) {
        fs.writeFileSync(dst, fs.readFileSync(src, 'utf-8'), 'utf-8');
      }
    }
  }, {
    key: 'findProject',
    value: function findProject(files, cb) {
      this._projectPackagePath = pkgUp.sync(path.dirname(files[0]));

      if (!this._projectPackagePath) {
        return cb(new Error('No package.json found, unable to establish project root. '));
      }

      this._projectDir = path.dirname(this._projectPackagePath);
      return cb(null, files);
    }
  }, {
    key: 'processFiles',
    value: function processFiles(files, cb) {
      var q = queue(this.convertFile.bind(this), this.opts.concurrency);
      q.push(files);
      q.drain = function () {
        return cb(null, files);
      };
    }
  }, {
    key: 'upgradeDeps',
    value: function upgradeDeps(files, cb) {
      if (this.opts.check) {
        scrolex.exe(this.opts.npmBinDir + '/npm-check ' + this._projectDir, { cwd: this._projectDir, components: 'invig>' + path.relative(process.cwd(), this._projectDir) }, function (err, stdout) {
          if (err) {
            return cb(err);
          }
          return cb(null);
        });
      } else {
        return cb(null);
      }
    }
  }, {
    key: 'runOnStdIn',
    value: function runOnStdIn(stdin, cb) {
      var _this = this;

      this._projectDir = __dirname + '/..';
      var coffeePath = __dirname + '/tmpFile.coffee';
      var jsPath = __dirname + '/tmpFile.js';

      fs.writeFileSync('' + coffeePath, stdin, 'utf-8');
      scrolex.persistOpts({ mode: 'silent' });

      this.toJs(coffeePath, function (err) {
        if (err) {
          // Assume this was a JS snippet on STDIN already
          fs.writeFileSync('' + jsPath, fs.readFileSync('' + coffeePath, 'utf-8'), 'utf-8');
        }
        _this.convertFile(jsPath, function (err) {
          debug(err);
          process.stdout.write(fs.readFileSync('' + jsPath, 'utf-8'));
          try {
            fs.unlinkSync('' + jsPath);
            fs.unlinkSync('' + coffeePath);
          } catch (e) {}

          return cb(null);
        });
      });
    }
  }, {
    key: 'runOnPattern',
    value: function runOnPattern(cb) {
      waterfall([this.findFiles.bind(this), this.findProject.bind(this), this.initProject.bind(this), this.processFiles.bind(this), this.upgradeDeps.bind(this)], cb);
    }
  }]);

  return Invig;
}();

module.exports = Invig;
//# sourceMappingURL=Invig.js.map