conventional-changelog-lint/distribution/index.js

Lint commit messages against a conventional-changelog preset and ruleset

'use strict';

Object.defineProperty(exports, "__esModule", {
	value: true
});
exports.getPreset = exports.getMessages = exports.getConfiguration = exports.format = undefined;

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

var _regenerator2 = _interopRequireDefault(_regenerator);

var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

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

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _rules = require('./rules');

var _rules2 = _interopRequireDefault(_rules);

var _format = require('./library/format');

var _format2 = _interopRequireDefault(_format);

var _getConfiguration = require('./library/get-configuration');

var _getConfiguration2 = _interopRequireDefault(_getConfiguration);

var _getMessages = require('./library/get-messages');

var _getMessages2 = _interopRequireDefault(_getMessages);

var _getPreset = require('./library/get-preset');

var _getPreset2 = _interopRequireDefault(_getPreset);

var _isIgnored = require('./library/is-ignored');

var _isIgnored2 = _interopRequireDefault(_isIgnored);

var _parse = require('./library/parse');

var _parse2 = _interopRequireDefault(_parse);

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

exports.format = _format2.default;
exports.getConfiguration = _getConfiguration2.default;
exports.getMessages = _getMessages2.default;
exports.getPreset = _getPreset2.default;

exports.default = function () {
	var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(message) {
		var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
		var configuration, parsed, results, errors, warnings, valid;
		return _regenerator2.default.wrap(function _callee$(_context) {
			while (1) {
				switch (_context.prev = _context.next) {
					case 0:
						configuration = options.configuration;

						// Found a wildcard match, skip

						if (!(0, _isIgnored2.default)(message)) {
							_context.next = 3;
							break;
						}

						return _context.abrupt('return', {
							valid: true,
							errors: [],
							warnings: []
						});

					case 3:

						// Parse the commit message
						parsed = (0, _parse2.default)(message);

						// Validate against all rules

						results = Object.entries(configuration.rules).filter(function (entry) {
							var _entry = (0, _slicedToArray3.default)(entry, 2),
							    _entry$ = (0, _slicedToArray3.default)(_entry[1], 1),
							    level = _entry$[0];

							return level > 0;
						}).map(function (entry) {
							var _entry2 = (0, _slicedToArray3.default)(entry, 2),
							    name = _entry2[0],
							    config = _entry2[1];

							var _config = (0, _slicedToArray3.default)(config, 3),
							    level = _config[0],
							    when = _config[1],
							    value = _config[2];

							// Level 0 rules are ignored


							if (level === 0) {
								return null;
							}

							var rule = _rules2.default[name];

							var _rule = rule(parsed, when, value),
							    _rule2 = (0, _slicedToArray3.default)(_rule, 2),
							    valid = _rule2[0],
							    message = _rule2[1];

							return {
								level,
								valid,
								name,
								message
							};
						}).filter(Boolean);
						errors = results.filter(function (result) {
							return result.level > 1 && !result.valid;
						});
						warnings = results.filter(function (result) {
							return result.level < 2 && !result.valid;
						});
						valid = errors.length === 0;
						return _context.abrupt('return', {
							valid,
							errors,
							warnings
						});

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

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