smooth-release/lib/github/release.js

Smart CLI tool to safely and automatically do every step to release a new version of a library hosted on GitHub and published on npm

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _lodash = require('lodash');

var _staggerjs = require('staggerjs');

var _staggerjs2 = _interopRequireDefault(_staggerjs);

var _utils = require('../utils');

var _getAllTags = require('../modules/getAllTags');

var _getAllTags2 = _interopRequireDefault(_getAllTags);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var getAllVersionTags = function () {
  var _ref = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee() {
    var tags, versionTags;
    return _regenerator2.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            (0, _utils.info)('Get all npm version "tags"');
            _utils.status.addSteps(['Get all tags from GitHub', 'filter npm-version tags']);

            _context.next = 4;
            return (0, _getAllTags2.default)();

          case 4:
            tags = _context.sent;

            _utils.status.doneStep(true);

            versionTags = tags.filter(_utils.isVersionTag);

            _utils.status.doneStep(versionTags.length > 0);

            return _context.abrupt('return', versionTags);

          case 9:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, undefined);
  }));

  return function getAllVersionTags() {
    return _ref.apply(this, arguments);
  };
}();

var getLastVersionTag = function () {
  var _ref2 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee2(packageJsonVersion) {
    var tags, tag;
    return _regenerator2.default.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            (0, _utils.info)('Get last npm version "tag"');
            _utils.status.addSteps(['Get all tags from GitHub', 'Find last npm-version tag']);

            _context2.next = 4;
            return (0, _getAllTags2.default)();

          case 4:
            tags = _context2.sent;

            _utils.status.doneStep(true);

            tag = (0, _lodash.find)(tags, { name: 'v' + packageJsonVersion });

            _utils.status.doneStep(!!tag);

            return _context2.abrupt('return', tag || null);

          case 9:
          case 'end':
            return _context2.stop();
        }
      }
    }, _callee2, undefined);
  }));

  return function getLastVersionTag(_x) {
    return _ref2.apply(this, arguments);
  };
}();

var computeRelease = function () {
  var _ref3 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee3(tag) {
    var commit, _getGithubOwnerAndRep, owner, repo, changelogUrl, tagISODate, linkToChangelog, release;

    return _regenerator2.default.wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            (0, _utils.info)('Compute release');
            _utils.status.addSteps(['Get tag\'s creation datetime from GitHub', 'Compute "release" object']);

            _context3.next = 4;
            return _utils.github.commits(tag.commit.sha).fetch();

          case 4:
            commit = _context3.sent;
            _getGithubOwnerAndRep = (0, _utils.getGithubOwnerAndRepo)(), owner = _getGithubOwnerAndRep.owner, repo = _getGithubOwnerAndRep.repo;
            changelogUrl = 'https://github.com/' + owner + '/' + repo + '/blob/master/CHANGELOG.md';
            tagISODate = commit.commit.author.date.slice(0, 10);

            _utils.status.doneStep(true);

            linkToChangelog = changelogUrl + '#' + tag.name.split('.').join('') + '-' + tagISODate;
            release = {
              tag_name: tag.name,
              name: tag.name,
              body: 'See [CHANGELOG.md](' + linkToChangelog + ') for details about this release.'
            };

            _utils.status.doneStep(true);

            return _context3.abrupt('return', release);

          case 13:
          case 'end':
            return _context3.stop();
        }
      }
    }, _callee3, undefined);
  }));

  return function computeRelease(_x2) {
    return _ref3.apply(this, arguments);
  };
}();

var postRelease = function () {
  var _ref4 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee4(release) {
    var _JSON$parse, message;

    return _regenerator2.default.wrap(function _callee4$(_context4) {
      while (1) {
        switch (_context4.prev = _context4.next) {
          case 0:
            (0, _utils.info)('Create new release on GitHub');
            _utils.status.addSteps(['Post release on GitHub']);

            _context4.prev = 2;
            _context4.next = 5;
            return _utils.github.releases.create(release);

          case 5:
            _utils.status.doneStep(true);
            _context4.next = 13;
            break;

          case 8:
            _context4.prev = 8;
            _context4.t0 = _context4['catch'](2);

            _utils.status.doneStep(false);
            _JSON$parse = JSON.parse(_context4.t0.message), message = _JSON$parse.message;
            throw new _utils.SmoothReleaseError(message === 'Validation Failed' ? 'Release "' + release.tag_name + '" already exists' : message);

          case 13:
          case 'end':
            return _context4.stop();
        }
      }
    }, _callee4, undefined, [[2, 8]]);
  }));

  return function postRelease(_x3) {
    return _ref4.apply(this, arguments);
  };
}();

exports.default = function () {
  var _ref6 = (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee6(_ref5) {
    var all = _ref5.all;
    var versionTags, tag, release;
    return _regenerator2.default.wrap(function _callee6$(_context6) {
      while (1) {
        switch (_context6.prev = _context6.next) {
          case 0:
            (0, _utils.title)('\nPost release on GitHub for ' + (all ? 'every' : 'latest') + ' npm-version tag');

            if (!all) {
              _context6.next = 9;
              break;
            }

            _context6.next = 4;
            return getAllVersionTags();

          case 4:
            versionTags = _context6.sent;
            _context6.next = 7;
            return (0, _staggerjs2.default)(versionTags.map(function (tag) {
              return (0, _asyncToGenerator3.default)( /*#__PURE__*/_regenerator2.default.mark(function _callee5() {
                var release;
                return _regenerator2.default.wrap(function _callee5$(_context5) {
                  while (1) {
                    switch (_context5.prev = _context5.next) {
                      case 0:
                        _context5.next = 2;
                        return computeRelease(tag);

                      case 2:
                        release = _context5.sent;
                        _context5.next = 5;
                        return postRelease(release);

                      case 5:
                      case 'end':
                        return _context5.stop();
                    }
                  }
                }, _callee5, undefined);
              }));
            }), { maxOngoingMethods: 1 });

          case 7:
            _context6.next = 18;
            break;

          case 9:
            _context6.next = 11;
            return getLastVersionTag((0, _utils.getPackageJsonVersion)());

          case 11:
            tag = _context6.sent;

            if (!tag) {
              _context6.next = 18;
              break;
            }

            _context6.next = 15;
            return computeRelease(tag);

          case 15:
            release = _context6.sent;
            _context6.next = 18;
            return postRelease(release);

          case 18:
          case 'end':
            return _context6.stop();
        }
      }
    }, _callee6, undefined);
  }));

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