conventional-changelog-lint/distribution/cli.js

#!/usr/bin/env node
'use strict';

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

var _regenerator2 = _interopRequireDefault(_regenerator);

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

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

// Assemble the engine
var main = function () {
	var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2(options) {
		var _this = this;

		var raw, flags, fromStdin, input;
		return _regenerator2.default.wrap(function _callee2$(_context2) {
			while (1) {
				switch (_context2.prev = _context2.next) {
					case 0:
						raw = options.input, flags = options.flags;
						fromStdin = rules.fromStdin(raw, flags);

						if (!fromStdin) {
							_context2.next = 9;
							break;
						}

						_context2.next = 5;
						return (0, _getStdin2.default)();

					case 5:
						_context2.t1 = _context2.sent;
						_context2.t0 = [_context2.t1];
						_context2.next = 12;
						break;

					case 9:
						_context2.next = 11;
						return (0, _.getMessages)((0, _lodash.pick)(flags, 'edit', 'from', 'to'));

					case 11:
						_context2.t0 = _context2.sent;

					case 12:
						input = _context2.t0;
						return _context2.abrupt('return', Promise.all(input.map(function () {
							var _ref2 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(commit) {
								var fmt, seed, report, formatted, error;
								return _regenerator2.default.wrap(function _callee$(_context) {
									while (1) {
										switch (_context.prev = _context.next) {
											case 0:
												fmt = new _chalk2.default.constructor({ enabled: flags.color });
												seed = {};

												if (flags.extends) {
													seed.extends = flags.extends.split(',');
												}

												_context.t0 = _2.default;
												_context.t1 = commit;
												_context.next = 7;
												return (0, _.getPreset)(flags.preset);

											case 7:
												_context.t2 = _context.sent;
												_context.next = 10;
												return (0, _.getConfiguration)('conventional-changelog-lint', {
													prefix: 'conventional-changelog-lint-config'
												}, seed);

											case 10:
												_context.t3 = _context.sent;
												_context.t4 = {
													preset: _context.t2,
													configuration: _context.t3
												};
												_context.next = 14;
												return (0, _context.t0)(_context.t1, _context.t4);

											case 14:
												report = _context.sent;
												formatted = (0, _.format)(report, {
													color: flags.color,
													signs: [' ', '⚠', '✖'],
													colors: ['white', 'yellow', 'red']
												});


												if (!flags.quiet) {
													console.log(`${fmt.grey('⧗')}   input: ${fmt.bold(commit.split('\n')[0])}`);
													console.log(formatted.join('\n'));
												}

												if (!(report.errors.length > 0)) {
													_context.next = 21;
													break;
												}

												error = new Error(formatted[formatted.length - 1]);

												error.type = _package2.default.name;
												throw error;

											case 21:
												return _context.abrupt('return', console.log(''));

											case 22:
											case 'end':
												return _context.stop();
										}
									}
								}, _callee, _this);
							}));

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

					case 14:
					case 'end':
						return _context2.stop();
				}
			}
		}, _callee2, this);
	}));

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

// Start the engine


require('babel-polyfill');

var _chalk = require('chalk');

var _chalk2 = _interopRequireDefault(_chalk);

var _meow = require('meow');

var _meow2 = _interopRequireDefault(_meow);

var _lodash = require('lodash');

var _getStdin = require('get-stdin');

var _getStdin2 = _interopRequireDefault(_getStdin);

var _help = require('./help');

var _help2 = _interopRequireDefault(_help);

var _ = require('./');

var _2 = _interopRequireDefault(_);

var _package = require('../package');

var _package2 = _interopRequireDefault(_package);

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

/**
 * Behavioural rules
 */


// local modules


// npm modules
var rules = {
	fromStdin: function fromStdin(input, flags) {
		return input.length === 0 && flags.from === null && flags.to === null && !flags.edit;
	}
};
// polyfills


var configuration = {
	// flags of string type
	string: ['from', 'to', 'preset', 'extends'],
	// flags of array type
	// flags of bool type
	boolean: ['edit', 'help', 'version', 'quiet', 'color'],
	// flag aliases
	alias: {
		c: 'color',
		e: 'edit',
		f: 'from',
		p: 'preset',
		t: 'to',
		q: 'quiet',
		h: 'help',
		v: 'version',
		x: 'extends'
	},
	description: {
		color: 'toggle formatted output',
		edit: 'read last commit message found in ./git/COMMIT_EDITMSG',
		extends: 'array of shareable configurations to extend',
		from: 'lower end of the commit range to lint; applies if edit=false',
		preset: 'conventional-changelog-preset to use for commit message parsing',
		to: 'upper end of the commit range to lint; applies if edit=false',
		quiet: 'toggle console output'
	},
	// flag defaults
	default: {
		color: true,
		edit: false,
		from: null,
		preset: 'angular',
		to: null,
		quiet: false
	},
	// fail on unknown
	unknown(arg) {
		throw new Error(`unknown flags: ${arg}`);
	}
};

// Init meow 😸cli
var cli = (0, _meow2.default)({
	help: `[input] reads from stdin if --edit, --from, --to are omitted\n${(0, _help2.default)(configuration)}`,
	description: `${_package2.default.name}@${_package2.default.version} - ${_package2.default.description}`
}, configuration);main(cli).catch(function (error) {
	return setTimeout(function () {
		if (error.type === _package2.default.name) {
			process.exit(1);
		}
		throw error;
	});
});

// Catch unhandled rejections globally
process.on('unhandledRejection', function (reason, promise) {
	console.log('Unhandled Rejection at: Promise ', promise, ' reason: ', reason);
	throw reason;
});