fix: use conventional-changelog-angular again

Author: marionebl

@commitlint/core/package.json

@@ -130,18 +130,19 @@
     "xo": "0.18.2"
   },
   "dependencies": {
-    "babel-runtime": "6.23.0",
-    "chalk": "1.1.3",
-    "conventional-commits-parser": "1.3.0",
-    "franc": "2.0.0",
-    "git-raw-commits": "1.1.2",
-    "git-toplevel": "1.1.1",
+    "babel-runtime": "^6.23.0",
+    "chalk": "^2.0.1",
+    "conventional-changelog-angular": "^1.3.3",
+    "conventional-commits-parser": "^1.3.0",
+    "franc": "^2.0.0",
+    "git-raw-commits": "^1.1.2",
+    "git-toplevel": "^1.1.1",
     "import-from": "^2.1.0",
-    "lodash": "4.17.4",
-    "mz": "2.6.0",
+    "lodash": "^4.17.4",
+    "mz": "^2.6.0",
     "path-exists": "^3.0.0",
-    "pos": "0.4.2",
-    "rc": "1.1.7",
+    "pos": "^0.4.2",
+    "rc": "^1.1.7",
     "resolve-from": "^3.0.0",
     "semver": "^5.3.0"
   }

@commitlint/core/src/library/parse.js

@@ -2,8 +2,16 @@ import {sync} from 'conventional-commits-parser';
 
 export default parse;
 
-function parse(message, options, parser = sync) {
-	const parsed = parser(message, options);
+async function parse(message, parser = sync) {
+	// Prevent conventional-changelog-angular from spamming startup
+	// TODO: Remove when https://github.com/conventional-changelog/conventional-changelog/pull/206 lands
+	const _error = console.error;
+	console.error = () => {};
+	const opts = require('conventional-changelog-angular');
+	console.error = _error;
+
+	const {parserOpts} = await opts;
+	const parsed = parser(message, parserOpts);
 	parsed.raw = message;
 	return parsed;
 }

@commitlint/core/src/library/parse.test.js

@@ -2,34 +2,78 @@ import test from 'ava';
 import parse from './parse';
 
 test('throws when called without params', t => {
-	t.throws(() => parse(), /Expected a raw commit/);
+	t.throws(parse(), /Expected a raw commit/);
 });
 
 test('throws when called with empty message', t => {
-	t.throws(() => parse(''), /Expected a raw commit/);
+	t.throws(parse(''), /Expected a raw commit/);
 });
 
-test('returns object with raw message', t => {
+test('returns object with raw message', async t => {
 	const message = 'type(scope): subject';
-	const actual = parse(message);
+	const actual = await parse(message);
 	t.is(actual.raw, message);
 });
 
 test('calls parser with message and passed options', t => {
 	const message = 'message';
-	const options = {};
 
-	parse(message, options, (m, o) => {
+	parse(message, m => {
 		t.is(message, m);
-		t.is(options, o);
 		return {};
 	});
 });
 
-test('passes object up from parser function', t => {
+test('passes object up from parser function', async t => {
 	const message = 'message';
-	const options = {};
 	const result = {};
-	const actual = parse(message, options, () => result);
+	const actual = await parse(message, () => result);
 	t.is(actual, result);
 });
+
+test('returns object with expected keys', async t => {
+	const message = 'message';
+	const actual = await parse(message);
+	const expected = {
+		body: null,
+		footer: null,
+		header: 'message',
+		mentions: [],
+		merge: null,
+		notes: [],
+		raw: 'message',
+		references: [],
+		revert: null,
+		scope: null,
+		subject: null,
+		type: null
+	};
+	t.deepEqual(actual, expected);
+});
+
+test('uses angular grammar', async t => {
+	const message = 'type(scope): subject';
+	const actual = await parse(message);
+	const expected = {
+		body: null,
+		footer: null,
+		header: 'type(scope): subject',
+		mentions: [],
+		merge: null,
+		notes: [],
+		raw: 'type(scope): subject',
+		references: [],
+		revert: null,
+		scope: 'scope',
+		subject: 'subject',
+		type: 'type'
+	};
+	t.deepEqual(actual, expected);
+});
+
+test('supports scopes with /', async t => {
+	const message = 'type(some/scope): subject';
+	const actual = await parse(message);
+	t.is(actual.scope, 'some/scope');
+	t.is(actual.subject, 'subject');
+});

@commitlint/core/src/lint.js

@@ -3,7 +3,7 @@ import isIgnored from './library/is-ignored';
 import parse from './library/parse';
 import implementations from './rules';
 
-export default (message, rules = {}) => {
+export default async (message, rules = {}) => {
 	// Found a wildcard match, skip
 	if (isIgnored(message)) {
 		return {
@@ -14,7 +14,7 @@ export default (message, rules = {}) => {
 	}
 
 	// Parse the commit message
-	const parsed = parse(message);
+	const parsed = await parse(message);
 
 	// Validate against all rules
 	const results = entries(rules)

@commitlint/core/src/lint.test.js

@@ -2,34 +2,34 @@ import test from 'ava';
 import lint from './lint';
 
 test('throws without params', t => {
-	t.throws(() => lint());
+	t.throws(lint());
 });
 
 test('throws with empty message', t => {
-	t.throws(() => lint(''));
+	t.throws(lint(''));
 });
 
-test('positive on stub message and no rule', t => {
-	const actual = lint('foo: bar');
+test('positive on stub message and no rule', async t => {
+	const actual = await lint('foo: bar');
 	t.true(actual.valid);
 });
 
-test('positive on stub message and adhered rule', t => {
-	const actual = lint('foo: bar', {
+test('positive on stub message and adhered rule', async t => {
+	const actual = await lint('foo: bar', {
 		'type-enum': [2, 'always', ['foo']]
 	});
 	t.true(actual.valid);
 });
 
-test('negative on stub message and broken rule', t => {
-	const actual = lint('foo: bar', {
+test('negative on stub message and broken rule', async t => {
+	const actual = await lint('foo: bar', {
 		'type-enum': [2, 'never', ['foo']]
 	});
 	t.false(actual.valid);
 });
 
-test('positive on ignored message and broken rule', t => {
-	const actual = lint('Revert "some bogus commit"', {
+test('positive on ignored message and broken rule', async t => {
+	const actual = await lint('Revert "some bogus commit"', {
 		'type-empty': [2, 'never']
 	});
 	t.true(actual.valid);

@commitlint/core/src/rules/body-case.test.js

@@ -16,74 +16,74 @@ const parsed = {
 	uppercase: parse(messages.uppercase)
 };
 
-test('with empty body should succeed for "never lowercase"', t => {
-	const [actual] = bodyCase(parsed.empty, 'never', 'lowercase');
+test('with empty body should succeed for "never lowercase"', async t => {
+	const [actual] = bodyCase(await parsed.empty, 'never', 'lowercase');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with empty body should succeed for "always lowercase"', t => {
-	const [actual] = bodyCase(parsed.empty, 'always', 'lowercase');
+test('with empty body should succeed for "always lowercase"', async t => {
+	const [actual] = bodyCase(await parsed.empty, 'always', 'lowercase');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with empty body should succeed for "never uppercase"', t => {
-	const [actual] = bodyCase(parsed.empty, 'never', 'uppercase');
+test('with empty body should succeed for "never uppercase"', async t => {
+	const [actual] = bodyCase(await parsed.empty, 'never', 'uppercase');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with empty body should succeed for "always uppercase"', t => {
-	const [actual] = bodyCase(parsed.empty, 'always', 'uppercase');
+test('with empty body should succeed for "always uppercase"', async t => {
+	const [actual] = bodyCase(await parsed.empty, 'always', 'uppercase');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with lowercase body should fail for "never lowercase"', t => {
-	const [actual] = bodyCase(parsed.lowercase, 'never', 'lowercase');
+test('with lowercase body should fail for "never lowercase"', async t => {
+	const [actual] = bodyCase(await parsed.lowercase, 'never', 'lowercase');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('with lowercase body should succeed for "always lowercase"', t => {
-	const [actual] = bodyCase(parsed.lowercase, 'always', 'lowercase');
+test('with lowercase body should succeed for "always lowercase"', async t => {
+	const [actual] = bodyCase(await parsed.lowercase, 'always', 'lowercase');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with mixedcase body should succeed for "never lowercase"', t => {
-	const [actual] = bodyCase(parsed.mixedcase, 'never', 'lowercase');
+test('with mixedcase body should succeed for "never lowercase"', async t => {
+	const [actual] = bodyCase(await parsed.mixedcase, 'never', 'lowercase');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with mixedcase body should fail for "always lowercase"', t => {
-	const [actual] = bodyCase(parsed.mixedcase, 'always', 'lowercase');
+test('with mixedcase body should fail for "always lowercase"', async t => {
+	const [actual] = bodyCase(await parsed.mixedcase, 'always', 'lowercase');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('with mixedcase body should succeed for "never uppercase"', t => {
-	const [actual] = bodyCase(parsed.mixedcase, 'never', 'uppercase');
+test('with mixedcase body should succeed for "never uppercase"', async t => {
+	const [actual] = bodyCase(await parsed.mixedcase, 'never', 'uppercase');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with mixedcase body should fail for "always uppercase"', t => {
-	const [actual] = bodyCase(parsed.mixedcase, 'always', 'uppercase');
+test('with mixedcase body should fail for "always uppercase"', async t => {
+	const [actual] = bodyCase(await parsed.mixedcase, 'always', 'uppercase');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('with uppercase body should fail for "never uppercase"', t => {
-	const [actual] = bodyCase(parsed.uppercase, 'never', 'uppercase');
+test('with uppercase body should fail for "never uppercase"', async t => {
+	const [actual] = bodyCase(await parsed.uppercase, 'never', 'uppercase');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('with lowercase body should succeed for "always uppercase"', t => {
-	const [actual] = bodyCase(parsed.uppercase, 'always', 'uppercase');
+test('with lowercase body should succeed for "always uppercase"', async t => {
+	const [actual] = bodyCase(await parsed.uppercase, 'always', 'uppercase');
 	const expected = true;
 	t.is(actual, expected);
 });

@commitlint/core/src/rules/body-empty.test.js

@@ -12,38 +12,38 @@ const parsed = {
 	filled: parse(messages.filled)
 };
 
-test('with empty body should succeed for empty keyword', t => {
-	const [actual] = bodyEmpty(parsed.empty);
+test('with empty body should succeed for empty keyword', async t => {
+	const [actual] = bodyEmpty(await parsed.empty);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with empty body should fail for "never"', t => {
-	const [actual] = bodyEmpty(parsed.empty, 'never');
+test('with empty body should fail for "never"', async t => {
+	const [actual] = bodyEmpty(await parsed.empty, 'never');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('with empty body should succeed for "always"', t => {
-	const [actual] = bodyEmpty(parsed.empty, 'always');
+test('with empty body should succeed for "always"', async t => {
+	const [actual] = bodyEmpty(await parsed.empty, 'always');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with body should fail for empty keyword', t => {
-	const [actual] = bodyEmpty(parsed.filled);
+test('with body should fail for empty keyword', async t => {
+	const [actual] = bodyEmpty(await parsed.filled);
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('with body should succeed for "never"', t => {
-	const [actual] = bodyEmpty(parsed.filled, 'never');
+test('with body should succeed for "never"', async t => {
+	const [actual] = bodyEmpty(await parsed.filled, 'never');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with body should fail for "always"', t => {
-	const [actual] = bodyEmpty(parsed.filled, 'always');
+test('with body should fail for "always"', async t => {
+	const [actual] = bodyEmpty(await parsed.filled, 'always');
 	const expected = false;
 	t.is(actual, expected);
 });