conventional-changelog-lint/distribution/index.js

'use strict';

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

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

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 }; }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { return step("next", value); }, function (err) { return step("throw", err); }); } } return step("next"); }); }; }

exports.getConfiguration = _getConfiguration3.default;
exports.getMessages = _getMessages3.default;
exports.getPreset = _getPreset3.default;
exports.format = _format3.default;

exports.default = (() => {
	var ref = _asyncToGenerator(function* (message) {
		let options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
		const parserOptions = options.preset.parserOpts;
		var _options$configuratio = options.configuration;
		const rules = _options$configuratio.rules;
		const wildcards = _options$configuratio.wildcards;

		// parse the commit message

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

		// wildcard matches skip the linting
		const bails = Object.entries(wildcards).filter(function (entry) {
			var _entry = _slicedToArray(entry, 2);

			const pattern = _entry[1];

			return Array.isArray(pattern);
		}).filter(function (entry) {
			var _entry2 = _slicedToArray(entry, 2);

			const pattern = _entry2[1];

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

		// found a wildcard match, skip
		if (bails.length > 0) {
			return {
				valid: true,
				wildcards: bails,
				rules: [],
				warnings: [],
				errors: []
			};
		}

		// validate against all rules
		const results = Object.entries(rules).filter(function (entry) {
			var _entry3 = _slicedToArray(entry, 2);

			var _entry3$ = _slicedToArray(_entry3[1], 1);

			const level = _entry3$[0];

			return level > 0;
		}).map(function (entry) {
			var _entry4 = _slicedToArray(entry, 2);

			const name = _entry4[0];
			const config = _entry4[1];

			var _config = _slicedToArray(config, 3);

			const level = _config[0];
			const when = _config[1];
			const value = _config[2];

			// Level 0 rules are ignored

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

			const rule = require(`./rules/${ name }`);

			var _rule = rule(parsed, when, value);

			var _rule2 = _slicedToArray(_rule, 2);

			const valid = _rule2[0];
			const message = _rule2[1];


			return {
				level,
				valid,
				name,
				message
			};
		}).filter(Boolean);

		const errors = results.filter(function (result) {
			return result.level > 1 && !result.valid;
		});

		const warnings = results.filter(function (result) {
			return result.level < 2 && !result.valid;
		});

		const valid = errors.length === 0;

		return {
			valid,
			errors,
			warnings
		};
	}),
	    _this = undefined;

	return function (_x, _x2) {
		return ref.apply(_this, arguments);
	};
})();