@buildo/hophop/lib/utils/index.js

A minimal tool to accelerate the GitHub workflow from the command line.

'use strict';

var _Promise = require('babel-runtime/core-js/promise')['default'];

var _regeneratorRuntime = require('babel-runtime/regenerator')['default'];

var _interopRequireDefault = require('babel-runtime/helpers/interop-require-default')['default'];

exports.__esModule = true;

var _argparse = require('argparse');

var _lodash = require('lodash');

var _ramda = require('ramda');

var _ramda2 = _interopRequireDefault(_ramda);

var _octonode = require('octonode');

var _octonode2 = _interopRequireDefault(_octonode);

var _child_process = require('child_process');

var _child_process2 = _interopRequireDefault(_child_process);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _es6Promisify = require('es6-promisify');

var _es6Promisify2 = _interopRequireDefault(_es6Promisify);

var _semver = require('semver');

var _semver2 = _interopRequireDefault(_semver);

var _inquirer = require('inquirer');

var _inquirer2 = _interopRequireDefault(_inquirer);

var _cliColor = require('cli-color');

var _cliColor2 = _interopRequireDefault(_cliColor);

var cmdoutc = _cliColor2['default'].blackBright;
var issuec = _cliColor2['default'].bold;
var warning = _cliColor2['default'].xterm(184);

function log(l) {
  console.log(l); // eslint-disable-line no-console
}

function error(e) {
  console.error(e); // eslint-disable-line no-console
}

function rlinterface() {
  return {
    question: function question(_question, defaultInput) {
      return new _Promise(function (resolve) {
        var qName = _question.name || _lodash.uniqueId('question_');
        var enhancedQ = _lodash.assign({}, {
          type: 'input',
          name: qName,
          'default': defaultInput || null
        }, _question);

        _inquirer2['default'].prompt([enhancedQ], function (a) {
          return resolve(a[qName]);
        });
      });
    },
    yesOrNoQuestion: function yesOrNoQuestion(message, defaultInput) {
      return new _Promise(function (resolve) {
        var enhancedQ = {
          message: message + ' (y/n)',
          name: _lodash.uniqueId('yes_or_no_question_'),
          type: 'input',
          'default': defaultInput || 'n'
        };

        _inquirer2['default'].prompt([enhancedQ], function (a) {
          return resolve(a[enhancedQ.name]);
        });
      });
    }
  };
}
var rl = rlinterface();

var exec = function exec(cmd) {
  return new _Promise(function (resolve) {
    return _child_process2['default'].exec(cmd, function (err, o, i) {
      if (!!err) throw err;
      resolve({ stdout: o, stderr: i });
    });
  });
};

var execF = function execF(cmd) {
  return new _Promise(function (resolve) {
    return _child_process2['default'].exec(cmd, function (err, o, i) {
      resolve({ err: err, stdout: o, stderr: i });
    });
  });
};

var enterpriseRepos = {
  'buildo/labonline': {
    apiEndpoint: 'github.omnilab.our.buildo.io/api/v3',
    githubURL: 'github.omnilab.our.buildo.io',
    accountName: 'omnilab'
  }
};

function origin() {
  var _origin;

  return _regeneratorRuntime.async(function origin$(context$1$0) {
    while (1) switch (context$1$0.prev = context$1$0.next) {
      case 0:
        context$1$0.next = 2;
        return _regeneratorRuntime.awrap(exec('git remote -v | grep origin | grep fetch'));

      case 2:
        _origin = context$1$0.sent.stdout.replace('\t', ' ').replace('\n', '').split(' ');
        return context$1$0.abrupt('return', _origin[1].replace('.git', '').split(':')[1]);

      case 4:
      case 'end':
        return context$1$0.stop();
    }
  }, null, this);
}

function currBranch() {
  var o;
  return _regeneratorRuntime.async(function currBranch$(context$1$0) {
    while (1) switch (context$1$0.prev = context$1$0.next) {
      case 0:
        context$1$0.next = 2;
        return _regeneratorRuntime.awrap(exec('git rev-parse --abbrev-ref HEAD'));

      case 2:
        o = context$1$0.sent.stdout;
        return context$1$0.abrupt('return', o.split('\n')[0]);

      case 4:
      case 'end':
        return context$1$0.stop();
    }
  }, null, this);
}

var issuesLabelMapper = function issuesLabelMapper(issues) {
  return issues.map(function (i) {
    return { name: issuec(i.number) + '\t' + i.title, value: i.number };
  });
};

function slugify(s) {
  var fullSlug = s.toLowerCase().replace(/[^\w ]+/g, '').replace(/ +/g, '_');
  var shortSlugify = _ramda2['default'].compose(_ramda2['default'].join('_'), _ramda2['default'].take(4), _ramda2['default'].split('_'));
  return shortSlugify(fullSlug);
}

function gh_token_file_name(gheAccountName) {
  var prefix = '.hophop_gh_token';
  return gheAccountName ? prefix + '_' + gheAccountName : prefix;
}

function gh_token(gheAccountName) {
  var fileName = gh_token_file_name(gheAccountName);
  return _fs2['default'].readFileSync(process.env.HOME + '/' + fileName, 'utf8');
}

function gh_helper() {
  var repo_name, config, _enterpriseRepos$repo_name, apiEndpoint, accountName, client, repo;

  return _regeneratorRuntime.async(function gh_helper$(context$1$0) {
    while (1) switch (context$1$0.prev = context$1$0.next) {
      case 0:
        context$1$0.next = 2;
        return _regeneratorRuntime.awrap(origin());

      case 2:
        repo_name = context$1$0.sent;
        config = {};
        _enterpriseRepos$repo_name = enterpriseRepos[repo_name];
        _enterpriseRepos$repo_name = _enterpriseRepos$repo_name === undefined ? {} : _enterpriseRepos$repo_name;
        apiEndpoint = _enterpriseRepos$repo_name.apiEndpoint;
        accountName = _enterpriseRepos$repo_name.accountName;

        if (apiEndpoint) {
          config.hostname = apiEndpoint;
        }
        client = _octonode2['default'].client(gh_token(accountName), config);

        // FIXME(gabro): this is here because omnilab's github SSL cert is currently self-signed
        if (apiEndpoint) {
          client.requestDefaults.rejectUnhauthorized = false;
          client.requestDefaults.strictSSL = false;
        }

        repo = client.repo(repo_name);
        return context$1$0.abrupt('return', { repo_name: repo_name, client: client, repo: repo });

      case 13:
      case 'end':
        return context$1$0.stop();
    }
  }, null, this);
}

function gh_me(client) {
  var clientMe, me;
  return _regeneratorRuntime.async(function gh_me$(context$1$0) {
    while (1) switch (context$1$0.prev = context$1$0.next) {
      case 0:
        clientMe = client.me();
        context$1$0.prev = 1;
        context$1$0.next = 4;
        return _regeneratorRuntime.awrap(_es6Promisify2['default'](clientMe.info.bind(clientMe))());

      case 4:
        me = context$1$0.sent;
        return context$1$0.abrupt('return', me);

      case 8:
        context$1$0.prev = 8;
        context$1$0.t0 = context$1$0['catch'](1);

        error(context$1$0.t0);

      case 11:
      case 'end':
        return context$1$0.stop();
    }
  }, null, this, [[1, 8]]);
}

function checkForUpdates() {
  var latestVersion, installedVersion;
  return _regeneratorRuntime.async(function checkForUpdates$(context$1$0) {
    while (1) switch (context$1$0.prev = context$1$0.next) {
      case 0:
        context$1$0.next = 2;
        return _regeneratorRuntime.awrap(exec('npm view @buildo/hophop version'));

      case 2:
        latestVersion = context$1$0.sent.stdout.replace(/\n/g, '');
        context$1$0.next = 5;
        return _regeneratorRuntime.awrap(exec('npm list -g --depth=0 @buildo/hophop | grep hophop | cut -d@ -f3'));

      case 5:
        installedVersion = context$1$0.sent.stdout.replace(/\n/g, '');

        if (_semver2['default'].gt(latestVersion, installedVersion)) {
          log('\n    -------------------------------------------------------\n    |  A new version of hophop is available! Update with  |\n    |                                                     |\n    |           npm install -g @buildo/hophop             |\n    |                                                     |\n    -------------------------------------------------------\n    ');
        }

      case 7:
      case 'end':
        return context$1$0.stop();
    }
  }, null, this);
}

function parseArgs() {
  var parser = new _argparse.ArgumentParser({
    version: '0.0.1',
    addHelp: true,
    description: 'Argparse example'
  });

  var subparsers = parser.addSubparsers({
    title: 'subcommand',
    dest: 'cmd'
  });

  var gh = subparsers.addParser('gh', { addHelp: true });
  var toggl = subparsers.addParser('toggl', { addHelp: true });

  var gh_sp = gh.addSubparsers({
    title: 'gh',
    dest: 'cmd_gh'
  });

  var toggl_sp = toggl.addSubparsers({
    title: 'toggl',
    dest: 'cmd_toggl'
  });

  gh_sp.addParser('pr', { addHelp: true });
  var gh_feature_sp = gh_sp.addParser('feature', { addHelp: true });
  gh_feature_sp.addArgument(['issueNumber'], { nargs: '?' });
  gh_sp.addParser('setup', { addHelp: true });
  var gh_setup_sp = gh_sp.addParser('setup', { addHelp: true });
  gh_setup_sp.addArgument(['gheAccountName'], { nargs: '?' });
  gh_sp.addParser('commit', { addHelp: true });

  toggl_sp.addParser('setup', { addHelp: true });
  toggl_sp.addParser('start', { addHelp: true });
  toggl_sp.addParser('stop', { addHelp: true });
  toggl_sp.addParser('install-hooks', { addHelp: true });

  return parser.parseArgs();
}

exports['default'] = {
  rl: rl,
  exec: exec, execF: execF,
  currBranch: currBranch,
  issuesLabelMapper: issuesLabelMapper,
  slugify: slugify,
  gh_helper: gh_helper,
  gh_me: gh_me,
  checkForUpdates: checkForUpdates,
  parseArgs: parseArgs,
  cmdoutc: cmdoutc, issuec: issuec, warning: warning,
  log: log, error: error,
  origin: origin,
  enterpriseRepos: enterpriseRepos,
  gh_token_file_name: gh_token_file_name
};
module.exports = exports['default'];