conventional-changelog-lint/distribution/index.js

'use strict';

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

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

var _regenerator2 = _interopRequireDefault(_regenerator);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

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

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

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

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _conventionalCommitsParser = require('conventional-commits-parser');

var _lodash = require('lodash');

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

var _getConfiguration3 = _interopRequireDefault(_getConfiguration2);

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

var _getMessages3 = _interopRequireDefault(_getMessages2);

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

var _getPreset3 = _interopRequireDefault(_getPreset2);

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

var _format3 = _interopRequireDefault(_format2);

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

exports.getConfiguration = _getConfiguration3.default;
exports.getMessages = _getMessages3.default;
exports.getPreset = _getPreset3.default;
exports.format = _format3.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 parserOptions, _options$configuratio, rules, wildcards, parsed, bails, results, errors, warnings, valid;

		return _regenerator2.default.wrap(function _callee$(_context) {
			while (1) {
				switch (_context.prev = _context.next) {
					case 0:
						parserOptions = options.preset.parserOpts, _options$configuratio = options.configuration, rules = _options$configuratio.rules, wildcards = _options$configuratio.wildcards;

						// parse the commit message

						parsed = (0, _lodash.merge)({ raw: message }, (0, _conventionalCommitsParser.sync)(message, parserOptions));

						// wildcard matches skip the linting

						bails = Object.entries(wildcards).filter(function (entry) {
							var _entry = (0, _slicedToArray3.default)(entry, 2),
							    pattern = _entry[1];

							return Array.isArray(pattern);
						}).filter(function (entry) {
							var _entry2 = (0, _slicedToArray3.default)(entry, 2),
							    pattern = _entry2[1];

							var expression = new (Function.prototype.bind.apply(RegExp, [null].concat((0, _toConsumableArray3.default)(pattern))))();
							return parsed.header.match(expression);
						}).map(function (entry) {
							return entry[0];
						});

						// found a wildcard match, skip

						if (!(bails.length > 0)) {
							_context.next = 5;
							break;
						}

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

					case 5:

						// validate against all rules
						results = Object.entries(rules).filter(function (entry) {
							var _entry3 = (0, _slicedToArray3.default)(entry, 2),
							    _entry3$ = (0, _slicedToArray3.default)(_entry3[1], 1),
							    level = _entry3$[0];

							return level > 0;
						}).map(function (entry) {
							var _entry4 = (0, _slicedToArray3.default)(entry, 2),
							    name = _entry4[0],
							    config = _entry4[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 = require(`./rules/${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 10:
					case 'end':
						return _context.stop();
				}
			}
		}, _callee, undefined);
	}));

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