From 4768ca9c601a96bc951e15fe791d1d219d236032 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 1 May 2017 17:25:59 +0200
Subject: [PATCH 01/77] test: add test cases for footer-empty

---
 test/rules/footer-empty.js | 69 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 test/rules/footer-empty.js

diff --git a/test/rules/footer-empty.js b/test/rules/footer-empty.js
new file mode 100644
index 0000000000..7743a5476f
--- /dev/null
+++ b/test/rules/footer-empty.js
@@ -0,0 +1,69 @@
+import test from 'ava';
+import parse from '../../source/library/parse';
+import footerEmpty from '../../source/rules/footer-empty';
+
+const messages = {
+	simple: 'chore: subject',
+	empty: 'chore: subject\nbody',
+	filled: 'chore: subject\nBREAKING CHANGE: something important'
+};
+
+const parsed = {
+	simple: parse(messages.simple),
+	empty: parse(messages.empty),
+	filled: parse(messages.filled)
+};
+
+test('footer-empty with simple message should succeed for empty keyword', t => {
+	const [actual] = footerEmpty(parsed.simple);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('footer-empty with simple message should fail for "never"', t => {
+	const [actual] = footerEmpty(parsed.simple, 'never');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('footer-empty with simple message should succeed for "always"', t => {
+	const [actual] = footerEmpty(parsed.simple, 'always');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('footer-empty with empty footer should succeed for empty keyword', t => {
+	const [actual] = footerEmpty(parsed.empty);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('footer-empty with empty footer should fail for "never"', t => {
+	const [actual] = footerEmpty(parsed.empty, 'never');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('footer-empty with empty footer should succeed for "always"', t => {
+	const [actual] = footerEmpty(parsed.empty, 'always');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('footer-empty with footer should fail for empty keyword', t => {
+	const [actual] = footerEmpty(parsed.filled);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('footer-empty with footer should succeed for "never"', t => {
+	const [actual] = footerEmpty(parsed.filled, 'never');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('footer-empty with footer should fail for "always"', t => {
+	const [actual] = footerEmpty(parsed.filled, 'always');
+	const expected = false;
+	t.is(actual, expected);
+});

From 5f9a618cb00d632c041fef0e5a4d02244ba746e6 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 1 May 2017 17:30:01 +0200
Subject: [PATCH 02/77] fix: finish footer-empty implementation

---
 source/rules/footer-empty.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/source/rules/footer-empty.js b/source/rules/footer-empty.js
index fbb4f76874..ef97473e62 100644
--- a/source/rules/footer-empty.js
+++ b/source/rules/footer-empty.js
@@ -2,8 +2,10 @@ import ensureNotEmpty from '../library/ensure-not-empty';
 
 export default (parsed, when) => {
 	const negated = when === 'never';
+	const notEmpty = ensureNotEmpty(parsed.footer);
+
 	return [
-		ensureNotEmpty(parsed.footer),
+		negated ? notEmpty : !notEmpty,
 		[
 			'footer',
 			negated ? 'may not' : 'must',

From cffc0779dc095f05e950ff471d2c21eddc252635 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 1 May 2017 17:41:58 +0200
Subject: [PATCH 03/77] test: add test cases for footer-max-length

---
 test/rules/footer-max-length.js | 45 +++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 test/rules/footer-max-length.js

diff --git a/test/rules/footer-max-length.js b/test/rules/footer-max-length.js
new file mode 100644
index 0000000000..17450c1db7
--- /dev/null
+++ b/test/rules/footer-max-length.js
@@ -0,0 +1,45 @@
+import test from 'ava';
+import parse from '../../source/library/parse';
+import footerMaxLength from '../../source/rules/footer-max-length';
+
+const short = 'BREAKING CHANGE: a';
+const long = 'BREAKING CHANGE: ab';
+
+const messages = {
+	simple: 'chore: subject',
+	empty: 'chore: subject\nbody',
+	short: `chore: subject\n${short}`,
+	long: `chore: subject\n${long}`
+};
+
+const parsed = {
+	simple: parse(messages.simple),
+	empty: parse(messages.empty),
+	short: parse(messages.short),
+	long: parse(messages.short)
+};
+
+test.failing('footer-max-length with simple message should succeed', t => {
+	const [actual] = footerMaxLength(parsed.simple, '', short.length);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('footer-max-length with empty footer should succeed', t => {
+	const [actual] = footerMaxLength(parsed.empty, '', short.length);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('footer-max-length with short footer should succeed', t => {
+	const [actual] = footerMaxLength(parsed.short, '', short.length);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('footer-max-length with long footer should succeed', t => {
+	const [actual] = footerMaxLength(parsed.long, '', short.length);
+	const expected = true;
+	t.is(actual, expected);
+});
+

From 06fb33b6c0fe9c3ed0a81722238c7c5dcca662b9 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 1 May 2017 17:42:37 +0200
Subject: [PATCH 04/77] fix: allow empty footer for footer-max-length

---
 source/rules/footer-max-length.js | 4 ++++
 test/rules/footer-max-length.js   | 4 ++--
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/source/rules/footer-max-length.js b/source/rules/footer-max-length.js
index 87d35cee6e..7da98617af 100644
--- a/source/rules/footer-max-length.js
+++ b/source/rules/footer-max-length.js
@@ -1,6 +1,10 @@
 import ensureMaxLength from '../library/ensure-max-length';
 
 export default (parsed, when, value) => {
+	if (!parsed.footer) {
+		return [true];
+	}
+
 	return [
 		ensureMaxLength(parsed.footer, value),
 		`footer must not be longer than ${value} characters`
diff --git a/test/rules/footer-max-length.js b/test/rules/footer-max-length.js
index 17450c1db7..0ad688d58b 100644
--- a/test/rules/footer-max-length.js
+++ b/test/rules/footer-max-length.js
@@ -19,13 +19,13 @@ const parsed = {
 	long: parse(messages.short)
 };
 
-test.failing('footer-max-length with simple message should succeed', t => {
+test('footer-max-length with simple message should succeed', t => {
 	const [actual] = footerMaxLength(parsed.simple, '', short.length);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('footer-max-length with empty footer should succeed', t => {
+test('footer-max-length with empty footer should succeed', t => {
 	const [actual] = footerMaxLength(parsed.empty, '', short.length);
 	const expected = true;
 	t.is(actual, expected);

From 380705b4a491b40b928d3291346c2ad6ccddb3af Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 1 May 2017 17:50:05 +0200
Subject: [PATCH 05/77] test: correct non-criticals in footer-max-length tests

---
 test/rules/footer-max-length.js | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/test/rules/footer-max-length.js b/test/rules/footer-max-length.js
index 0ad688d58b..1bdbdbf413 100644
--- a/test/rules/footer-max-length.js
+++ b/test/rules/footer-max-length.js
@@ -5,6 +5,8 @@ import footerMaxLength from '../../source/rules/footer-max-length';
 const short = 'BREAKING CHANGE: a';
 const long = 'BREAKING CHANGE: ab';
 
+const allowed = short.length;
+
 const messages = {
 	simple: 'chore: subject',
 	empty: 'chore: subject\nbody',
@@ -16,30 +18,30 @@ const parsed = {
 	simple: parse(messages.simple),
 	empty: parse(messages.empty),
 	short: parse(messages.short),
-	long: parse(messages.short)
+	long: parse(messages.long)
 };
 
 test('footer-max-length with simple message should succeed', t => {
-	const [actual] = footerMaxLength(parsed.simple, '', short.length);
+	const [actual] = footerMaxLength(parsed.simple, '', allowed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
 test('footer-max-length with empty footer should succeed', t => {
-	const [actual] = footerMaxLength(parsed.empty, '', short.length);
+	const [actual] = footerMaxLength(parsed.empty, '', allowed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
 test('footer-max-length with short footer should succeed', t => {
-	const [actual] = footerMaxLength(parsed.short, '', short.length);
+	const [actual] = footerMaxLength(parsed.short, '', allowed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-max-length with long footer should succeed', t => {
-	const [actual] = footerMaxLength(parsed.long, '', short.length);
-	const expected = true;
+test('footer-max-length with long footer should fail', t => {
+	const [actual] = footerMaxLength(parsed.long, '', allowed);
+	const expected = false;
 	t.is(actual, expected);
 });
 

From bd1e874443c3f92e5e1374b161aebcd026155bb6 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 1 May 2017 17:57:48 +0200
Subject: [PATCH 06/77] test: add test cases for footer-min-length

---
 test/rules/footer-min-length.js | 47 +++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 test/rules/footer-min-length.js

diff --git a/test/rules/footer-min-length.js b/test/rules/footer-min-length.js
new file mode 100644
index 0000000000..f6cc199b67
--- /dev/null
+++ b/test/rules/footer-min-length.js
@@ -0,0 +1,47 @@
+import test from 'ava';
+import parse from '../../source/library/parse';
+import footerMinLength from '../../source/rules/footer-min-length';
+
+const short = 'BREAKING CHANGE: a';
+const long = 'BREAKING CHANGE: ab';
+
+const needed = long.length;
+
+const messages = {
+	simple: 'chore: subject',
+	empty: 'chore: subject\nbody',
+	short: `chore: subject\n${short}`,
+	long: `chore: subject\n${long}`
+};
+
+const parsed = {
+	simple: parse(messages.simple),
+	empty: parse(messages.empty),
+	short: parse(messages.short),
+	long: parse(messages.long)
+};
+
+test.failing('footer-min-length with simple message should succeed', t => {
+	const [actual] = footerMinLength(parsed.simple, '', needed);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('footer-min-length with empty footer should succeed', t => {
+	const [actual] = footerMinLength(parsed.empty, '', needed);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('footer-min-length with short footer should fail', t => {
+	const [actual] = footerMinLength(parsed.short, '', needed);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('footer-min-length with long footer should succeed', t => {
+	const [actual] = footerMinLength(parsed.long, '', needed);
+	const expected = true;
+	t.is(actual, expected);
+});
+

From 5d0b4e0050453c5b3798ba03c56d2a9f33f1bf7b Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 1 May 2017 17:59:12 +0200
Subject: [PATCH 07/77] fix: allow empty footer for footer-min-length

---
 source/rules/footer-min-length.js | 3 +++
 test/rules/footer-min-length.js   | 4 ++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/source/rules/footer-min-length.js b/source/rules/footer-min-length.js
index 32341585dd..ed0099205e 100644
--- a/source/rules/footer-min-length.js
+++ b/source/rules/footer-min-length.js
@@ -1,6 +1,9 @@
 import ensureMinLength from '../library/ensure-min-length';
 
 export default (parsed, when, value) => {
+	if (!parsed.footer) {
+		return [true];
+	}
 	return [
 		ensureMinLength(parsed.footer, value),
 		`footer must not be shorter than ${value} characters`
diff --git a/test/rules/footer-min-length.js b/test/rules/footer-min-length.js
index f6cc199b67..c55b64fdad 100644
--- a/test/rules/footer-min-length.js
+++ b/test/rules/footer-min-length.js
@@ -21,13 +21,13 @@ const parsed = {
 	long: parse(messages.long)
 };
 
-test.failing('footer-min-length with simple message should succeed', t => {
+test('footer-min-length with simple message should succeed', t => {
 	const [actual] = footerMinLength(parsed.simple, '', needed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('footer-min-length with empty footer should succeed', t => {
+test('footer-min-length with empty footer should succeed', t => {
 	const [actual] = footerMinLength(parsed.empty, '', needed);
 	const expected = true;
 	t.is(actual, expected);

From 419af1fcefa49eaa6be79822be77f0e77b4dd0c5 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 1 May 2017 22:56:38 +0200
Subject: [PATCH 08/77] test: add cases for body-empty

---
 test/rules/body-empty.js | 49 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 test/rules/body-empty.js

diff --git a/test/rules/body-empty.js b/test/rules/body-empty.js
new file mode 100644
index 0000000000..bc6773d5f6
--- /dev/null
+++ b/test/rules/body-empty.js
@@ -0,0 +1,49 @@
+import test from 'ava';
+import parse from '../../source/library/parse';
+import bodyEmpty from '../../source/rules/body-empty';
+
+const messages = {
+	empty: 'chore: subject',
+	filled: 'chore: subject\nbody'
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	filled: parse(messages.filled)
+};
+
+test.failing('body-empty with empty body should succeed for empty keyword', t => {
+	const [actual] = bodyEmpty(parsed.empty);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('body-empty with empty body should fail for "never"', t => {
+	const [actual] = bodyEmpty(parsed.empty, 'never');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('body-empty with empty body should succeed for "always"', t => {
+	const [actual] = bodyEmpty(parsed.empty, 'always');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('body-empty with body should fail for empty keyword', t => {
+	const [actual] = bodyEmpty(parsed.filled);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('body-empty with body should succeed for "never"', t => {
+	const [actual] = bodyEmpty(parsed.filled, 'never');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('body-empty with body should fail for "always"', t => {
+	const [actual] = bodyEmpty(parsed.filled, 'always');
+	const expected = false;
+	t.is(actual, expected);
+});

From ada66d0814e20ce35b6d1babec2419347aa62a8a Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 1 May 2017 22:58:14 +0200
Subject: [PATCH 09/77] fix: use keywords in body-empty

---
 source/rules/body-empty.js | 4 +++-
 test/rules/body-empty.js   | 8 ++++----
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/source/rules/body-empty.js b/source/rules/body-empty.js
index 81d7ed4228..83c51b635a 100644
--- a/source/rules/body-empty.js
+++ b/source/rules/body-empty.js
@@ -2,8 +2,10 @@ import ensureNotEmpty from '../library/ensure-not-empty';
 
 export default (parsed, when) => {
 	const negated = when === 'never';
+	const notEmpty = ensureNotEmpty(parsed.body);
+
 	return [
-		ensureNotEmpty(parsed.body),
+		negated ? notEmpty : !notEmpty,
 		[
 			'body',
 			negated ? 'may not' : 'must',
diff --git a/test/rules/body-empty.js b/test/rules/body-empty.js
index bc6773d5f6..fed4b592e4 100644
--- a/test/rules/body-empty.js
+++ b/test/rules/body-empty.js
@@ -12,7 +12,7 @@ const parsed = {
 	filled: parse(messages.filled)
 };
 
-test.failing('body-empty with empty body should succeed for empty keyword', t => {
+test('body-empty with empty body should succeed for empty keyword', t => {
 	const [actual] = bodyEmpty(parsed.empty);
 	const expected = true;
 	t.is(actual, expected);
@@ -24,13 +24,13 @@ test('body-empty with empty body should fail for "never"', t => {
 	t.is(actual, expected);
 });
 
-test.failing('body-empty with empty body should succeed for "always"', t => {
+test('body-empty with empty body should succeed for "always"', t => {
 	const [actual] = bodyEmpty(parsed.empty, 'always');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('body-empty with body should fail for empty keyword', t => {
+test('body-empty with body should fail for empty keyword', t => {
 	const [actual] = bodyEmpty(parsed.filled);
 	const expected = false;
 	t.is(actual, expected);
@@ -42,7 +42,7 @@ test('body-empty with body should succeed for "never"', t => {
 	t.is(actual, expected);
 });
 
-test.failing('body-empty with body should fail for "always"', t => {
+test('body-empty with body should fail for "always"', t => {
 	const [actual] = bodyEmpty(parsed.filled, 'always');
 	const expected = false;
 	t.is(actual, expected);

From 76efafa39741ea2878c6e563b0eb388579b39d78 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 1 May 2017 23:04:26 +0200
Subject: [PATCH 10/77] test: add cases for subject-empty

---
 source/rules/scope-empty.js |  4 +--
 test/rules/subject-empty.js | 49 +++++++++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+), 2 deletions(-)
 create mode 100644 test/rules/subject-empty.js

diff --git a/source/rules/scope-empty.js b/source/rules/scope-empty.js
index 4c27642a8f..69fa8954d9 100644
--- a/source/rules/scope-empty.js
+++ b/source/rules/scope-empty.js
@@ -2,9 +2,9 @@ import ensureNotEmpty from '../library/ensure-not-empty';
 
 export default (parsed, when = 'never') => {
 	const negated = when === 'always';
-	const result = ensureNotEmpty(parsed.scope);
+	const notEmpty = ensureNotEmpty(parsed.scope);
 	return [
-		negated ? !result : result,
+		negated ? !notEmpty : notEmpty,
 		[
 			'scope',
 			negated ? 'must' : 'may not',
diff --git a/test/rules/subject-empty.js b/test/rules/subject-empty.js
new file mode 100644
index 0000000000..3218a0ef1b
--- /dev/null
+++ b/test/rules/subject-empty.js
@@ -0,0 +1,49 @@
+import test from 'ava';
+import parse from '../../source/library/parse';
+import subjectEmpty from '../../source/rules/subject-empty';
+
+const messages = {
+	empty: 'chore: \nbody',
+	filled: 'chore: subject\nbody'
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	filled: parse(messages.filled)
+};
+
+test.failing('subject-empty without subject should succeed for empty keyword', t => {
+	const [actual] = subjectEmpty(parsed.empty);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('subject-empty without subject should fail for "never"', t => {
+	const [actual] = subjectEmpty(parsed.empty, 'never');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('subject-empty without subject should succeed for "always"', t => {
+	const [actual] = subjectEmpty(parsed.empty, 'always');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('subject-empty with subject fail for empty keyword', t => {
+	const [actual] = subjectEmpty(parsed.filled);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('subject-empty with subject succeed for "never"', t => {
+	const [actual] = subjectEmpty(parsed.filled, 'never');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('subject-empty with subject fail for "always"', t => {
+	const [actual] = subjectEmpty(parsed.filled, 'always');
+	const expected = false;
+	t.is(actual, expected);
+});

From 89b9cb0018c1974172b823498008eefc386d1906 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 1 May 2017 23:05:59 +0200
Subject: [PATCH 11/77] fix: use keywords in subject-empty

---
 source/rules/subject-empty.js | 4 +++-
 test/rules/subject-empty.js   | 8 ++++----
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/source/rules/subject-empty.js b/source/rules/subject-empty.js
index a5ec258124..8c0c5c4880 100644
--- a/source/rules/subject-empty.js
+++ b/source/rules/subject-empty.js
@@ -2,8 +2,10 @@ import ensureNotEmpty from '../library/ensure-not-empty';
 
 export default (parsed, when) => {
 	const negated = when === 'never';
+	const notEmpty = ensureNotEmpty(parsed.subject);
+
 	return [
-		ensureNotEmpty(parsed.subject),
+		negated ? notEmpty : !notEmpty,
 		[
 			'message',
 			negated ? 'may not' : 'must',
diff --git a/test/rules/subject-empty.js b/test/rules/subject-empty.js
index 3218a0ef1b..8fa397c462 100644
--- a/test/rules/subject-empty.js
+++ b/test/rules/subject-empty.js
@@ -12,7 +12,7 @@ const parsed = {
 	filled: parse(messages.filled)
 };
 
-test.failing('subject-empty without subject should succeed for empty keyword', t => {
+test('subject-empty without subject should succeed for empty keyword', t => {
 	const [actual] = subjectEmpty(parsed.empty);
 	const expected = true;
 	t.is(actual, expected);
@@ -24,13 +24,13 @@ test('subject-empty without subject should fail for "never"', t => {
 	t.is(actual, expected);
 });
 
-test.failing('subject-empty without subject should succeed for "always"', t => {
+test('subject-empty without subject should succeed for "always"', t => {
 	const [actual] = subjectEmpty(parsed.empty, 'always');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('subject-empty with subject fail for empty keyword', t => {
+test('subject-empty with subject fail for empty keyword', t => {
 	const [actual] = subjectEmpty(parsed.filled);
 	const expected = false;
 	t.is(actual, expected);
@@ -42,7 +42,7 @@ test('subject-empty with subject succeed for "never"', t => {
 	t.is(actual, expected);
 });
 
-test.failing('subject-empty with subject fail for "always"', t => {
+test('subject-empty with subject fail for "always"', t => {
 	const [actual] = subjectEmpty(parsed.filled, 'always');
 	const expected = false;
 	t.is(actual, expected);

From 6194f4a72afc83a3b85c5f4081457bcaf8b68971 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 1 May 2017 23:19:36 +0200
Subject: [PATCH 12/77] test: add cases for type-empty

---
 test/rules/type-empty.js | 49 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 test/rules/type-empty.js

diff --git a/test/rules/type-empty.js b/test/rules/type-empty.js
new file mode 100644
index 0000000000..4271cd0cd2
--- /dev/null
+++ b/test/rules/type-empty.js
@@ -0,0 +1,49 @@
+import test from 'ava';
+import parse from '../../source/library/parse';
+import typeEmpty from '../../source/rules/type-empty';
+
+const messages = {
+	empty: '(scope):',
+	filled: 'type: subject'
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	filled: parse(messages.filled)
+};
+
+test.failing('without type should succeed for empty keyword', t => {
+	const [actual] = typeEmpty(parsed.empty);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('without type should fail for "never"', t => {
+	const [actual] = typeEmpty(parsed.empty, 'never');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('without type should succeed for "always"', t => {
+	const [actual] = typeEmpty(parsed.empty, 'always');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with type fail for empty keyword', t => {
+	const [actual] = typeEmpty(parsed.filled);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with type succeed for "never"', t => {
+	const [actual] = typeEmpty(parsed.filled, 'never');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with type fail for "always"', t => {
+	const [actual] = typeEmpty(parsed.filled, 'always');
+	const expected = false;
+	t.is(actual, expected);
+});

From 4bebfc742ec22ffd06ba4ca31ade5f35a666557b Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 1 May 2017 23:20:17 +0200
Subject: [PATCH 13/77] test: remove superfluous message prefixes

---
 test/rules/body-empty.js           | 12 ++++++------
 test/rules/footer-empty.js         | 18 +++++++++---------
 test/rules/footer-leading-blank.js | 30 +++++++++++++++---------------
 test/rules/footer-max-length.js    |  8 ++++----
 test/rules/footer-min-length.js    |  8 ++++----
 test/rules/scope-empty.js          | 18 +++++++++---------
 test/rules/scope-enum.js           |  2 +-
 test/rules/subject-empty.js        | 12 ++++++------
 8 files changed, 54 insertions(+), 54 deletions(-)

diff --git a/test/rules/body-empty.js b/test/rules/body-empty.js
index fed4b592e4..d44d7868bb 100644
--- a/test/rules/body-empty.js
+++ b/test/rules/body-empty.js
@@ -12,37 +12,37 @@ const parsed = {
 	filled: parse(messages.filled)
 };
 
-test('body-empty with empty body should succeed for empty keyword', t => {
+test('with empty body should succeed for empty keyword', t => {
 	const [actual] = bodyEmpty(parsed.empty);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('body-empty with empty body should fail for "never"', t => {
+test('with empty body should fail for "never"', t => {
 	const [actual] = bodyEmpty(parsed.empty, 'never');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('body-empty with empty body should succeed for "always"', t => {
+test('with empty body should succeed for "always"', t => {
 	const [actual] = bodyEmpty(parsed.empty, 'always');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('body-empty with body should fail for empty keyword', t => {
+test('with body should fail for empty keyword', t => {
 	const [actual] = bodyEmpty(parsed.filled);
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('body-empty with body should succeed for "never"', t => {
+test('with body should succeed for "never"', t => {
 	const [actual] = bodyEmpty(parsed.filled, 'never');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('body-empty with body should fail for "always"', t => {
+test('with body should fail for "always"', t => {
 	const [actual] = bodyEmpty(parsed.filled, 'always');
 	const expected = false;
 	t.is(actual, expected);
diff --git a/test/rules/footer-empty.js b/test/rules/footer-empty.js
index 7743a5476f..46fe1f5243 100644
--- a/test/rules/footer-empty.js
+++ b/test/rules/footer-empty.js
@@ -14,55 +14,55 @@ const parsed = {
 	filled: parse(messages.filled)
 };
 
-test('footer-empty with simple message should succeed for empty keyword', t => {
+test('with simple message should succeed for empty keyword', t => {
 	const [actual] = footerEmpty(parsed.simple);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-empty with simple message should fail for "never"', t => {
+test('with simple message should fail for "never"', t => {
 	const [actual] = footerEmpty(parsed.simple, 'never');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('footer-empty with simple message should succeed for "always"', t => {
+test('with simple message should succeed for "always"', t => {
 	const [actual] = footerEmpty(parsed.simple, 'always');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-empty with empty footer should succeed for empty keyword', t => {
+test('with empty footer should succeed for empty keyword', t => {
 	const [actual] = footerEmpty(parsed.empty);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-empty with empty footer should fail for "never"', t => {
+test('with empty footer should fail for "never"', t => {
 	const [actual] = footerEmpty(parsed.empty, 'never');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('footer-empty with empty footer should succeed for "always"', t => {
+test('with empty footer should succeed for "always"', t => {
 	const [actual] = footerEmpty(parsed.empty, 'always');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-empty with footer should fail for empty keyword', t => {
+test('with footer should fail for empty keyword', t => {
 	const [actual] = footerEmpty(parsed.filled);
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('footer-empty with footer should succeed for "never"', t => {
+test('with footer should succeed for "never"', t => {
 	const [actual] = footerEmpty(parsed.filled, 'never');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-empty with footer should fail for "always"', t => {
+test('with footer should fail for "always"', t => {
 	const [actual] = footerEmpty(parsed.filled, 'always');
 	const expected = false;
 	t.is(actual, expected);
diff --git a/test/rules/footer-leading-blank.js b/test/rules/footer-leading-blank.js
index 731517ff3c..d0764489b9 100644
--- a/test/rules/footer-leading-blank.js
+++ b/test/rules/footer-leading-blank.js
@@ -18,91 +18,91 @@ const parsed = {
 	with: parse(messages.with)
 };
 
-test('footer-leading-blank with simple message should succeed for empty keyword', t => {
+test('with simple message should succeed for empty keyword', t => {
 	const [actual] = footerLeadingBlank(parsed.simple);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-leading-blank with simple message should succeed for "never"', t => {
+test('with simple message should succeed for "never"', t => {
 	const [actual] = footerLeadingBlank(parsed.simple, 'never');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-leading-blank with simple message should succeed for "always"', t => {
+test('with simple message should succeed for "always"', t => {
 	const [actual] = footerLeadingBlank(parsed.simple, 'always');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-leading-blank with body message should succeed for empty keyword', t => {
+test('with body message should succeed for empty keyword', t => {
 	const [actual] = footerLeadingBlank(parsed.body);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-leading-blank with body message should succeed for "never"', t => {
+test('with body message should succeed for "never"', t => {
 	const [actual] = footerLeadingBlank(parsed.body, 'never');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-leading-blank with body message should succeed for "always"', t => {
+test('with body message should succeed for "always"', t => {
 	const [actual] = footerLeadingBlank(parsed.body, 'always');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-leading-blank with trailing message should succeed for empty keyword', t => {
+test('with trailing message should succeed for empty keyword', t => {
 	const [actual] = footerLeadingBlank(parsed.trailing);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-leading-blank with trailing message should succeed for "never"', t => {
+test('with trailing message should succeed for "never"', t => {
 	const [actual] = footerLeadingBlank(parsed.trailing, 'never');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-leading-blank with trailing message should succeed for "always"', t => {
+test('with trailing message should succeed for "always"', t => {
 	const [actual] = footerLeadingBlank(parsed.trailing, 'always');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-leading-blank without blank line before footer should fail for empty keyword', t => {
+test('without blank line before footer should fail for empty keyword', t => {
 	const [actual] = footerLeadingBlank(parsed.without);
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('footer-leading-blank without blank line before footer should succeed for "never"', t => {
+test('without blank line before footer should succeed for "never"', t => {
 	const [actual] = footerLeadingBlank(parsed.without, 'never');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-leading-blank without blank line before footer should fail for "always"', t => {
+test('without blank line before footer should fail for "always"', t => {
 	const [actual] = footerLeadingBlank(parsed.without, 'always');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('footer-leading-blank with blank line before footer should succeed for empty keyword', t => {
+test('with blank line before footer should succeed for empty keyword', t => {
 	const [actual] = footerLeadingBlank(parsed.with);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-leading-blank with blank line before footer should fail for "never"', t => {
+test('with blank line before footer should fail for "never"', t => {
 	const [actual] = footerLeadingBlank(parsed.with, 'never');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('footer-leading-blank with blank line before footer should succeed for "always"', t => {
+test('with blank line before footer should succeed for "always"', t => {
 	const [actual] = footerLeadingBlank(parsed.with, 'always');
 	const expected = true;
 	t.is(actual, expected);
diff --git a/test/rules/footer-max-length.js b/test/rules/footer-max-length.js
index 1bdbdbf413..efcc2d18a7 100644
--- a/test/rules/footer-max-length.js
+++ b/test/rules/footer-max-length.js
@@ -21,25 +21,25 @@ const parsed = {
 	long: parse(messages.long)
 };
 
-test('footer-max-length with simple message should succeed', t => {
+test('with simple message should succeed', t => {
 	const [actual] = footerMaxLength(parsed.simple, '', allowed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-max-length with empty footer should succeed', t => {
+test('with empty footer should succeed', t => {
 	const [actual] = footerMaxLength(parsed.empty, '', allowed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-max-length with short footer should succeed', t => {
+test('with short footer should succeed', t => {
 	const [actual] = footerMaxLength(parsed.short, '', allowed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-max-length with long footer should fail', t => {
+test('with long footer should fail', t => {
 	const [actual] = footerMaxLength(parsed.long, '', allowed);
 	const expected = false;
 	t.is(actual, expected);
diff --git a/test/rules/footer-min-length.js b/test/rules/footer-min-length.js
index c55b64fdad..9970d33b50 100644
--- a/test/rules/footer-min-length.js
+++ b/test/rules/footer-min-length.js
@@ -21,25 +21,25 @@ const parsed = {
 	long: parse(messages.long)
 };
 
-test('footer-min-length with simple message should succeed', t => {
+test('with simple message should succeed', t => {
 	const [actual] = footerMinLength(parsed.simple, '', needed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-min-length with empty footer should succeed', t => {
+test('with empty footer should succeed', t => {
 	const [actual] = footerMinLength(parsed.empty, '', needed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('footer-min-length with short footer should fail', t => {
+test('with short footer should fail', t => {
 	const [actual] = footerMinLength(parsed.short, '', needed);
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('footer-min-length with long footer should succeed', t => {
+test('with long footer should succeed', t => {
 	const [actual] = footerMinLength(parsed.long, '', needed);
 	const expected = true;
 	t.is(actual, expected);
diff --git a/test/rules/scope-empty.js b/test/rules/scope-empty.js
index 3ac7a42041..0c5d786988 100644
--- a/test/rules/scope-empty.js
+++ b/test/rules/scope-empty.js
@@ -14,55 +14,55 @@ const parsed = {
 	empty: parse(messages.empty)
 };
 
-test('scope-empty with plain message it should succeed for empty keyword', t => {
+test('with plain message it should succeed for empty keyword', t => {
 	const [actual] = scopeEmpty(parsed.plain);
 	const expected = true;
 	t.deepEqual(actual, expected);
 });
 
-test('scope-empty with plain message it should succeed for "never"', t => {
+test('with plain message it should succeed for "never"', t => {
 	const [actual] = scopeEmpty(parsed.plain, 'never');
 	const expected = true;
 	t.deepEqual(actual, expected);
 });
 
-test('scope-empty with plain message it should fail for "always"', t => {
+test('with plain message it should fail for "always"', t => {
 	const [actual] = scopeEmpty(parsed.plain, 'always');
 	const expected = false;
 	t.deepEqual(actual, expected);
 });
 
-test('scope-empty with superfluous message it should fail for empty keyword', t => {
+test('with superfluous message it should fail for empty keyword', t => {
 	const [actual] = scopeEmpty(parsed.superfluous);
 	const expected = false;
 	t.deepEqual(actual, expected);
 });
 
-test('scope-empty with superfluous message it should fail for "never"', t => {
+test('with superfluous message it should fail for "never"', t => {
 	const [actual] = scopeEmpty(parsed.superfluous, 'never');
 	const expected = false;
 	t.deepEqual(actual, expected);
 });
 
-test('scope-empty with superfluous message it should fail for "always"', t => {
+test('with superfluous message it should fail for "always"', t => {
 	const [actual] = scopeEmpty(parsed.superfluous, 'always');
 	const expected = true;
 	t.deepEqual(actual, expected);
 });
 
-test('scope-empty with empty message it should fail for empty keyword', t => {
+test('with empty message it should fail for empty keyword', t => {
 	const [actual] = scopeEmpty(parsed.empty);
 	const expected = false;
 	t.deepEqual(actual, expected);
 });
 
-test('scope-empty with empty message it should fail for "never"', t => {
+test('with empty message it should fail for "never"', t => {
 	const [actual] = scopeEmpty(parsed.empty, 'never');
 	const expected = false;
 	t.deepEqual(actual, expected);
 });
 
-test('scope-empty with empty message it should fail for "always"', t => {
+test('with empty message it should fail for "always"', t => {
 	const [actual] = scopeEmpty(parsed.empty, 'always');
 	const expected = true;
 	t.deepEqual(actual, expected);
diff --git a/test/rules/scope-enum.js b/test/rules/scope-enum.js
index f4a2a26e44..ec57802882 100644
--- a/test/rules/scope-enum.js
+++ b/test/rules/scope-enum.js
@@ -26,7 +26,7 @@ test('scope-enum with plain message and never should error empty enum', t => {
 	t.deepEqual(actual, expected);
 });
 
-test('scope-enum with plain message should succeed correct enum', t => {
+test('with plain message should succeed correct enum', t => {
 	const [actual] = scopeEnum(parsed.plain, 'always', ['bar']);
 	const expected = true;
 	t.deepEqual(actual, expected);
diff --git a/test/rules/subject-empty.js b/test/rules/subject-empty.js
index 8fa397c462..af2d4e293c 100644
--- a/test/rules/subject-empty.js
+++ b/test/rules/subject-empty.js
@@ -12,37 +12,37 @@ const parsed = {
 	filled: parse(messages.filled)
 };
 
-test('subject-empty without subject should succeed for empty keyword', t => {
+test('without subject should succeed for empty keyword', t => {
 	const [actual] = subjectEmpty(parsed.empty);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('subject-empty without subject should fail for "never"', t => {
+test('without subject should fail for "never"', t => {
 	const [actual] = subjectEmpty(parsed.empty, 'never');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('subject-empty without subject should succeed for "always"', t => {
+test('without subject should succeed for "always"', t => {
 	const [actual] = subjectEmpty(parsed.empty, 'always');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('subject-empty with subject fail for empty keyword', t => {
+test('with subject fail for empty keyword', t => {
 	const [actual] = subjectEmpty(parsed.filled);
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('subject-empty with subject succeed for "never"', t => {
+test('with subject succeed for "never"', t => {
 	const [actual] = subjectEmpty(parsed.filled, 'never');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('subject-empty with subject fail for "always"', t => {
+test('with subject fail for "always"', t => {
 	const [actual] = subjectEmpty(parsed.filled, 'always');
 	const expected = false;
 	t.is(actual, expected);

From 70e42f55c1ce07bdcc235ade7dac25e705382bcb Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 1 May 2017 23:20:53 +0200
Subject: [PATCH 14/77] fix: use keywords in type-empty

---
 source/rules/type-empty.js | 3 ++-
 test/rules/type-empty.js   | 8 ++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/source/rules/type-empty.js b/source/rules/type-empty.js
index 39e327eee2..d265b76b24 100644
--- a/source/rules/type-empty.js
+++ b/source/rules/type-empty.js
@@ -2,8 +2,9 @@ import ensureNotEmpty from '../library/ensure-not-empty';
 
 export default (parsed, when) => {
 	const negated = when === 'never';
+	const notEmpty = ensureNotEmpty(parsed.type);
 	return [
-		ensureNotEmpty(parsed.type),
+		negated ? notEmpty : !notEmpty,
 		[
 			'type',
 			negated ? 'may not' : 'must',
diff --git a/test/rules/type-empty.js b/test/rules/type-empty.js
index 4271cd0cd2..21a2f5cd77 100644
--- a/test/rules/type-empty.js
+++ b/test/rules/type-empty.js
@@ -12,7 +12,7 @@ const parsed = {
 	filled: parse(messages.filled)
 };
 
-test.failing('without type should succeed for empty keyword', t => {
+test('without type should succeed for empty keyword', t => {
 	const [actual] = typeEmpty(parsed.empty);
 	const expected = true;
 	t.is(actual, expected);
@@ -24,13 +24,13 @@ test('without type should fail for "never"', t => {
 	t.is(actual, expected);
 });
 
-test.failing('without type should succeed for "always"', t => {
+test('without type should succeed for "always"', t => {
 	const [actual] = typeEmpty(parsed.empty, 'always');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('with type fail for empty keyword', t => {
+test('with type fail for empty keyword', t => {
 	const [actual] = typeEmpty(parsed.filled);
 	const expected = false;
 	t.is(actual, expected);
@@ -42,7 +42,7 @@ test('with type succeed for "never"', t => {
 	t.is(actual, expected);
 });
 
-test.failing('with type fail for "always"', t => {
+test('with type fail for "always"', t => {
 	const [actual] = typeEmpty(parsed.filled, 'always');
 	const expected = false;
 	t.is(actual, expected);

From d304cbf4fea70de362230dd0e6ee5f3e2bae4f1a Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 1 May 2017 23:36:46 +0200
Subject: [PATCH 15/77] style: move tests into colocation

---
 .../library/get-configuration.test.js                         | 2 +-
 .../get-messages.js => source/library/get-messages.test.js    | 2 +-
 test/rules/body-empty.js => source/rules/body-empty.test.js   | 4 ++--
 .../footer-empty.js => source/rules/footer-empty.test.js      | 4 ++--
 .../rules/footer-leading-blank.test.js                        | 4 ++--
 .../rules/footer-max-length.test.js                           | 4 ++--
 .../rules/footer-min-length.test.js                           | 4 ++--
 test/rules/scope-empty.js => source/rules/scope-empty.test.js | 4 ++--
 test/rules/scope-enum.js => source/rules/scope-enum.test.js   | 4 ++--
 .../subject-empty.js => source/rules/subject-empty.test.js    | 4 ++--
 test/rules/type-empty.js => source/rules/type-empty.test.js   | 4 ++--
 11 files changed, 20 insertions(+), 20 deletions(-)
 rename test/integration/get-configuration.js => source/library/get-configuration.test.js (95%)
 rename test/integration/get-messages.js => source/library/get-messages.test.js (98%)
 rename test/rules/body-empty.js => source/rules/body-empty.test.js (91%)
 rename test/rules/footer-empty.js => source/rules/footer-empty.test.js (94%)
 rename test/rules/footer-leading-blank.js => source/rules/footer-leading-blank.test.js (96%)
 rename test/rules/footer-max-length.js => source/rules/footer-max-length.test.js (90%)
 rename test/rules/footer-min-length.js => source/rules/footer-min-length.test.js (90%)
 rename test/rules/scope-empty.js => source/rules/scope-empty.test.js (94%)
 rename test/rules/scope-enum.js => source/rules/scope-enum.test.js (96%)
 rename test/rules/subject-empty.js => source/rules/subject-empty.test.js (91%)
 rename test/rules/type-empty.js => source/rules/type-empty.test.js (91%)

diff --git a/test/integration/get-configuration.js b/source/library/get-configuration.test.js
similarity index 95%
rename from test/integration/get-configuration.js
rename to source/library/get-configuration.test.js
index 5b6d3b8b64..e44b63eb7f 100644
--- a/test/integration/get-configuration.js
+++ b/source/library/get-configuration.test.js
@@ -2,7 +2,7 @@ import path from 'path';
 import test from 'ava';
 import expect from 'unexpected';
 
-import getConfiguration from '../../source/library/get-configuration';
+import getConfiguration from './get-configuration';
 
 const cwd = process.cwd();
 
diff --git a/test/integration/get-messages.js b/source/library/get-messages.test.js
similarity index 98%
rename from test/integration/get-messages.js
rename to source/library/get-messages.test.js
index 4dd3471f02..01b0e9b048 100644
--- a/test/integration/get-messages.js
+++ b/source/library/get-messages.test.js
@@ -10,7 +10,7 @@ import exists from 'path-exists';
 import rimraf from 'rimraf';
 import expect from 'unexpected';
 
-import getMessages from '../../source/library/get-messages';
+import getMessages from './get-messages';
 import pkg from '../../package';
 
 const rm = denodeify(rimraf);
diff --git a/test/rules/body-empty.js b/source/rules/body-empty.test.js
similarity index 91%
rename from test/rules/body-empty.js
rename to source/rules/body-empty.test.js
index d44d7868bb..d27cd5f1e1 100644
--- a/test/rules/body-empty.js
+++ b/source/rules/body-empty.test.js
@@ -1,6 +1,6 @@
 import test from 'ava';
-import parse from '../../source/library/parse';
-import bodyEmpty from '../../source/rules/body-empty';
+import parse from '../library/parse';
+import bodyEmpty from './body-empty';
 
 const messages = {
 	empty: 'chore: subject',
diff --git a/test/rules/footer-empty.js b/source/rules/footer-empty.test.js
similarity index 94%
rename from test/rules/footer-empty.js
rename to source/rules/footer-empty.test.js
index 46fe1f5243..033e9c9e1c 100644
--- a/test/rules/footer-empty.js
+++ b/source/rules/footer-empty.test.js
@@ -1,6 +1,6 @@
 import test from 'ava';
-import parse from '../../source/library/parse';
-import footerEmpty from '../../source/rules/footer-empty';
+import parse from '../library/parse';
+import footerEmpty from './footer-empty';
 
 const messages = {
 	simple: 'chore: subject',
diff --git a/test/rules/footer-leading-blank.js b/source/rules/footer-leading-blank.test.js
similarity index 96%
rename from test/rules/footer-leading-blank.js
rename to source/rules/footer-leading-blank.test.js
index d0764489b9..fb25915fac 100644
--- a/test/rules/footer-leading-blank.js
+++ b/source/rules/footer-leading-blank.test.js
@@ -1,6 +1,6 @@
 import test from 'ava';
-import parse from '../../source/library/parse';
-import footerLeadingBlank from '../../source/rules/footer-leading-blank';
+import parse from '../library/parse';
+import footerLeadingBlank from './footer-leading-blank';
 
 const messages = {
 	simple: 'chore: subject',
diff --git a/test/rules/footer-max-length.js b/source/rules/footer-max-length.test.js
similarity index 90%
rename from test/rules/footer-max-length.js
rename to source/rules/footer-max-length.test.js
index efcc2d18a7..239bcdcc65 100644
--- a/test/rules/footer-max-length.js
+++ b/source/rules/footer-max-length.test.js
@@ -1,6 +1,6 @@
 import test from 'ava';
-import parse from '../../source/library/parse';
-import footerMaxLength from '../../source/rules/footer-max-length';
+import parse from '../library/parse';
+import footerMaxLength from './footer-max-length';
 
 const short = 'BREAKING CHANGE: a';
 const long = 'BREAKING CHANGE: ab';
diff --git a/test/rules/footer-min-length.js b/source/rules/footer-min-length.test.js
similarity index 90%
rename from test/rules/footer-min-length.js
rename to source/rules/footer-min-length.test.js
index 9970d33b50..a0e80fd347 100644
--- a/test/rules/footer-min-length.js
+++ b/source/rules/footer-min-length.test.js
@@ -1,6 +1,6 @@
 import test from 'ava';
-import parse from '../../source/library/parse';
-import footerMinLength from '../../source/rules/footer-min-length';
+import parse from '../library/parse';
+import footerMinLength from './footer-min-length';
 
 const short = 'BREAKING CHANGE: a';
 const long = 'BREAKING CHANGE: ab';
diff --git a/test/rules/scope-empty.js b/source/rules/scope-empty.test.js
similarity index 94%
rename from test/rules/scope-empty.js
rename to source/rules/scope-empty.test.js
index 0c5d786988..8935c7f31f 100644
--- a/test/rules/scope-empty.js
+++ b/source/rules/scope-empty.test.js
@@ -1,6 +1,6 @@
 import test from 'ava';
-import parse from '../../source/library/parse';
-import scopeEmpty from '../../source/rules/scope-empty';
+import parse from '../library/parse';
+import scopeEmpty from './scope-empty';
 
 const messages = {
 	plain: 'foo(bar): baz',
diff --git a/test/rules/scope-enum.js b/source/rules/scope-enum.test.js
similarity index 96%
rename from test/rules/scope-enum.js
rename to source/rules/scope-enum.test.js
index ec57802882..c470bb8f6e 100644
--- a/test/rules/scope-enum.js
+++ b/source/rules/scope-enum.test.js
@@ -1,6 +1,6 @@
 import test from 'ava';
-import parse from '../../source/library/parse';
-import scopeEnum from '../../source/rules/scope-enum';
+import parse from '../library/parse';
+import scopeEnum from './scope-enum';
 
 const messages = {
 	plain: 'foo(bar): baz',
diff --git a/test/rules/subject-empty.js b/source/rules/subject-empty.test.js
similarity index 91%
rename from test/rules/subject-empty.js
rename to source/rules/subject-empty.test.js
index af2d4e293c..1994047258 100644
--- a/test/rules/subject-empty.js
+++ b/source/rules/subject-empty.test.js
@@ -1,6 +1,6 @@
 import test from 'ava';
-import parse from '../../source/library/parse';
-import subjectEmpty from '../../source/rules/subject-empty';
+import parse from '../library/parse';
+import subjectEmpty from './subject-empty';
 
 const messages = {
 	empty: 'chore: \nbody',
diff --git a/test/rules/type-empty.js b/source/rules/type-empty.test.js
similarity index 91%
rename from test/rules/type-empty.js
rename to source/rules/type-empty.test.js
index 21a2f5cd77..9036a4586e 100644
--- a/test/rules/type-empty.js
+++ b/source/rules/type-empty.test.js
@@ -1,6 +1,6 @@
 import test from 'ava';
-import parse from '../../source/library/parse';
-import typeEmpty from '../../source/rules/type-empty';
+import parse from '../library/parse';
+import typeEmpty from './type-empty';
 
 const messages = {
 	empty: '(scope):',

From 6c338e0a4922303e5438543e82ac425b6e793612 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 13:54:36 +0200
Subject: [PATCH 16/77] test: add body-case test cases

---
 source/rules/body-case.test.js | 83 ++++++++++++++++++++++++++++++++++
 1 file changed, 83 insertions(+)
 create mode 100644 source/rules/body-case.test.js

diff --git a/source/rules/body-case.test.js b/source/rules/body-case.test.js
new file mode 100644
index 0000000000..3480b54da7
--- /dev/null
+++ b/source/rules/body-case.test.js
@@ -0,0 +1,83 @@
+import test from 'ava';
+import parse from '../library/parse';
+import bodyCase from './body-case';
+
+const messages = {
+	empty: 'chore: subject',
+	lowercase: 'chore: subject\nbody',
+	mixedcase: 'chore: subject\nBody',
+	uppercase: 'chore: subject\nBODY'
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	lowercase: parse(messages.lowercase),
+	mixedcase: parse(messages.mixedcase),
+	uppercase: parse(messages.uppercase)
+};
+
+test.failing('with empty body should succeed for empty keyword', t => {
+	const [actual] = bodyCase(parsed.empty);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with empty body should succeed for "never lowercase"', t => {
+	const [actual] = bodyCase(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');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with empty body should succeed for "never uppercase"', t => {
+	const [actual] = bodyCase(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');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with lowercase body should fail for "never lowercase"', t => {
+	const [actual] = bodyCase(parsed.lowercase, 'never', 'lowercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('with lowercase body should succeed for "always lowercase"', t => {
+	const [actual] = bodyCase(parsed.lowercase, 'always', 'lowercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with mixedcase body should fail for "never lowercase"', t => {
+	const [actual] = bodyCase(parsed.mixedcase, 'never', 'lowercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('with mixedcase body should fail for "always lowercase"', t => {
+	const [actual] = bodyCase(parsed.mixedcase, 'always', 'lowercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('with uppercase body should fail for "never uppercase"', t => {
+	const [actual] = bodyCase(parsed.uppercase, 'never', 'uppercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('with lowercase body should succeed for "always uppercase"', t => {
+	const [actual] = bodyCase(parsed.uppercase, 'always', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});

From 65fc90a4e7eb37982ca0e0d1efc458774d75cfe1 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 13:57:12 +0200
Subject: [PATCH 17/77] fix: handle empty body gracefully

---
 source/rules/body-case.js      |  7 +++++++
 source/rules/body-case.test.js | 10 ++--------
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/source/rules/body-case.js b/source/rules/body-case.js
index 8d0694c4f4..b782030234 100644
--- a/source/rules/body-case.js
+++ b/source/rules/body-case.js
@@ -1,7 +1,14 @@
 import ensureCase from '../library/ensure-case';
 
 export default (parsed, when, value) => {
+	const {body} = parsed;
+
+	if (!body) {
+		return [true];
+	}
+
 	const negated = when === 'never';
+
 	const result = ensureCase(parsed.body, value);
 	return [
 		negated ? !result : result,
diff --git a/source/rules/body-case.test.js b/source/rules/body-case.test.js
index 3480b54da7..520acc6b53 100644
--- a/source/rules/body-case.test.js
+++ b/source/rules/body-case.test.js
@@ -16,13 +16,7 @@ const parsed = {
 	uppercase: parse(messages.uppercase)
 };
 
-test.failing('with empty body should succeed for empty keyword', t => {
-	const [actual] = bodyCase(parsed.empty);
-	const expected = true;
-	t.is(actual, expected);
-});
-
-test.failing('with empty body should succeed for "never lowercase"', t => {
+test('with empty body should succeed for "never lowercase"', t => {
 	const [actual] = bodyCase(parsed.empty, 'never', 'lowercase');
 	const expected = true;
 	t.is(actual, expected);
@@ -34,7 +28,7 @@ test('with empty body should succeed for "always lowercase"', t => {
 	t.is(actual, expected);
 });
 
-test.failing('with empty body should succeed for "never uppercase"', t => {
+test('with empty body should succeed for "never uppercase"', t => {
 	const [actual] = bodyCase(parsed.empty, 'never', 'uppercase');
 	const expected = true;
 	t.is(actual, expected);

From 6b725acdc3076c8658611bc5bf406e882b4f0458 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 14:05:32 +0200
Subject: [PATCH 18/77] fix: rework ensure-case to produce saner output

---
 source/library/ensure-case.js  | 13 ++++++++++---
 source/rules/body-case.test.js | 26 +++++++++++++++++++-------
 2 files changed, 29 insertions(+), 10 deletions(-)

diff --git a/source/library/ensure-case.js b/source/library/ensure-case.js
index ed77506dae..f20358ed1e 100644
--- a/source/library/ensure-case.js
+++ b/source/library/ensure-case.js
@@ -1,4 +1,11 @@
-export default (a, stringCase) => {
-	const method = `to${stringCase[0].toUpperCase()}${stringCase.slice(1)}`;
-	return typeof a !== 'string' || a[method]() === a;
+export default (raw = '', target = 'lowercase') => {
+	const normalized = String(raw);
+
+	switch (target) {
+		case 'uppercase':
+			return normalized.toUpperCase() === normalized;
+		case 'lowercase':
+		default:
+			return normalized.toLowerCase() === normalized;
+	}
 };
diff --git a/source/rules/body-case.test.js b/source/rules/body-case.test.js
index 520acc6b53..30faa6de3a 100644
--- a/source/rules/body-case.test.js
+++ b/source/rules/body-case.test.js
@@ -40,37 +40,49 @@ test('with empty body should succeed for "always uppercase"', t => {
 	t.is(actual, expected);
 });
 
-test.failing('with lowercase body should fail for "never lowercase"', t => {
+test('with lowercase body should fail for "never lowercase"', t => {
 	const [actual] = bodyCase(parsed.lowercase, 'never', 'lowercase');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test.failing('with lowercase body should succeed for "always lowercase"', t => {
+test('with lowercase body should succeed for "always lowercase"', t => {
 	const [actual] = bodyCase(parsed.lowercase, 'always', 'lowercase');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('with mixedcase body should fail for "never lowercase"', t => {
+test('with mixedcase body should succeed for "never lowercase"', t => {
 	const [actual] = bodyCase(parsed.mixedcase, 'never', 'lowercase');
-	const expected = false;
+	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('with mixedcase body should fail for "always lowercase"', t => {
+test('with mixedcase body should fail for "always lowercase"', t => {
 	const [actual] = bodyCase(parsed.mixedcase, 'always', 'lowercase');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test.failing('with uppercase body should fail for "never uppercase"', t => {
+test('with mixedcase body should succeed for "never uppercase"', t => {
+	const [actual] = bodyCase(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');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with uppercase body should fail for "never uppercase"', t => {
 	const [actual] = bodyCase(parsed.uppercase, 'never', 'uppercase');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test.failing('with lowercase body should succeed for "always uppercase"', t => {
+test('with lowercase body should succeed for "always uppercase"', t => {
 	const [actual] = bodyCase(parsed.uppercase, 'always', 'uppercase');
 	const expected = true;
 	t.is(actual, expected);

From 1fdbdae5d921d872cae818b6de01420b08855882 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 14:08:59 +0200
Subject: [PATCH 19/77] test: add cases for body-leading-blank

---
 source/rules/body-leading-blank.test.js | 69 +++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 source/rules/body-leading-blank.test.js

diff --git a/source/rules/body-leading-blank.test.js b/source/rules/body-leading-blank.test.js
new file mode 100644
index 0000000000..e132ac22c5
--- /dev/null
+++ b/source/rules/body-leading-blank.test.js
@@ -0,0 +1,69 @@
+import test from 'ava';
+import parse from '../library/parse';
+import bodyLeadingBlank from './body-leading-blank';
+
+const messages = {
+	simple: 'chore: subject',
+	without: 'chore: subject\nbody',
+	with: 'chore: subject\n\nbody'
+};
+
+const parsed = {
+	simple: parse(messages.simple),
+	without: parse(messages.without),
+	with: parse(messages.with)
+};
+
+test('with simple message should succeed for empty keyword', t => {
+	const [actual] = bodyLeadingBlank(parsed.simple);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with simple message should succeed for "never"', t => {
+	const [actual] = bodyLeadingBlank(parsed.simple, 'never');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with simple message should succeed for "always"', t => {
+	const [actual] = bodyLeadingBlank(parsed.simple, 'always');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('without blank line before body should fail for empty keyword', t => {
+	const [actual] = bodyLeadingBlank(parsed.without);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('without blank line before body should succeed for "never"', t => {
+	const [actual] = bodyLeadingBlank(parsed.without, 'never');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('without blank line before body should fail for "always"', t => {
+	const [actual] = bodyLeadingBlank(parsed.without, 'always');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with blank line before body should succeed for empty keyword', t => {
+	const [actual] = bodyLeadingBlank(parsed.with);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with blank line before body should fail for "never"', t => {
+	const [actual] = bodyLeadingBlank(parsed.with, 'never');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with blank line before body should succeed for "always"', t => {
+	const [actual] = bodyLeadingBlank(parsed.with, 'always');
+	const expected = true;
+	t.is(actual, expected);
+});

From e314d5bd8ddce0a7f15de5abcc06f2ddeac5116d Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 14:17:57 +0200
Subject: [PATCH 20/77] test: add multiline body cases for footer-leading-blank

---
 source/rules/footer-leading-blank.test.js | 24 +++++++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/source/rules/footer-leading-blank.test.js b/source/rules/footer-leading-blank.test.js
index fb25915fac..e1e425b39b 100644
--- a/source/rules/footer-leading-blank.test.js
+++ b/source/rules/footer-leading-blank.test.js
@@ -7,7 +7,8 @@ const messages = {
 	body: 'chore: subject\nbody',
 	trailing: 'chore: subject\nbody\n\n',
 	without: 'chore: subject\nbody\nBREAKING CHANGE: something important',
-	with: 'chore: subject\nbody\n\nBREAKING CHANGE: something important'
+	with: 'chore: subject\nbody\n\nBREAKING CHANGE: something important',
+	withMulitLine: 'chore: subject\nmulti\nline\nbody\n\nBREAKING CHANGE: something important'
 };
 
 const parsed = {
@@ -15,7 +16,8 @@ const parsed = {
 	body: parse(messages.body),
 	trailing: parse(messages.trailing),
 	without: parse(messages.without),
-	with: parse(messages.with)
+	with: parse(messages.with),
+	withMulitLine: parse(messages.withMulitLine)
 };
 
 test('with simple message should succeed for empty keyword', t => {
@@ -107,3 +109,21 @@ test('with blank line before footer should succeed for "always"', t => {
 	const expected = true;
 	t.is(actual, expected);
 });
+
+test.failing('with blank line before footer and multiline body should succeed for empty keyword', t => {
+	const [actual] = footerLeadingBlank(parsed.withMulitLine);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with blank line before footer and multiline body should fail for "never"', t => {
+	const [actual] = footerLeadingBlank(parsed.withMulitLine, 'never');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('with blank line before footer and multiline body should succeed for "always"', t => {
+	const [actual] = footerLeadingBlank(parsed.withMulitLine, 'always');
+	const expected = true;
+	t.is(actual, expected);
+});

From ea741880692a2dd5ff6be9bb1904a1c0284d4d9c Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 14:18:27 +0200
Subject: [PATCH 21/77] fix: handle multiline bodies properly

---
 source/rules/footer-leading-blank.js      | 11 ++++++++---
 source/rules/footer-leading-blank.test.js |  6 +++---
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/source/rules/footer-leading-blank.js b/source/rules/footer-leading-blank.js
index eaec80b41d..23a0066a7d 100644
--- a/source/rules/footer-leading-blank.js
+++ b/source/rules/footer-leading-blank.js
@@ -6,11 +6,16 @@ export default (parsed, when) => {
 
 	const negated = when === 'never';
 
-	// get complete body split into lines
-	const lines = (parsed.raw || '').split(/\r|\n/).slice(2);
+	const count = (parsed.body || '').split(/\r|\n/).length;
+
+	// get complete message split into lines
+	const lines = (parsed.raw || '')
+		.split(/\r|\n/)
+		.slice(count + 1);
+
 	const [leading] = lines;
 
-	// check if the first line of body is empty
+	// check if the first line of footer is empty
 	const succeeds = leading === '';
 
 	return [
diff --git a/source/rules/footer-leading-blank.test.js b/source/rules/footer-leading-blank.test.js
index e1e425b39b..6fa76fb81b 100644
--- a/source/rules/footer-leading-blank.test.js
+++ b/source/rules/footer-leading-blank.test.js
@@ -110,19 +110,19 @@ test('with blank line before footer should succeed for "always"', t => {
 	t.is(actual, expected);
 });
 
-test.failing('with blank line before footer and multiline body should succeed for empty keyword', t => {
+test('with blank line before footer and multiline body should succeed for empty keyword', t => {
 	const [actual] = footerLeadingBlank(parsed.withMulitLine);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('with blank line before footer and multiline body should fail for "never"', t => {
+test('with blank line before footer and multiline body should fail for "never"', t => {
 	const [actual] = footerLeadingBlank(parsed.withMulitLine, 'never');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test.failing('with blank line before footer and multiline body should succeed for "always"', t => {
+test('with blank line before footer and multiline body should succeed for "always"', t => {
 	const [actual] = footerLeadingBlank(parsed.withMulitLine, 'always');
 	const expected = true;
 	t.is(actual, expected);

From 25c43f8eb977b25a885b4bf3402cd13a418b12b9 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 14:18:43 +0200
Subject: [PATCH 22/77] fix: harden body-leading-blank implementation

---
 source/rules/body-leading-blank.js      | 20 +++++++++++++-------
 source/rules/body-leading-blank.test.js |  2 +-
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/source/rules/body-leading-blank.js b/source/rules/body-leading-blank.js
index 46b4ac87bc..d6b3d5c3d7 100644
--- a/source/rules/body-leading-blank.js
+++ b/source/rules/body-leading-blank.js
@@ -1,14 +1,20 @@
 export default (parsed, when) => {
+	// flunk if no body is found
+	if (!parsed.body) {
+		return [true];
+	}
+
 	const negated = when === 'never';
+
 	// get complete body split into lines
-	const lines = (parsed.raw || '').split('\n').slice(1);
-	// check if the first line of body (if any) is empty
-	const leadingBlank =
-		lines.length > 0 ?
-		lines[0].length === 0 :
-		true;
+	const lines = (parsed.raw || '').split(/\r|\n/).slice(1);
+	const [leading] = lines;
+
+	// check if the first line of body is empty
+	const succeeds = leading === '';
+
 	return [
-		negated ? !leadingBlank : leadingBlank,
+		negated ? !succeeds : succeeds,
 		[
 			'body',
 			negated ? 'may not' : 'must',
diff --git a/source/rules/body-leading-blank.test.js b/source/rules/body-leading-blank.test.js
index e132ac22c5..273888999c 100644
--- a/source/rules/body-leading-blank.test.js
+++ b/source/rules/body-leading-blank.test.js
@@ -20,7 +20,7 @@ test('with simple message should succeed for empty keyword', t => {
 	t.is(actual, expected);
 });
 
-test.failing('with simple message should succeed for "never"', t => {
+test('with simple message should succeed for "never"', t => {
 	const [actual] = bodyLeadingBlank(parsed.simple, 'never');
 	const expected = true;
 	t.is(actual, expected);

From 7dfc3a275dbedcefeea0d35763eb46d92e3484ee Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 14:28:42 +0200
Subject: [PATCH 23/77] test: add body-max-length cases

---
 source/rules/body-max-length.test.js | 38 ++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 source/rules/body-max-length.test.js

diff --git a/source/rules/body-max-length.test.js b/source/rules/body-max-length.test.js
new file mode 100644
index 0000000000..4ddd9def12
--- /dev/null
+++ b/source/rules/body-max-length.test.js
@@ -0,0 +1,38 @@
+import test from 'ava';
+import parse from '../library/parse';
+import bodyMaxLength from './body-max-length';
+
+const short = 'a';
+const long = 'ab';
+
+const allowed = short.length;
+
+const messages = {
+	simple: 'chore: subject',
+	short: `chore: subject\n${short}`,
+	long: `chore: subject\n${long}`
+};
+
+const parsed = {
+	simple: parse(messages.simple),
+	short: parse(messages.short),
+	long: parse(messages.long)
+};
+
+test.failing('with simple message should succeed', t => {
+	const [actual] = bodyMaxLength(parsed.simple, '', allowed);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with short body should succeed', t => {
+	const [actual] = bodyMaxLength(parsed.short, '', allowed);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with long body should fail', t => {
+	const [actual] = bodyMaxLength(parsed.long, '', allowed);
+	const expected = false;
+	t.is(actual, expected);
+});

From 5e7f0ef547537187991f0182b4a9734cb3bcac1f Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 14:29:48 +0200
Subject: [PATCH 24/77] fix: handle empty body gracefully

---
 source/rules/body-max-length.js      | 4 ++++
 source/rules/body-max-length.test.js | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/source/rules/body-max-length.js b/source/rules/body-max-length.js
index ed6a25b3f1..e7cfa3f3bd 100644
--- a/source/rules/body-max-length.js
+++ b/source/rules/body-max-length.js
@@ -1,6 +1,10 @@
 import ensureMaxLength from '../library/ensure-max-length';
 
 export default (parsed, when, value) => {
+	if (!parsed.body) {
+		return [true];
+	}
+
 	return [
 		ensureMaxLength(parsed.body, value),
 		`body must not be longer than ${value} characters`
diff --git a/source/rules/body-max-length.test.js b/source/rules/body-max-length.test.js
index 4ddd9def12..f6ef9ef386 100644
--- a/source/rules/body-max-length.test.js
+++ b/source/rules/body-max-length.test.js
@@ -19,7 +19,7 @@ const parsed = {
 	long: parse(messages.long)
 };
 
-test.failing('with simple message should succeed', t => {
+test('with simple message should succeed', t => {
 	const [actual] = bodyMaxLength(parsed.simple, '', allowed);
 	const expected = true;
 	t.is(actual, expected);

From 239b7a02f18494d475800fd424115134c76f9795 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 14:31:48 +0200
Subject: [PATCH 25/77] test: add body-min-length cases

---
 source/rules/body-min-length.test.js | 38 ++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 source/rules/body-min-length.test.js

diff --git a/source/rules/body-min-length.test.js b/source/rules/body-min-length.test.js
new file mode 100644
index 0000000000..fe2b2521ef
--- /dev/null
+++ b/source/rules/body-min-length.test.js
@@ -0,0 +1,38 @@
+import test from 'ava';
+import parse from '../library/parse';
+import bodyMinLength from './body-min-length';
+
+const short = 'a';
+const long = 'ab';
+
+const needed = long.length;
+
+const messages = {
+	simple: 'chore: subject',
+	short: `chore: subject\n${short}`,
+	long: `chore: subject\n${long}`
+};
+
+const parsed = {
+	simple: parse(messages.simple),
+	short: parse(messages.short),
+	long: parse(messages.long)
+};
+
+test.failing('with simple message should succeed', t => {
+	const [actual] = bodyMinLength(parsed.simple, '', needed);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with short body should fail', t => {
+	const [actual] = bodyMinLength(parsed.short, '', needed);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with long body should succeed', t => {
+	const [actual] = bodyMinLength(parsed.long, '', needed);
+	const expected = true;
+	t.is(actual, expected);
+});

From d74210ddf7e41bbef518c81c0842f53b1f09f893 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 14:35:48 +0200
Subject: [PATCH 26/77] fix: handle empty body gracefully

---
 source/rules/body-min-length.js      | 4 ++++
 source/rules/body-min-length.test.js | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/source/rules/body-min-length.js b/source/rules/body-min-length.js
index 37bfe56242..55eca2b85e 100644
--- a/source/rules/body-min-length.js
+++ b/source/rules/body-min-length.js
@@ -1,6 +1,10 @@
 import ensureMinLength from '../library/ensure-min-length';
 
 export default (parsed, when, value) => {
+	if (!parsed.body) {
+		return [true];
+	}
+
 	return [
 		ensureMinLength(parsed.body, value),
 		`body must not be shorter than ${value} characters`
diff --git a/source/rules/body-min-length.test.js b/source/rules/body-min-length.test.js
index fe2b2521ef..c39c973ca1 100644
--- a/source/rules/body-min-length.test.js
+++ b/source/rules/body-min-length.test.js
@@ -19,7 +19,7 @@ const parsed = {
 	long: parse(messages.long)
 };
 
-test.failing('with simple message should succeed', t => {
+test('with simple message should succeed', t => {
 	const [actual] = bodyMinLength(parsed.simple, '', needed);
 	const expected = true;
 	t.is(actual, expected);

From 6269cf3300f1faea618fa0548268879c1c00972f Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 15:15:45 +0200
Subject: [PATCH 27/77] fix: add test case for footer-tense

---
 source/rules/footer-tense.test.js | 73 +++++++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 source/rules/footer-tense.test.js

diff --git a/source/rules/footer-tense.test.js b/source/rules/footer-tense.test.js
new file mode 100644
index 0000000000..9349f77a13
--- /dev/null
+++ b/source/rules/footer-tense.test.js
@@ -0,0 +1,73 @@
+import test from 'ava';
+import parse from '../library/parse';
+import footerTense from './footer-tense';
+
+const messages = {
+	empty: 'chore: subject\nbody',
+	presentImperative: `chore: subject\nBREAKING CHANGE: we implement things`,
+	presentParticiple: `chore: subject\nBREAKING CHANGE: implementing things`,
+	presentThirdPerson: `chore: implements things`,
+	past: `chore: subject\nBREAKING CHANGE: we did implement things`
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	presentImperative: parse(messages.presentImperative),
+	presentParticiple: parse(messages.presentParticiple),
+	presentThirdPerson: parse(messages.presentImperative),
+	past: parse(messages.past)
+};
+
+test('with empty footer should succeed', t => {
+	const [actual] = footerTense(parsed.empty, '', ['present-imperative']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with present footer should succeed for "always present-imperative"', t => {
+	const [actual] = footerTense(parsed.presentImperative, 'always', ['present-imperative']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with present footer should fail for "never present-imperative"', t => {
+	const [actual] = footerTense(parsed.presentImperative, 'never', ['present-imperative']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with present footer should succeed for "always present-participle"', t => {
+	const [actual] = footerTense(parsed.presentParticiple, 'always', ['present-participle']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with present footer should fail for "never present-participle"', t => {
+	const [actual] = footerTense(parsed.presentParticiple, 'never', ['present-participle']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('with present footer should succeed for "always present-third-person"', t => {
+	const [actual] = footerTense(parsed.presentThirdPerson, 'always', ['present-third-person']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with present footer should fail for "never present-third-person"', t => {
+	const [actual] = footerTense(parsed.presentThirdPerson, 'never', ['present-third-person']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('with past footer should succedd for "always past-tense"', t => {
+	const [actual] = footerTense(parsed.past, 'always', ['past-tense']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with past footer should fail for "never past-tense"', t => {
+	const [actual] = footerTense(parsed.past, 'never', ['past-tense']);
+	const expected = false;
+	t.is(actual, expected);
+});

From 6113353ce3b363613f4cb74f1a8d5249e1c66bd4 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 15:44:56 +0200
Subject: [PATCH 28/77] feat: introduce object based config for footer-tense

---
 source/library/ensure-tense.js    |  6 +++-
 source/rules/footer-tense.js      |  6 +++-
 source/rules/footer-tense.test.js | 59 ++++++++++++++++++++++++++-----
 3 files changed, 60 insertions(+), 11 deletions(-)

diff --git a/source/library/ensure-tense.js b/source/library/ensure-tense.js
index 663fd105ef..c8d897bf15 100644
--- a/source/library/ensure-tense.js
+++ b/source/library/ensure-tense.js
@@ -26,7 +26,7 @@ function getTags(lemmata) {
 	}
 }
 
-export default (input, allowed) => {
+export default (input, allowed, options = {}) => {
 	const lemmata = getLemmata(input);
 	const tagged = getTags(lemmata);
 	const verbs = tagged.filter(tag => tag[1][0] === 'V');
@@ -42,6 +42,10 @@ export default (input, allowed) => {
 			const [, tag] = verb;
 			return tags.length > 0 && tags.indexOf(tag) === -1;
 		})
+		.filter(verb => {
+			const [word] = verb;
+			return !options.ignored.some(ignored => ignored.indexOf(word) > -1);
+		})
 		.filter(Boolean)
 		.map(verb => {
 			const [lemma, tag] = verb;
diff --git a/source/rules/footer-tense.js b/source/rules/footer-tense.js
index f944efd954..1767689fed 100644
--- a/source/rules/footer-tense.js
+++ b/source/rules/footer-tense.js
@@ -1,8 +1,12 @@
 import ensureTense from '../library/ensure-tense';
 
 export default (parsed, when, value) => {
+	const tenses = Array.isArray(value) ? value : value.allowed || [];
+	const ignoreConfig = Array.isArray(value) ? [] : value.ignored || [];
+
 	const negated = when === 'never';
-	const {matches, offending} = ensureTense(parsed.footer, value);
+	const ignored = [...ignoreConfig, ...parsed.notes.map(note => note.title)];
+	const {matches, offending} = ensureTense(parsed.footer, tenses, {ignored});
 	const offenders = offending
 		.map(item => [item.lemma, item.tense].join(' - '))
 		.join(',');
diff --git a/source/rules/footer-tense.test.js b/source/rules/footer-tense.test.js
index 9349f77a13..a96bb8198d 100644
--- a/source/rules/footer-tense.test.js
+++ b/source/rules/footer-tense.test.js
@@ -6,8 +6,9 @@ const messages = {
 	empty: 'chore: subject\nbody',
 	presentImperative: `chore: subject\nBREAKING CHANGE: we implement things`,
 	presentParticiple: `chore: subject\nBREAKING CHANGE: implementing things`,
-	presentThirdPerson: `chore: implements things`,
-	past: `chore: subject\nBREAKING CHANGE: we did implement things`
+	presentThirdPerson: `chore: subject\nBREAKING CHANGE: implements things`,
+	past: `chore: subject\nBREAKING CHANGE: we did implement things`,
+	mixed: `chore: subject\nBREAKING CHANGE: implement, implementing, implements, implemented`
 };
 
 const parsed = {
@@ -15,7 +16,8 @@ const parsed = {
 	presentImperative: parse(messages.presentImperative),
 	presentParticiple: parse(messages.presentParticiple),
 	presentThirdPerson: parse(messages.presentImperative),
-	past: parse(messages.past)
+	past: parse(messages.past),
+	mixed: parse(messages.mixed)
 };
 
 test('with empty footer should succeed', t => {
@@ -24,13 +26,13 @@ test('with empty footer should succeed', t => {
 	t.is(actual, expected);
 });
 
-test.failing('with present footer should succeed for "always present-imperative"', t => {
+test('with present footer should succeed for "always present-imperative"', t => {
 	const [actual] = footerTense(parsed.presentImperative, 'always', ['present-imperative']);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('with present footer should fail for "never present-imperative"', t => {
+test('with present footer should fail for "never present-imperative"', t => {
 	const [actual] = footerTense(parsed.presentImperative, 'never', ['present-imperative']);
 	const expected = false;
 	t.is(actual, expected);
@@ -48,26 +50,65 @@ test('with present footer should fail for "never present-participle"', t => {
 	t.is(actual, expected);
 });
 
-test.failing('with present footer should succeed for "always present-third-person"', t => {
+test('with present footer should succeed for "always present-third-person"', t => {
 	const [actual] = footerTense(parsed.presentThirdPerson, 'always', ['present-third-person']);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('with present footer should fail for "never present-third-person"', t => {
+test('with present footer should fail for "never present-third-person"', t => {
 	const [actual] = footerTense(parsed.presentThirdPerson, 'never', ['present-third-person']);
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test.failing('with past footer should succedd for "always past-tense"', t => {
+test('with past footer should succedd for "always past-tense"', t => {
 	const [actual] = footerTense(parsed.past, 'always', ['past-tense']);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('with past footer should fail for "never past-tense"', t => {
+test('with past footer should fail for "never past-tense"', t => {
 	const [actual] = footerTense(parsed.past, 'never', ['past-tense']);
 	const expected = false;
 	t.is(actual, expected);
 });
+
+test('with mixed footer should fail for "always present-third-person"', t => {
+	const [actual] = footerTense(parsed.mixed, 'always', ['present-third-person']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with mixed footer should fail for "always present-imperative"', t => {
+	const [actual] = footerTense(parsed.mixed, 'always', ['present-imperative']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with present footer should fail for "always present-participle"', t => {
+	const [actual] = footerTense(parsed.mixed, 'always', ['present-participle']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with mixed footer should fail for "always past-tense"', t => {
+	const [actual] = footerTense(parsed.mixed, 'always', ['past-tense']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with mixed footer should succeed for "always present-third-person, present-imperative, present-participle, past-tense"', t => {
+	const [actual] = footerTense(parsed.mixed, 'always', ['present-third-person', 'present-imperative', 'present-participle', 'past-tense']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with mixed footer should succeed for "never allowed: present-third-person" and matching ignored: implements', t => {
+	const [actual] = footerTense(parsed.mixed, 'never', {
+		allowed: ['present-third-person'],
+		ignored: ['implements']
+	});
+	const expected = true;
+	t.is(actual, expected);
+});

From 010aabf612075de6e24033fdd2afeff0c6296e02 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 15:54:11 +0200
Subject: [PATCH 29/77] test: add header length tests

---
 source/rules/header-max-length.test.js | 30 ++++++++++++++++++++++++++
 source/rules/header-min-length.test.js | 30 ++++++++++++++++++++++++++
 2 files changed, 60 insertions(+)
 create mode 100644 source/rules/header-max-length.test.js
 create mode 100644 source/rules/header-min-length.test.js

diff --git a/source/rules/header-max-length.test.js b/source/rules/header-max-length.test.js
new file mode 100644
index 0000000000..1527a7b1d0
--- /dev/null
+++ b/source/rules/header-max-length.test.js
@@ -0,0 +1,30 @@
+import test from 'ava';
+import parse from '../library/parse';
+import headerMaxLength from './header-max-length';
+
+const short = 'chore: a';
+const long = 'chore: ab';
+
+const allowed = short.length;
+
+const messages = {
+	short,
+	long
+};
+
+const parsed = {
+	short: parse(messages.short),
+	long: parse(messages.long)
+};
+
+test('with short header should succeed', t => {
+	const [actual] = headerMaxLength(parsed.short, '', allowed);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with long header should fail', t => {
+	const [actual] = headerMaxLength(parsed.long, '', allowed);
+	const expected = false;
+	t.is(actual, expected);
+});
diff --git a/source/rules/header-min-length.test.js b/source/rules/header-min-length.test.js
new file mode 100644
index 0000000000..a6c6a56095
--- /dev/null
+++ b/source/rules/header-min-length.test.js
@@ -0,0 +1,30 @@
+import test from 'ava';
+import parse from '../library/parse';
+import headerMinLength from './header-min-length';
+
+const short = 'BREAKING CHANGE: a';
+const long = 'BREAKING CHANGE: ab';
+
+const needed = long.length;
+
+const messages = {
+	short,
+	long
+};
+
+const parsed = {
+	short: parse(messages.short),
+	long: parse(messages.long)
+};
+
+test('with short footer should fail', t => {
+	const [actual] = headerMinLength(parsed.short, '', needed);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with long footer should succeed', t => {
+	const [actual] = headerMinLength(parsed.long, '', needed);
+	const expected = true;
+	t.is(actual, expected);
+});

From 6ca5e80dddfa6f26cff86da18a21a57de03b8910 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 16:04:39 +0200
Subject: [PATCH 30/77] test: add case rule tests

---
 source/rules/scope-case.test.js   | 89 +++++++++++++++++++++++++++++++
 source/rules/subject-case.test.js | 89 +++++++++++++++++++++++++++++++
 source/rules/type-case.test.js    | 89 +++++++++++++++++++++++++++++++
 3 files changed, 267 insertions(+)
 create mode 100644 source/rules/scope-case.test.js
 create mode 100644 source/rules/subject-case.test.js
 create mode 100644 source/rules/type-case.test.js

diff --git a/source/rules/scope-case.test.js b/source/rules/scope-case.test.js
new file mode 100644
index 0000000000..46195baac3
--- /dev/null
+++ b/source/rules/scope-case.test.js
@@ -0,0 +1,89 @@
+import test from 'ava';
+import parse from '../library/parse';
+import scopeCase from './scope-case';
+
+const messages = {
+	empty: 'chore: subject',
+	lowercase: 'chore(scope): subject',
+	mixedcase: 'chore(sCoPe): subject',
+	uppercase: 'chore(SCOPE): subject'
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	lowercase: parse(messages.lowercase),
+	mixedcase: parse(messages.mixedcase),
+	uppercase: parse(messages.uppercase)
+};
+
+test.failing('with empty scope should succeed for "never lowercase"', t => {
+	const [actual] = scopeCase(parsed.empty, 'never', 'lowercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with empty scope should succeed for "always lowercase"', t => {
+	const [actual] = scopeCase(parsed.empty, 'always', 'lowercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with empty scope should succeed for "never uppercase"', t => {
+	const [actual] = scopeCase(parsed.empty, 'never', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with empty scope should succeed for "always uppercase"', t => {
+	const [actual] = scopeCase(parsed.empty, 'always', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with lowercase scope should fail for "never lowercase"', t => {
+	const [actual] = scopeCase(parsed.lowercase, 'never', 'lowercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with lowercase scope should succeed for "always lowercase"', t => {
+	const [actual] = scopeCase(parsed.lowercase, 'always', 'lowercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with mixedcase scope should succeed for "never lowercase"', t => {
+	const [actual] = scopeCase(parsed.mixedcase, 'never', 'lowercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with mixedcase scope should fail for "always lowercase"', t => {
+	const [actual] = scopeCase(parsed.mixedcase, 'always', 'lowercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with mixedcase scope should succeed for "never uppercase"', t => {
+	const [actual] = scopeCase(parsed.mixedcase, 'never', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with mixedcase scope should fail for "always uppercase"', t => {
+	const [actual] = scopeCase(parsed.mixedcase, 'always', 'uppercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with uppercase scope should fail for "never uppercase"', t => {
+	const [actual] = scopeCase(parsed.uppercase, 'never', 'uppercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with lowercase scope should succeed for "always uppercase"', t => {
+	const [actual] = scopeCase(parsed.uppercase, 'always', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});
diff --git a/source/rules/subject-case.test.js b/source/rules/subject-case.test.js
new file mode 100644
index 0000000000..cad8444c19
--- /dev/null
+++ b/source/rules/subject-case.test.js
@@ -0,0 +1,89 @@
+import test from 'ava';
+import parse from '../library/parse';
+import subjectCase from './subject-case';
+
+const messages = {
+	empty: 'chore:\n',
+	lowercase: 'chore: subject',
+	mixedcase: 'chore: sUbJeCt',
+	uppercase: 'chore: SUBJECT'
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	lowercase: parse(messages.lowercase),
+	mixedcase: parse(messages.mixedcase),
+	uppercase: parse(messages.uppercase)
+};
+
+test.failing('with empty subject should succeed for "never lowercase"', t => {
+	const [actual] = subjectCase(parsed.empty, 'never', 'lowercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with empty subject should succeed for "always lowercase"', t => {
+	const [actual] = subjectCase(parsed.empty, 'always', 'lowercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with empty subject should succeed for "never uppercase"', t => {
+	const [actual] = subjectCase(parsed.empty, 'never', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with empty subject should succeed for "always uppercase"', t => {
+	const [actual] = subjectCase(parsed.empty, 'always', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with lowercase subject should fail for "never lowercase"', t => {
+	const [actual] = subjectCase(parsed.lowercase, 'never', 'lowercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with lowercase subject should succeed for "always lowercase"', t => {
+	const [actual] = subjectCase(parsed.lowercase, 'always', 'lowercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with mixedcase subject should succeed for "never lowercase"', t => {
+	const [actual] = subjectCase(parsed.mixedcase, 'never', 'lowercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with mixedcase subject should fail for "always lowercase"', t => {
+	const [actual] = subjectCase(parsed.mixedcase, 'always', 'lowercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with mixedcase subject should succeed for "never uppercase"', t => {
+	const [actual] = subjectCase(parsed.mixedcase, 'never', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with mixedcase subject should fail for "always uppercase"', t => {
+	const [actual] = subjectCase(parsed.mixedcase, 'always', 'uppercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with uppercase subject should fail for "never uppercase"', t => {
+	const [actual] = subjectCase(parsed.uppercase, 'never', 'uppercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with lowercase subject should succeed for "always uppercase"', t => {
+	const [actual] = subjectCase(parsed.uppercase, 'always', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});
diff --git a/source/rules/type-case.test.js b/source/rules/type-case.test.js
new file mode 100644
index 0000000000..c029f4202f
--- /dev/null
+++ b/source/rules/type-case.test.js
@@ -0,0 +1,89 @@
+import test from 'ava';
+import parse from '../library/parse';
+import typeCase from './type-case';
+
+const messages = {
+	empty: '(scope): subject',
+	lowercase: 'type: subject',
+	mixedcase: 'tYpE: subject',
+	uppercase: 'TYPE: subject'
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	lowercase: parse(messages.lowercase),
+	mixedcase: parse(messages.mixedcase),
+	uppercase: parse(messages.uppercase)
+};
+
+test.failing('with empty type should succeed for "never lowercase"', t => {
+	const [actual] = typeCase(parsed.empty, 'never', 'lowercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with empty type should succeed for "always lowercase"', t => {
+	const [actual] = typeCase(parsed.empty, 'always', 'lowercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with empty type should succeed for "never uppercase"', t => {
+	const [actual] = typeCase(parsed.empty, 'never', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with empty type should succeed for "always uppercase"', t => {
+	const [actual] = typeCase(parsed.empty, 'always', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with lowercase type should fail for "never lowercase"', t => {
+	const [actual] = typeCase(parsed.lowercase, 'never', 'lowercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with lowercase type should succeed for "always lowercase"', t => {
+	const [actual] = typeCase(parsed.lowercase, 'always', 'lowercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with mixedcase type should succeed for "never lowercase"', t => {
+	const [actual] = typeCase(parsed.mixedcase, 'never', 'lowercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with mixedcase type should fail for "always lowercase"', t => {
+	const [actual] = typeCase(parsed.mixedcase, 'always', 'lowercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with mixedcase type should succeed for "never uppercase"', t => {
+	const [actual] = typeCase(parsed.mixedcase, 'never', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with mixedcase type should fail for "always uppercase"', t => {
+	const [actual] = typeCase(parsed.mixedcase, 'always', 'uppercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with uppercase type should fail for "never uppercase"', t => {
+	const [actual] = typeCase(parsed.uppercase, 'never', 'uppercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with lowercase type should succeed for "always uppercase"', t => {
+	const [actual] = typeCase(parsed.uppercase, 'always', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});

From bb3fe0d001e999f4d4b5a926ad026b45a266ff37 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 16:05:19 +0200
Subject: [PATCH 31/77] fix: handle empty scope

---
 source/rules/scope-case.js      | 7 +++++++
 source/rules/scope-case.test.js | 4 ++--
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/source/rules/scope-case.js b/source/rules/scope-case.js
index 2bb179261c..eb522ecff9 100644
--- a/source/rules/scope-case.js
+++ b/source/rules/scope-case.js
@@ -1,7 +1,14 @@
 import ensureCase from '../library/ensure-case';
 
 export default (parsed, when, value) => {
+	const {scope} = parsed;
+
+	if (!scope) {
+		return [true];
+	}
+
 	const negated = when === 'never';
+
 	const result = ensureCase(parsed.scope, value);
 	return [
 		negated ? !result : result,
diff --git a/source/rules/scope-case.test.js b/source/rules/scope-case.test.js
index 46195baac3..3f643a7833 100644
--- a/source/rules/scope-case.test.js
+++ b/source/rules/scope-case.test.js
@@ -16,7 +16,7 @@ const parsed = {
 	uppercase: parse(messages.uppercase)
 };
 
-test.failing('with empty scope should succeed for "never lowercase"', t => {
+test('with empty scope should succeed for "never lowercase"', t => {
 	const [actual] = scopeCase(parsed.empty, 'never', 'lowercase');
 	const expected = true;
 	t.is(actual, expected);
@@ -34,7 +34,7 @@ test('with empty scope should succeed for "never uppercase"', t => {
 	t.is(actual, expected);
 });
 
-test.failing('with empty scope should succeed for "always uppercase"', t => {
+test('with empty scope should succeed for "always uppercase"', t => {
 	const [actual] = scopeCase(parsed.empty, 'always', 'uppercase');
 	const expected = true;
 	t.is(actual, expected);

From 0871f45476c8b64be221d1b04a30bd3873c4e6cc Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 16:08:01 +0200
Subject: [PATCH 32/77] fix: handle empty subject

---
 source/rules/subject-case.js      | 11 +++++++++--
 source/rules/subject-case.test.js |  4 ++--
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/source/rules/subject-case.js b/source/rules/subject-case.js
index a400e251f2..ad6d4aaa55 100644
--- a/source/rules/subject-case.js
+++ b/source/rules/subject-case.js
@@ -1,12 +1,19 @@
 import ensureCase from '../library/ensure-case';
 
 export default (parsed, when, value) => {
+	const {subject} = parsed;
+
+	if (!subject) {
+		return [true];
+	}
+
 	const negated = when === 'never';
-	const result = ensureCase(parsed.subject, value);
+
+	const result = ensureCase(subject, value);
 	return [
 		negated ? !result : result,
 		[
-			`message must`,
+			`subject must`,
 			negated ? `not` : null,
 			`be ${value}`
 		]
diff --git a/source/rules/subject-case.test.js b/source/rules/subject-case.test.js
index cad8444c19..20da9dbe49 100644
--- a/source/rules/subject-case.test.js
+++ b/source/rules/subject-case.test.js
@@ -16,7 +16,7 @@ const parsed = {
 	uppercase: parse(messages.uppercase)
 };
 
-test.failing('with empty subject should succeed for "never lowercase"', t => {
+test('with empty subject should succeed for "never lowercase"', t => {
 	const [actual] = subjectCase(parsed.empty, 'never', 'lowercase');
 	const expected = true;
 	t.is(actual, expected);
@@ -34,7 +34,7 @@ test('with empty subject should succeed for "never uppercase"', t => {
 	t.is(actual, expected);
 });
 
-test.failing('with empty subject should succeed for "always uppercase"', t => {
+test('with empty subject should succeed for "always uppercase"', t => {
 	const [actual] = subjectCase(parsed.empty, 'always', 'uppercase');
 	const expected = true;
 	t.is(actual, expected);

From 6ef3dc79c691b637d65dd4f3ea350e7f7ff152f3 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 16:08:14 +0200
Subject: [PATCH 33/77] style: harmonize case rules

---
 source/rules/body-case.js  | 2 +-
 source/rules/scope-case.js | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/rules/body-case.js b/source/rules/body-case.js
index b782030234..23f33cbe5c 100644
--- a/source/rules/body-case.js
+++ b/source/rules/body-case.js
@@ -9,7 +9,7 @@ export default (parsed, when, value) => {
 
 	const negated = when === 'never';
 
-	const result = ensureCase(parsed.body, value);
+	const result = ensureCase(body, value);
 	return [
 		negated ? !result : result,
 		[
diff --git a/source/rules/scope-case.js b/source/rules/scope-case.js
index eb522ecff9..ecc61bd064 100644
--- a/source/rules/scope-case.js
+++ b/source/rules/scope-case.js
@@ -9,7 +9,7 @@ export default (parsed, when, value) => {
 
 	const negated = when === 'never';
 
-	const result = ensureCase(parsed.scope, value);
+	const result = ensureCase(scope, value);
 	return [
 		negated ? !result : result,
 		[

From 98e53f34330834dcebcb696c40edd120e7ccc2cc Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 16:10:26 +0200
Subject: [PATCH 34/77] fix: handle empty type

---
 source/rules/type-case.js      | 11 +++++++++--
 source/rules/type-case.test.js |  4 ++--
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/source/rules/type-case.js b/source/rules/type-case.js
index 506de75919..fe088bc7a0 100644
--- a/source/rules/type-case.js
+++ b/source/rules/type-case.js
@@ -1,12 +1,19 @@
 import ensureCase from '../library/ensure-case';
 
 export default (parsed, when, value) => {
+	const {type} = parsed;
+
+	if (!type) {
+		return [true];
+	}
+
 	const negated = when === 'never';
-	const result = ensureCase(parsed.type, value);
+
+	const result = ensureCase(type, value);
 	return [
 		negated ? !result : result,
 		[
-			`type must`,
+			`subject must`,
 			negated ? `not` : null,
 			`be ${value}`
 		]
diff --git a/source/rules/type-case.test.js b/source/rules/type-case.test.js
index c029f4202f..673c31525b 100644
--- a/source/rules/type-case.test.js
+++ b/source/rules/type-case.test.js
@@ -16,7 +16,7 @@ const parsed = {
 	uppercase: parse(messages.uppercase)
 };
 
-test.failing('with empty type should succeed for "never lowercase"', t => {
+test('with empty type should succeed for "never lowercase"', t => {
 	const [actual] = typeCase(parsed.empty, 'never', 'lowercase');
 	const expected = true;
 	t.is(actual, expected);
@@ -34,7 +34,7 @@ test('with empty type should succeed for "never uppercase"', t => {
 	t.is(actual, expected);
 });
 
-test.failing('with empty type should succeed for "always uppercase"', t => {
+test('with empty type should succeed for "always uppercase"', t => {
 	const [actual] = typeCase(parsed.empty, 'always', 'uppercase');
 	const expected = true;
 	t.is(actual, expected);

From b46c4811934eb62abba04ac874529c0b701ac662 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 16:23:58 +0200
Subject: [PATCH 35/77] test: harmonize length tests

---
 source/rules/body-max-length.test.js   | 12 ++++++------
 source/rules/body-min-length.test.js   |  6 +++---
 source/rules/footer-max-length.test.js |  9 ++++-----
 source/rules/footer-min-length.test.js |  9 ++++-----
 source/rules/header-max-length.test.js |  4 ++--
 source/rules/header-min-length.test.js |  4 ++--
 6 files changed, 21 insertions(+), 23 deletions(-)

diff --git a/source/rules/body-max-length.test.js b/source/rules/body-max-length.test.js
index f6ef9ef386..eae5b49b98 100644
--- a/source/rules/body-max-length.test.js
+++ b/source/rules/body-max-length.test.js
@@ -8,30 +8,30 @@ const long = 'ab';
 const allowed = short.length;
 
 const messages = {
-	simple: 'chore: subject',
+	empty: 'chore: subject',
 	short: `chore: subject\n${short}`,
 	long: `chore: subject\n${long}`
 };
 
 const parsed = {
-	simple: parse(messages.simple),
+	empty: parse(messages.empty),
 	short: parse(messages.short),
 	long: parse(messages.long)
 };
 
-test('with simple message should succeed', t => {
-	const [actual] = bodyMaxLength(parsed.simple, '', allowed);
+test('with empty should succeed', t => {
+	const [actual] = bodyMaxLength(parsed.empty, '', allowed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with short body should succeed', t => {
+test('with short should succeed', t => {
 	const [actual] = bodyMaxLength(parsed.short, '', allowed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with long body should fail', t => {
+test('with long should fail', t => {
 	const [actual] = bodyMaxLength(parsed.long, '', allowed);
 	const expected = false;
 	t.is(actual, expected);
diff --git a/source/rules/body-min-length.test.js b/source/rules/body-min-length.test.js
index c39c973ca1..04fbc76958 100644
--- a/source/rules/body-min-length.test.js
+++ b/source/rules/body-min-length.test.js
@@ -19,19 +19,19 @@ const parsed = {
 	long: parse(messages.long)
 };
 
-test('with simple message should succeed', t => {
+test('with simple should succeed', t => {
 	const [actual] = bodyMinLength(parsed.simple, '', needed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with short body should fail', t => {
+test('with short should fail', t => {
 	const [actual] = bodyMinLength(parsed.short, '', needed);
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('with long body should succeed', t => {
+test('with long should succeed', t => {
 	const [actual] = bodyMinLength(parsed.long, '', needed);
 	const expected = true;
 	t.is(actual, expected);
diff --git a/source/rules/footer-max-length.test.js b/source/rules/footer-max-length.test.js
index 239bcdcc65..f1ef2ce639 100644
--- a/source/rules/footer-max-length.test.js
+++ b/source/rules/footer-max-length.test.js
@@ -21,27 +21,26 @@ const parsed = {
 	long: parse(messages.long)
 };
 
-test('with simple message should succeed', t => {
+test('with simple should succeed', t => {
 	const [actual] = footerMaxLength(parsed.simple, '', allowed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with empty footer should succeed', t => {
+test('with empty should succeed', t => {
 	const [actual] = footerMaxLength(parsed.empty, '', allowed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with short footer should succeed', t => {
+test('with short should succeed', t => {
 	const [actual] = footerMaxLength(parsed.short, '', allowed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with long footer should fail', t => {
+test('with long should fail', t => {
 	const [actual] = footerMaxLength(parsed.long, '', allowed);
 	const expected = false;
 	t.is(actual, expected);
 });
-
diff --git a/source/rules/footer-min-length.test.js b/source/rules/footer-min-length.test.js
index a0e80fd347..4a07e47c82 100644
--- a/source/rules/footer-min-length.test.js
+++ b/source/rules/footer-min-length.test.js
@@ -21,27 +21,26 @@ const parsed = {
 	long: parse(messages.long)
 };
 
-test('with simple message should succeed', t => {
+test('with simple should succeed', t => {
 	const [actual] = footerMinLength(parsed.simple, '', needed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with empty footer should succeed', t => {
+test('with empty should succeed', t => {
 	const [actual] = footerMinLength(parsed.empty, '', needed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with short footer should fail', t => {
+test('with short should fail', t => {
 	const [actual] = footerMinLength(parsed.short, '', needed);
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('with long footer should succeed', t => {
+test('with long should succeed', t => {
 	const [actual] = footerMinLength(parsed.long, '', needed);
 	const expected = true;
 	t.is(actual, expected);
 });
-
diff --git a/source/rules/header-max-length.test.js b/source/rules/header-max-length.test.js
index 1527a7b1d0..c29fe2ce48 100644
--- a/source/rules/header-max-length.test.js
+++ b/source/rules/header-max-length.test.js
@@ -17,13 +17,13 @@ const parsed = {
 	long: parse(messages.long)
 };
 
-test('with short header should succeed', t => {
+test('with short should succeed', t => {
 	const [actual] = headerMaxLength(parsed.short, '', allowed);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test('with long header should fail', t => {
+test('with long should fail', t => {
 	const [actual] = headerMaxLength(parsed.long, '', allowed);
 	const expected = false;
 	t.is(actual, expected);
diff --git a/source/rules/header-min-length.test.js b/source/rules/header-min-length.test.js
index a6c6a56095..c4ce9b88d8 100644
--- a/source/rules/header-min-length.test.js
+++ b/source/rules/header-min-length.test.js
@@ -17,13 +17,13 @@ const parsed = {
 	long: parse(messages.long)
 };
 
-test('with short footer should fail', t => {
+test('with short should fail', t => {
 	const [actual] = headerMinLength(parsed.short, '', needed);
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test('with long footer should succeed', t => {
+test('with long should succeed', t => {
 	const [actual] = headerMinLength(parsed.long, '', needed);
 	const expected = true;
 	t.is(actual, expected);

From 0cd5f50e992b1a213341e2c1df51dca3042c6d23 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 16:39:15 +0200
Subject: [PATCH 36/77] test: add length tests

---
 source/rules/body-max-length.test.js    | 10 +++----
 source/rules/body-min-length.test.js    | 10 +++----
 source/rules/footer-max-length.test.js  | 12 ++++----
 source/rules/footer-min-length.test.js  | 12 ++++----
 source/rules/header-max-length.test.js  |  8 +++---
 source/rules/header-min-length.test.js  |  8 +++---
 source/rules/scope-max-length.test.js   | 38 +++++++++++++++++++++++++
 source/rules/scope-min-length.test.js   | 32 +++++++++++++++++++++
 source/rules/subject-max-length.test.js | 38 +++++++++++++++++++++++++
 source/rules/subject-min-length.test.js | 32 +++++++++++++++++++++
 source/rules/type-max-length.test.js    | 38 +++++++++++++++++++++++++
 source/rules/type-min-length.test.js    | 32 +++++++++++++++++++++
 12 files changed, 240 insertions(+), 30 deletions(-)
 create mode 100644 source/rules/scope-max-length.test.js
 create mode 100644 source/rules/scope-min-length.test.js
 create mode 100644 source/rules/subject-max-length.test.js
 create mode 100644 source/rules/subject-min-length.test.js
 create mode 100644 source/rules/type-max-length.test.js
 create mode 100644 source/rules/type-min-length.test.js

diff --git a/source/rules/body-max-length.test.js b/source/rules/body-max-length.test.js
index eae5b49b98..1d5f319356 100644
--- a/source/rules/body-max-length.test.js
+++ b/source/rules/body-max-length.test.js
@@ -1,11 +1,11 @@
 import test from 'ava';
 import parse from '../library/parse';
-import bodyMaxLength from './body-max-length';
+import check from './body-max-length';
 
 const short = 'a';
 const long = 'ab';
 
-const allowed = short.length;
+const value = short.length;
 
 const messages = {
 	empty: 'chore: subject',
@@ -20,19 +20,19 @@ const parsed = {
 };
 
 test('with empty should succeed', t => {
-	const [actual] = bodyMaxLength(parsed.empty, '', allowed);
+	const [actual] = check(parsed.empty, '', value);
 	const expected = true;
 	t.is(actual, expected);
 });
 
 test('with short should succeed', t => {
-	const [actual] = bodyMaxLength(parsed.short, '', allowed);
+	const [actual] = check(parsed.short, '', value);
 	const expected = true;
 	t.is(actual, expected);
 });
 
 test('with long should fail', t => {
-	const [actual] = bodyMaxLength(parsed.long, '', allowed);
+	const [actual] = check(parsed.long, '', value);
 	const expected = false;
 	t.is(actual, expected);
 });
diff --git a/source/rules/body-min-length.test.js b/source/rules/body-min-length.test.js
index 04fbc76958..63cc7a7b90 100644
--- a/source/rules/body-min-length.test.js
+++ b/source/rules/body-min-length.test.js
@@ -1,11 +1,11 @@
 import test from 'ava';
 import parse from '../library/parse';
-import bodyMinLength from './body-min-length';
+import check from './body-min-length';
 
 const short = 'a';
 const long = 'ab';
 
-const needed = long.length;
+const value = long.length;
 
 const messages = {
 	simple: 'chore: subject',
@@ -20,19 +20,19 @@ const parsed = {
 };
 
 test('with simple should succeed', t => {
-	const [actual] = bodyMinLength(parsed.simple, '', needed);
+	const [actual] = check(parsed.simple, '', value);
 	const expected = true;
 	t.is(actual, expected);
 });
 
 test('with short should fail', t => {
-	const [actual] = bodyMinLength(parsed.short, '', needed);
+	const [actual] = check(parsed.short, '', value);
 	const expected = false;
 	t.is(actual, expected);
 });
 
 test('with long should succeed', t => {
-	const [actual] = bodyMinLength(parsed.long, '', needed);
+	const [actual] = check(parsed.long, '', value);
 	const expected = true;
 	t.is(actual, expected);
 });
diff --git a/source/rules/footer-max-length.test.js b/source/rules/footer-max-length.test.js
index f1ef2ce639..13af836f40 100644
--- a/source/rules/footer-max-length.test.js
+++ b/source/rules/footer-max-length.test.js
@@ -1,11 +1,11 @@
 import test from 'ava';
 import parse from '../library/parse';
-import footerMaxLength from './footer-max-length';
+import check from './footer-max-length';
 
 const short = 'BREAKING CHANGE: a';
 const long = 'BREAKING CHANGE: ab';
 
-const allowed = short.length;
+const value = short.length;
 
 const messages = {
 	simple: 'chore: subject',
@@ -22,25 +22,25 @@ const parsed = {
 };
 
 test('with simple should succeed', t => {
-	const [actual] = footerMaxLength(parsed.simple, '', allowed);
+	const [actual] = check(parsed.simple, '', value);
 	const expected = true;
 	t.is(actual, expected);
 });
 
 test('with empty should succeed', t => {
-	const [actual] = footerMaxLength(parsed.empty, '', allowed);
+	const [actual] = check(parsed.empty, '', value);
 	const expected = true;
 	t.is(actual, expected);
 });
 
 test('with short should succeed', t => {
-	const [actual] = footerMaxLength(parsed.short, '', allowed);
+	const [actual] = check(parsed.short, '', value);
 	const expected = true;
 	t.is(actual, expected);
 });
 
 test('with long should fail', t => {
-	const [actual] = footerMaxLength(parsed.long, '', allowed);
+	const [actual] = check(parsed.long, '', value);
 	const expected = false;
 	t.is(actual, expected);
 });
diff --git a/source/rules/footer-min-length.test.js b/source/rules/footer-min-length.test.js
index 4a07e47c82..5d20465f2c 100644
--- a/source/rules/footer-min-length.test.js
+++ b/source/rules/footer-min-length.test.js
@@ -1,11 +1,11 @@
 import test from 'ava';
 import parse from '../library/parse';
-import footerMinLength from './footer-min-length';
+import check from './footer-min-length';
 
 const short = 'BREAKING CHANGE: a';
 const long = 'BREAKING CHANGE: ab';
 
-const needed = long.length;
+const value = long.length;
 
 const messages = {
 	simple: 'chore: subject',
@@ -22,25 +22,25 @@ const parsed = {
 };
 
 test('with simple should succeed', t => {
-	const [actual] = footerMinLength(parsed.simple, '', needed);
+	const [actual] = check(parsed.simple, '', value);
 	const expected = true;
 	t.is(actual, expected);
 });
 
 test('with empty should succeed', t => {
-	const [actual] = footerMinLength(parsed.empty, '', needed);
+	const [actual] = check(parsed.empty, '', value);
 	const expected = true;
 	t.is(actual, expected);
 });
 
 test('with short should fail', t => {
-	const [actual] = footerMinLength(parsed.short, '', needed);
+	const [actual] = check(parsed.short, '', value);
 	const expected = false;
 	t.is(actual, expected);
 });
 
 test('with long should succeed', t => {
-	const [actual] = footerMinLength(parsed.long, '', needed);
+	const [actual] = check(parsed.long, '', value);
 	const expected = true;
 	t.is(actual, expected);
 });
diff --git a/source/rules/header-max-length.test.js b/source/rules/header-max-length.test.js
index c29fe2ce48..856d228290 100644
--- a/source/rules/header-max-length.test.js
+++ b/source/rules/header-max-length.test.js
@@ -1,11 +1,11 @@
 import test from 'ava';
 import parse from '../library/parse';
-import headerMaxLength from './header-max-length';
+import check from './header-max-length';
 
 const short = 'chore: a';
 const long = 'chore: ab';
 
-const allowed = short.length;
+const value = short.length;
 
 const messages = {
 	short,
@@ -18,13 +18,13 @@ const parsed = {
 };
 
 test('with short should succeed', t => {
-	const [actual] = headerMaxLength(parsed.short, '', allowed);
+	const [actual] = check(parsed.short, '', value);
 	const expected = true;
 	t.is(actual, expected);
 });
 
 test('with long should fail', t => {
-	const [actual] = headerMaxLength(parsed.long, '', allowed);
+	const [actual] = check(parsed.long, '', value);
 	const expected = false;
 	t.is(actual, expected);
 });
diff --git a/source/rules/header-min-length.test.js b/source/rules/header-min-length.test.js
index c4ce9b88d8..e63777991b 100644
--- a/source/rules/header-min-length.test.js
+++ b/source/rules/header-min-length.test.js
@@ -1,11 +1,11 @@
 import test from 'ava';
 import parse from '../library/parse';
-import headerMinLength from './header-min-length';
+import check from './header-min-length';
 
 const short = 'BREAKING CHANGE: a';
 const long = 'BREAKING CHANGE: ab';
 
-const needed = long.length;
+const value = long.length;
 
 const messages = {
 	short,
@@ -18,13 +18,13 @@ const parsed = {
 };
 
 test('with short should fail', t => {
-	const [actual] = headerMinLength(parsed.short, '', needed);
+	const [actual] = check(parsed.short, '', value);
 	const expected = false;
 	t.is(actual, expected);
 });
 
 test('with long should succeed', t => {
-	const [actual] = headerMinLength(parsed.long, '', needed);
+	const [actual] = check(parsed.long, '', value);
 	const expected = true;
 	t.is(actual, expected);
 });
diff --git a/source/rules/scope-max-length.test.js b/source/rules/scope-max-length.test.js
new file mode 100644
index 0000000000..d529602848
--- /dev/null
+++ b/source/rules/scope-max-length.test.js
@@ -0,0 +1,38 @@
+import test from 'ava';
+import parse from '../library/parse';
+import check from './scope-max-length';
+
+const short = 'a';
+const long = 'ab';
+
+const value = short.length;
+
+const messages = {
+	empty: 'chore:\n',
+	short: `chore(${short}):\n`,
+	long: `chore(${long}):\n`
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	short: parse(messages.short),
+	long: parse(messages.long)
+};
+
+test.failing('with empty should succeed', t => {
+	const [actual] = check(parsed.empty, '', value);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with short should succeed', t => {
+	const [actual] = check(parsed.short, '', value);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with long should fail', t => {
+	const [actual] = check(parsed.long, '', value);
+	const expected = false;
+	t.is(actual, expected);
+});
diff --git a/source/rules/scope-min-length.test.js b/source/rules/scope-min-length.test.js
new file mode 100644
index 0000000000..1ea74b11de
--- /dev/null
+++ b/source/rules/scope-min-length.test.js
@@ -0,0 +1,32 @@
+import test from 'ava';
+import parse from '../library/parse';
+import check from './scope-min-length';
+
+const short = 'a';
+const long = 'ab';
+
+const value = short.length;
+
+const messages = {
+	empty: 'chore:\n',
+	short: `chore(${short}):\n`,
+	long: `chore(${long}):\n`
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	short: parse(messages.short),
+	long: parse(messages.long)
+};
+
+test('with short should fail', t => {
+	const [actual] = check(parsed.short, '', value);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('with long should succeed', t => {
+	const [actual] = check(parsed.long, '', value);
+	const expected = true;
+	t.is(actual, expected);
+});
diff --git a/source/rules/subject-max-length.test.js b/source/rules/subject-max-length.test.js
new file mode 100644
index 0000000000..fecbaf6794
--- /dev/null
+++ b/source/rules/subject-max-length.test.js
@@ -0,0 +1,38 @@
+import test from 'ava';
+import parse from '../library/parse';
+import check from './scope-max-length';
+
+const short = 'a';
+const long = 'ab';
+
+const value = short.length;
+
+const messages = {
+	empty: 'chore:\n',
+	short: `chore: ${short}\n`,
+	long: `chore: ${long}\n`
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	short: parse(messages.short),
+	long: parse(messages.long)
+};
+
+test.failing('with empty should succeed', t => {
+	const [actual] = check(parsed.empty, '', value);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with short should succeed', t => {
+	const [actual] = check(parsed.short, '', value);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with long should fail', t => {
+	const [actual] = check(parsed.long, '', value);
+	const expected = false;
+	t.is(actual, expected);
+});
diff --git a/source/rules/subject-min-length.test.js b/source/rules/subject-min-length.test.js
new file mode 100644
index 0000000000..a04a7272a6
--- /dev/null
+++ b/source/rules/subject-min-length.test.js
@@ -0,0 +1,32 @@
+import test from 'ava';
+import parse from '../library/parse';
+import check from './subject-min-length';
+
+const short = 'a';
+const long = 'ab';
+
+const value = short.length;
+
+const messages = {
+	empty: 'chore:\n',
+	short: `chore: ${short}\n`,
+	long: `chore: ${long}\n`
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	short: parse(messages.short),
+	long: parse(messages.long)
+};
+
+test.failing('with short should fail', t => {
+	const [actual] = check(parsed.short, '', value);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with long should succeed', t => {
+	const [actual] = check(parsed.long, '', value);
+	const expected = true;
+	t.is(actual, expected);
+});
diff --git a/source/rules/type-max-length.test.js b/source/rules/type-max-length.test.js
new file mode 100644
index 0000000000..42331473fd
--- /dev/null
+++ b/source/rules/type-max-length.test.js
@@ -0,0 +1,38 @@
+import test from 'ava';
+import parse from '../library/parse';
+import check from './type-max-length';
+
+const short = 'a';
+const long = 'ab';
+
+const value = short.length;
+
+const messages = {
+	empty: '():\n',
+	short: `${short}:\n`,
+	long: `${long}:\n`
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	short: parse(messages.short),
+	long: parse(messages.long)
+};
+
+test.failing('with empty should succeed', t => {
+	const [actual] = check(parsed.empty, '', value);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with short should succeed', t => {
+	const [actual] = check(parsed.short, '', value);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with long should fail', t => {
+	const [actual] = check(parsed.long, '', value);
+	const expected = false;
+	t.is(actual, expected);
+});
diff --git a/source/rules/type-min-length.test.js b/source/rules/type-min-length.test.js
new file mode 100644
index 0000000000..5de5a00c4d
--- /dev/null
+++ b/source/rules/type-min-length.test.js
@@ -0,0 +1,32 @@
+import test from 'ava';
+import parse from '../library/parse';
+import check from './type-min-length';
+
+const short = 'a';
+const long = 'ab';
+
+const value = short.length;
+
+const messages = {
+	empty: '():\n',
+	short: `${short}:\n`,
+	long: `${long}:\n`
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	short: parse(messages.short),
+	long: parse(messages.long)
+};
+
+test.failing('with short should fail', t => {
+	const [actual] = check(parsed.short, '', value);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with long should succeed', t => {
+	const [actual] = check(parsed.long, '', value);
+	const expected = true;
+	t.is(actual, expected);
+});

From 47dc14e1243f3630d3dfaddf6f4563aa2706fe9b Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 16:39:28 +0200
Subject: [PATCH 37/77] chore: be specific about ava test files

---
 package.json | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/package.json b/package.json
index 7101c5e896..5819b83d60 100644
--- a/package.json
+++ b/package.json
@@ -30,6 +30,14 @@
     "travis:lint:commits": "./scripts/lint:commits.sh"
   },
   "ava": {
+    "files": [
+      "source/**/*.test.js",
+      "!distribution/**/*"
+    ],
+    "source": [
+      "source/**/*.js",
+      "!distribution/**/*"
+    ],
     "babel": "inherit",
     "require": [
       "babel-register",

From 42a55450698ddd8ba61f667b849344be613ad975 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Thu, 4 May 2017 18:52:17 +0200
Subject: [PATCH 38/77] fix: implement length checks correctly

---
 source/rules/body-max-length.js         |  6 ++++--
 source/rules/footer-max-length.js       |  6 ++++--
 source/rules/scope-max-length.js        |  8 +++++++-
 source/rules/scope-max-length.test.js   | 10 +++++-----
 source/rules/scope-min-length.js        |  6 +++++-
 source/rules/scope-min-length.test.js   | 14 ++++++++++----
 source/rules/subject-max-length.js      | 10 ++++++++--
 source/rules/subject-max-length.test.js |  4 ++--
 source/rules/subject-min-length.js      |  8 ++++++--
 source/rules/subject-min-length.test.js | 10 ++++++++--
 source/rules/type-max-length.js         |  8 +++++++-
 source/rules/type-max-length.test.js    |  8 ++++----
 source/rules/type-min-length.js         |  8 ++++++--
 source/rules/type-min-length.test.js    | 14 ++++++++++----
 14 files changed, 86 insertions(+), 34 deletions(-)

diff --git a/source/rules/body-max-length.js b/source/rules/body-max-length.js
index e7cfa3f3bd..1ecb06e3e2 100644
--- a/source/rules/body-max-length.js
+++ b/source/rules/body-max-length.js
@@ -1,12 +1,14 @@
 import ensureMaxLength from '../library/ensure-max-length';
 
 export default (parsed, when, value) => {
-	if (!parsed.body) {
+	const input = parsed.body;
+
+	if (!input) {
 		return [true];
 	}
 
 	return [
-		ensureMaxLength(parsed.body, value),
+		ensureMaxLength(input, value),
 		`body must not be longer than ${value} characters`
 	];
 };
diff --git a/source/rules/footer-max-length.js b/source/rules/footer-max-length.js
index 7da98617af..c3144041ca 100644
--- a/source/rules/footer-max-length.js
+++ b/source/rules/footer-max-length.js
@@ -1,12 +1,14 @@
 import ensureMaxLength from '../library/ensure-max-length';
 
 export default (parsed, when, value) => {
-	if (!parsed.footer) {
+	const input = parsed.footer;
+
+	if (!input) {
 		return [true];
 	}
 
 	return [
-		ensureMaxLength(parsed.footer, value),
+		ensureMaxLength(input, value),
 		`footer must not be longer than ${value} characters`
 	];
 };
diff --git a/source/rules/scope-max-length.js b/source/rules/scope-max-length.js
index 6a297d794d..5161944abe 100644
--- a/source/rules/scope-max-length.js
+++ b/source/rules/scope-max-length.js
@@ -1,8 +1,14 @@
 import ensureMaxLength from '../library/ensure-max-length';
 
 export default (parsed, when, value) => {
+	const input = parsed.scope;
+
+	if (!input) {
+		return [true];
+	}
+
 	return [
-		ensureMaxLength(parsed.subject, value),
+		ensureMaxLength(input, value),
 		`scope must not be longer than ${value} characters`
 	];
 };
diff --git a/source/rules/scope-max-length.test.js b/source/rules/scope-max-length.test.js
index d529602848..95222957a0 100644
--- a/source/rules/scope-max-length.test.js
+++ b/source/rules/scope-max-length.test.js
@@ -8,9 +8,9 @@ const long = 'ab';
 const value = short.length;
 
 const messages = {
-	empty: 'chore:\n',
-	short: `chore(${short}):\n`,
-	long: `chore(${long}):\n`
+	empty: 'chore: \n',
+	short: `chore(${short}): \n`,
+	long: `chore(${long}): \n`
 };
 
 const parsed = {
@@ -19,13 +19,13 @@ const parsed = {
 	long: parse(messages.long)
 };
 
-test.failing('with empty should succeed', t => {
+test('with empty should succeed', t => {
 	const [actual] = check(parsed.empty, '', value);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('with short should succeed', t => {
+test('with short should succeed', t => {
 	const [actual] = check(parsed.short, '', value);
 	const expected = true;
 	t.is(actual, expected);
diff --git a/source/rules/scope-min-length.js b/source/rules/scope-min-length.js
index 6affe5be80..583a8028dd 100644
--- a/source/rules/scope-min-length.js
+++ b/source/rules/scope-min-length.js
@@ -1,8 +1,12 @@
 import ensureMinLength from '../library/ensure-min-length';
 
 export default (parsed, when, value) => {
+	const input = parsed.scope;
+	if (!input) {
+		return [true];
+	}
 	return [
-		ensureMinLength(parsed.scope, value),
+		ensureMinLength(input, value),
 		`scope must not be shorter than ${value} characters`
 	];
 };
diff --git a/source/rules/scope-min-length.test.js b/source/rules/scope-min-length.test.js
index 1ea74b11de..c30c9d0399 100644
--- a/source/rules/scope-min-length.test.js
+++ b/source/rules/scope-min-length.test.js
@@ -5,12 +5,12 @@ import check from './scope-min-length';
 const short = 'a';
 const long = 'ab';
 
-const value = short.length;
+const value = long.length;
 
 const messages = {
 	empty: 'chore:\n',
-	short: `chore(${short}):\n`,
-	long: `chore(${long}):\n`
+	short: `chore(${short}): \n`,
+	long: `chore(${long}): \n`
 };
 
 const parsed = {
@@ -19,13 +19,19 @@ const parsed = {
 	long: parse(messages.long)
 };
 
+test('with empty should succeed', t => {
+	const [actual] = check(parsed.empty, '', value);
+	const expected = true;
+	t.is(actual, expected);
+});
+
 test('with short should fail', t => {
 	const [actual] = check(parsed.short, '', value);
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test.failing('with long should succeed', t => {
+test('with long should succeed', t => {
 	const [actual] = check(parsed.long, '', value);
 	const expected = true;
 	t.is(actual, expected);
diff --git a/source/rules/subject-max-length.js b/source/rules/subject-max-length.js
index f7f7b9a018..81b582ae0e 100644
--- a/source/rules/subject-max-length.js
+++ b/source/rules/subject-max-length.js
@@ -1,8 +1,14 @@
 import ensureMaxLength from '../library/ensure-max-length';
 
 export default (parsed, when, value) => {
+	const input = parsed.subject;
+
+	if (!input) {
+		return [true];
+	}
+
 	return [
-		ensureMaxLength(parsed.subject, value),
-		`message must not be longer than ${value} characters`
+		ensureMaxLength(input, value),
+		`footer must not be longer than ${value} characters`
 	];
 };
diff --git a/source/rules/subject-max-length.test.js b/source/rules/subject-max-length.test.js
index fecbaf6794..7a50873d70 100644
--- a/source/rules/subject-max-length.test.js
+++ b/source/rules/subject-max-length.test.js
@@ -1,6 +1,6 @@
 import test from 'ava';
 import parse from '../library/parse';
-import check from './scope-max-length';
+import check from './subject-max-length';
 
 const short = 'a';
 const long = 'ab';
@@ -19,7 +19,7 @@ const parsed = {
 	long: parse(messages.long)
 };
 
-test.failing('with empty should succeed', t => {
+test('with empty should succeed', t => {
 	const [actual] = check(parsed.empty, '', value);
 	const expected = true;
 	t.is(actual, expected);
diff --git a/source/rules/subject-min-length.js b/source/rules/subject-min-length.js
index b76a117f1d..054b4eda12 100644
--- a/source/rules/subject-min-length.js
+++ b/source/rules/subject-min-length.js
@@ -1,8 +1,12 @@
 import ensureMinLength from '../library/ensure-min-length';
 
 export default (parsed, when, value) => {
+	const input = parsed.subject;
+	if (!input) {
+		return [true];
+	}
 	return [
-		ensureMinLength(parsed.subject, value),
-		`message must not be shorter than ${value} characters`
+		ensureMinLength(input, value),
+		`subject must not be shorter than ${value} characters`
 	];
 };
diff --git a/source/rules/subject-min-length.test.js b/source/rules/subject-min-length.test.js
index a04a7272a6..b77ea43a24 100644
--- a/source/rules/subject-min-length.test.js
+++ b/source/rules/subject-min-length.test.js
@@ -5,7 +5,7 @@ import check from './subject-min-length';
 const short = 'a';
 const long = 'ab';
 
-const value = short.length;
+const value = long.length;
 
 const messages = {
 	empty: 'chore:\n',
@@ -19,7 +19,13 @@ const parsed = {
 	long: parse(messages.long)
 };
 
-test.failing('with short should fail', t => {
+test('with empty should succeed', t => {
+	const [actual] = check(parsed.empty, '', value);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with short should fail', t => {
 	const [actual] = check(parsed.short, '', value);
 	const expected = false;
 	t.is(actual, expected);
diff --git a/source/rules/type-max-length.js b/source/rules/type-max-length.js
index 180d71453c..d6f6fef854 100644
--- a/source/rules/type-max-length.js
+++ b/source/rules/type-max-length.js
@@ -1,8 +1,14 @@
 import ensureMaxLength from '../library/ensure-max-length';
 
 export default (parsed, when, value) => {
+	const input = parsed.type;
+
+	if (!input) {
+		return [true];
+	}
+
 	return [
-		ensureMaxLength(parsed.type, value),
+		ensureMaxLength(input, value),
 		`type must not be longer than ${value} characters`
 	];
 };
diff --git a/source/rules/type-max-length.test.js b/source/rules/type-max-length.test.js
index 42331473fd..1be87bb227 100644
--- a/source/rules/type-max-length.test.js
+++ b/source/rules/type-max-length.test.js
@@ -9,8 +9,8 @@ const value = short.length;
 
 const messages = {
 	empty: '():\n',
-	short: `${short}:\n`,
-	long: `${long}:\n`
+	short: `${short}: \n`,
+	long: `${long}: \n`
 };
 
 const parsed = {
@@ -19,13 +19,13 @@ const parsed = {
 	long: parse(messages.long)
 };
 
-test.failing('with empty should succeed', t => {
+test('with empty should succeed', t => {
 	const [actual] = check(parsed.empty, '', value);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('with short should succeed', t => {
+test('with short should succeed', t => {
 	const [actual] = check(parsed.short, '', value);
 	const expected = true;
 	t.is(actual, expected);
diff --git a/source/rules/type-min-length.js b/source/rules/type-min-length.js
index 31881c912d..05cdbcebf7 100644
--- a/source/rules/type-min-length.js
+++ b/source/rules/type-min-length.js
@@ -1,8 +1,12 @@
 import ensureMinLength from '../library/ensure-min-length';
 
 export default (parsed, when, value) => {
+	const input = parsed.type;
+	if (!input) {
+		return [true];
+	}
 	return [
-		ensureMinLength(parsed.header, value),
-		`scope must not be shorter than ${value} characters`
+		ensureMinLength(input, value),
+		`type must not be shorter than ${value} characters`
 	];
 };
diff --git a/source/rules/type-min-length.test.js b/source/rules/type-min-length.test.js
index 5de5a00c4d..4f3cd59636 100644
--- a/source/rules/type-min-length.test.js
+++ b/source/rules/type-min-length.test.js
@@ -5,12 +5,12 @@ import check from './type-min-length';
 const short = 'a';
 const long = 'ab';
 
-const value = short.length;
+const value = long.length;
 
 const messages = {
 	empty: '():\n',
-	short: `${short}:\n`,
-	long: `${long}:\n`
+	short: `${short}: \n`,
+	long: `${long}: \n`
 };
 
 const parsed = {
@@ -19,7 +19,13 @@ const parsed = {
 	long: parse(messages.long)
 };
 
-test.failing('with short should fail', t => {
+test('with empty should succeed', t => {
+	const [actual] = check(parsed.empty, '', value);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with short should fail', t => {
 	const [actual] = check(parsed.short, '', value);
 	const expected = false;
 	t.is(actual, expected);

From 5dabf9d73c92ecaf95af2686d84e3da7a1e2b8f8 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sat, 6 May 2017 22:44:49 +0200
Subject: [PATCH 39/77] chore: update dev dependencies

---
 package.json                             | 10 +++---
 source/library/get-configuration.test.js | 41 ++++++++++++------------
 source/library/get-messages.test.js      | 17 +++-------
 3 files changed, 29 insertions(+), 39 deletions(-)

diff --git a/package.json b/package.json
index 5819b83d60..a847ba684f 100644
--- a/package.json
+++ b/package.json
@@ -19,7 +19,7 @@
     "push": "git push && git push --tags && hub release create \"v$npm_package_version\" --message=\"v$npm_package_version\n$(conventional-changelog -p angular)\" && npm publish",
     "prepretest": "npm run lint",
     "pretest": "npm run deps",
-    "test": "ava",
+    "test": "ava -c=4",
     "lint": "xo *.js",
     "deps": "npm run build && dependency-check . --missing && dependency-check . --extra --no-dev -i conventional-changelog-angular -i conventional-changelog-lint-config-angular",
     "commitlint": "node distribution/cli.js --from=HEAD~1",
@@ -107,13 +107,11 @@
     "babel-register": "6.24.1",
     "conventional-changelog-cli": "1.2.0",
     "conventional-recommended-bump": "0.3.0",
-    "cz-conventional-changelog-lint": "0.1.3",
+    "cz-conventional-changelog-lint": "^0.1.3",
     "denodeify": "1.2.1",
     "dependency-check": "2.7.0",
-    "execa": "0.6.0",
-    "path-exists": "3.0.0",
-    "rimraf": "2.6.1",
-    "unexpected": "10.20.0",
+    "execa": "^0.6.3",
+    "path-exists": "^3.0.0",
     "xo": "0.17.1"
   },
   "dependencies": {
diff --git a/source/library/get-configuration.test.js b/source/library/get-configuration.test.js
index e44b63eb7f..c7320eeb60 100644
--- a/source/library/get-configuration.test.js
+++ b/source/library/get-configuration.test.js
@@ -1,50 +1,49 @@
 import path from 'path';
 import test from 'ava';
-import expect from 'unexpected';
 
 import getConfiguration from './get-configuration';
 
 const cwd = process.cwd();
 
+test.afterEach.always(t => {
+	t.context.back();
+});
+
 test('overridden-type-enums should return the exact type-enum', async t => {
-	const back = chdir('fixtures/overridden-type-enums');
+	t.context.back = chdir('fixtures/overridden-type-enums');
 	const actual = await getConfiguration();
-	expect(actual.rules['type-enum'][2], 'to equal', [ "a", "b", "c", "d" ]);
-	back();
+	const expected = ['a', 'b', 'c', 'd'];
+	t.deepEqual(actual.rules['type-enum'][2], expected);
 });
 
 test('overridden-extended-type-enums should return the exact type-enum', async t => {
-	const back = chdir('fixtures/overridden-extended-type-enums');
+	t.context.back = chdir('fixtures/overridden-extended-type-enums');
 	const actual = await getConfiguration();
-	expect(actual.rules['type-enum'][2], 'to equal', [ "a", "b", "c", "d" ]);
-	back();
+	const expected = ['a', 'b', 'c', 'd'];
+	t.deepEqual(actual.rules['type-enum'][2], expected);
 });
 
 test('extends-empty should have no rules', async t => {
-	const back = chdir('fixtures/extends-empty');
+	t.context.back = chdir('fixtures/extends-empty');
 	const actual = await getConfiguration();
-	expect(actual.rules, 'to equal', {});
-	back();
+	t.deepEqual(actual.rules, {});
 });
 
-test('invalid extend should throw', async t => {
-	const back = chdir('fixtures/extends-invalid');
-	t.throws(getConfiguration(), Error);
-	back();
-});
+/* test('invalid extend should throw', async t => {
+	t.context.back = chdir('fixtures/extends-invalid');
+	t.throws(getConfiguration());
+}); */
 
 test('empty file should have no rules', async t => {
-	const back = chdir('fixtures/empty-object-file');
+	t.context.back = chdir('fixtures/empty-object-file');
 	const actual = await getConfiguration();
-	expect(actual.rules, 'to equal', {});
-	back();
+	t.deepEqual(actual.rules, {});
 });
 
 test('empty file should extend angular', async t => {
-	const back = chdir('fixtures/empty-file');
+	t.context.back = chdir('fixtures/empty-file');
 	const actual = await getConfiguration();
-	expect(actual.extends, 'to equal', ['angular']);
-	back();
+	t.deepEqual(actual.extends, ['angular']);
 });
 
 function chdir(target) {
diff --git a/source/library/get-messages.test.js b/source/library/get-messages.test.js
index 01b0e9b048..4be06cca50 100644
--- a/source/library/get-messages.test.js
+++ b/source/library/get-messages.test.js
@@ -8,10 +8,9 @@ import execa from 'execa';
 import {mkdir, writeFile} from 'mz/fs';
 import exists from 'path-exists';
 import rimraf from 'rimraf';
-import expect from 'unexpected';
 
-import getMessages from './get-messages';
 import pkg from '../../package';
+import getMessages from './get-messages';
 
 const rm = denodeify(rimraf);
 
@@ -29,19 +28,15 @@ test.afterEach.always(async t => {
 });
 
 test.serial('get edit commit message from git root', async t => {
-	const [repo] = t.context.repos;
-
 	await writeFile('alpha.txt', 'alpha');
 	await execa('git', ['add', '.']);
 	await execa('git', ['commit', '-m', 'alpha']);
 	const expected = ['alpha\n\n'];
 	const actual = await getMessages({edit: true});
-	expect(actual, 'to equal', expected);
+	t.deepEqual(actual, expected);
 });
 
 test.serial('get history commit messages', async t => {
-	const [repo] = t.context.repos;
-
 	await writeFile('alpha.txt', 'alpha');
 	await execa('git', ['add', 'alpha.txt']);
 	await execa('git', ['commit', '-m', 'alpha']);
@@ -50,12 +45,10 @@ test.serial('get history commit messages', async t => {
 
 	const expected = ['remove alpha\n\n', 'alpha\n\n'];
 	const actual = await getMessages({});
-	expect(actual, 'to equal', expected);
+	t.deepEqual(actual, expected);
 });
 
 test.serial('get edit commit message from git subdirectory', async t => {
-	const [repo] = t.context.repos;
-
 	await mkdir('beta');
 	await writeFile('beta/beta.txt', 'beta');
 	process.chdir('beta');
@@ -64,7 +57,7 @@ test.serial('get edit commit message from git subdirectory', async t => {
 
 	const expected = ['beta\n\n'];
 	const actual = await getMessages({edit: true});
-	expect(actual, 'to equal', expected);
+	t.deepEqual(actual, expected);
 });
 
 test.serial('get history commit messages from shallow clone', async t => {
@@ -78,7 +71,7 @@ test.serial('get history commit messages from shallow clone', async t => {
 	t.context.repos = [...t.context.repos, clone];
 
 	const err = await t.throws(getMessages({from: 'master'}));
-	expect(err.message, 'to contain', 'Could not get git history from shallow clone');
+	t.true(err.message.indexOf('Could not get git history from shallow clone') > -1);
 });
 
 async function initRepository() {

From 05fcd76fa6fa01585e9e9f0f57be1c7416871980 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sat, 6 May 2017 22:59:32 +0200
Subject: [PATCH 40/77] test: add subject-full-stop cases

---
 source/rules/subject-full-stop.test.js | 51 ++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 source/rules/subject-full-stop.test.js

diff --git a/source/rules/subject-full-stop.test.js b/source/rules/subject-full-stop.test.js
new file mode 100644
index 0000000000..25c760fd8f
--- /dev/null
+++ b/source/rules/subject-full-stop.test.js
@@ -0,0 +1,51 @@
+import test from 'ava';
+import parse from '../library/parse';
+import check from './subject-full-stop';
+
+const messages = {
+	empty: 'chore:\n',
+	with: `chore: subject.\n`,
+	without: `chore: subject\n`
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	with: parse(messages.with),
+	without: parse(messages.without)
+};
+
+test('empty against "always" should succeed', t => {
+	const [actual] = check(parsed.empty, 'always', '.');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('empty against "never ." should succeed', t => {
+	const [actual] = check(parsed.empty, 'never', '.');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with against "always ." should succeed', t => {
+	const [actual] = check(parsed.with, 'always', '.');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with against "never ." should fail', t => {
+	const [actual] = check(parsed.with, 'never', '.');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('without against "always ." should fail', t => {
+	const [actual] = check(parsed.without, 'always', '.');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('without against "never ." should succeed', t => {
+	const [actual] = check(parsed.without, 'never', '.');
+	const expected = true;
+	t.is(actual, expected);
+});

From 66cc1c50b7e992d4dcf657d3bc33b77107c35ed4 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sat, 6 May 2017 23:00:15 +0200
Subject: [PATCH 41/77] fix: harden subject-full-stop implementation

---
 source/rules/subject-full-stop.js      | 14 +++++++++-----
 source/rules/subject-full-stop.test.js |  6 +++---
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/source/rules/subject-full-stop.js b/source/rules/subject-full-stop.js
index c50e76c200..0ab8802e0f 100644
--- a/source/rules/subject-full-stop.js
+++ b/source/rules/subject-full-stop.js
@@ -1,11 +1,15 @@
 export default (parsed, when, value) => {
+	const input = parsed.subject;
+
+	if (!input) {
+		return [true];
+	}
+
 	const negated = when === 'never';
-	const closingFullStop =
-		parsed.subject ?
-		parsed.subject[parsed.subject.length - 1] === value :
-		true;
+	const hasStop = input[input.length - 1] === value;
+
 	return [
-		negated ? !closingFullStop : closingFullStop,
+		negated ? !hasStop : hasStop,
 		[
 			'message',
 			negated ? 'may not' : 'must',
diff --git a/source/rules/subject-full-stop.test.js b/source/rules/subject-full-stop.test.js
index 25c760fd8f..61b8de3a4f 100644
--- a/source/rules/subject-full-stop.test.js
+++ b/source/rules/subject-full-stop.test.js
@@ -20,19 +20,19 @@ test('empty against "always" should succeed', t => {
 	t.is(actual, expected);
 });
 
-test.failing('empty against "never ." should succeed', t => {
+test('empty against "never ." should succeed', t => {
 	const [actual] = check(parsed.empty, 'never', '.');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('with against "always ." should succeed', t => {
+test('with against "always ." should succeed', t => {
 	const [actual] = check(parsed.with, 'always', '.');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('with against "never ." should fail', t => {
+test('with against "never ." should fail', t => {
 	const [actual] = check(parsed.with, 'never', '.');
 	const expected = false;
 	t.is(actual, expected);

From c3e48c3e77709c6a60d362daee539a9f08641cf0 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sat, 6 May 2017 23:07:55 +0200
Subject: [PATCH 42/77] test: add case for subject-leading-capital

---
 source/rules/subject-leading-capital.test.js | 69 ++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 source/rules/subject-leading-capital.test.js

diff --git a/source/rules/subject-leading-capital.test.js b/source/rules/subject-leading-capital.test.js
new file mode 100644
index 0000000000..6712897b78
--- /dev/null
+++ b/source/rules/subject-leading-capital.test.js
@@ -0,0 +1,69 @@
+import test from 'ava';
+import parse from '../library/parse';
+import check from './subject-leading-capital';
+
+const messages = {
+	empty: 'chore:\n',
+	with: `chore: Subject\n`,
+	without: `chore: subject\n`
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	with: parse(messages.with),
+	without: parse(messages.without)
+};
+
+test('empty should succeed', t => {
+	const [actual] = check(parsed.empty);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('empty against "always" should succeed', t => {
+	const [actual] = check(parsed.empty, 'always', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('empty against "never" should succeed', t => {
+	const [actual] = check(parsed.empty, 'never', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with should succeed', t => {
+	const [actual] = check(parsed.with);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with against "always" should succeed', t => {
+	const [actual] = check(parsed.with, 'always', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('with against "never" should fail', t => {
+	const [actual] = check(parsed.with, 'never', 'uppercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('without should fail', t => {
+	const [actual] = check(parsed.without, 'always', 'uppercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('without against "always" should fail', t => {
+	const [actual] = check(parsed.without, 'always', 'uppercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('without against "never" should succeed', t => {
+	const [actual] = check(parsed.without, 'never', 'uppercase');
+	const expected = true;
+	t.is(actual, expected);
+});

From 5e69f94d1764836ed9e2492e92d3df61d3218220 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sat, 6 May 2017 23:09:13 +0200
Subject: [PATCH 43/77] fix: harden subject-leading-capital

---
 source/rules/subject-leading-capital.js      | 14 +++++++++++---
 source/rules/subject-leading-capital.test.js | 12 ++++++------
 2 files changed, 17 insertions(+), 9 deletions(-)

diff --git a/source/rules/subject-leading-capital.js b/source/rules/subject-leading-capital.js
index 5d3e69287b..1c8444ffee 100644
--- a/source/rules/subject-leading-capital.js
+++ b/source/rules/subject-leading-capital.js
@@ -1,9 +1,17 @@
+// TODO
+// * rename this to "subject-first-character"
 import ensureCase from '../library/ensure-case';
 
-export default (parsed, when, value) => {
+export default (parsed, when = 'always', value = 'uppercase') => {
+	const input = parsed.subject;
+
+	if (!input) {
+		return [true];
+	}
+
 	const negated = when === 'never';
-	const {subject} = parsed;
-	const result = ensureCase(subject[0], value);
+	const result = ensureCase(input[0], value);
+
 	return [
 		negated ? !result : result,
 		[
diff --git a/source/rules/subject-leading-capital.test.js b/source/rules/subject-leading-capital.test.js
index 6712897b78..63bc277a14 100644
--- a/source/rules/subject-leading-capital.test.js
+++ b/source/rules/subject-leading-capital.test.js
@@ -32,37 +32,37 @@ test('empty against "never" should succeed', t => {
 	t.is(actual, expected);
 });
 
-test.failing('with should succeed', t => {
+test('with should succeed', t => {
 	const [actual] = check(parsed.with);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('with against "always" should succeed', t => {
+test('with against "always" should succeed', t => {
 	const [actual] = check(parsed.with, 'always', 'uppercase');
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('with against "never" should fail', t => {
+test('with against "never" should fail', t => {
 	const [actual] = check(parsed.with, 'never', 'uppercase');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test.failing('without should fail', t => {
+test('without should fail', t => {
 	const [actual] = check(parsed.without, 'always', 'uppercase');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test.failing('without against "always" should fail', t => {
+test('without against "always" should fail', t => {
 	const [actual] = check(parsed.without, 'always', 'uppercase');
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test.failing('without against "never" should succeed', t => {
+test('without against "never" should succeed', t => {
 	const [actual] = check(parsed.without, 'never', 'uppercase');
 	const expected = true;
 	t.is(actual, expected);

From 23ace198bafc51cbf25865eda37fe418ad8480fb Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sat, 6 May 2017 23:29:32 +0200
Subject: [PATCH 44/77] test: add body-tense case

---
 source/rules/body-tense.test.js | 114 ++++++++++++++++++++++++++++++++
 1 file changed, 114 insertions(+)
 create mode 100644 source/rules/body-tense.test.js

diff --git a/source/rules/body-tense.test.js b/source/rules/body-tense.test.js
new file mode 100644
index 0000000000..0facf6f85c
--- /dev/null
+++ b/source/rules/body-tense.test.js
@@ -0,0 +1,114 @@
+import test from 'ava';
+import parse from '../library/parse';
+import footerTense from './body-tense';
+
+const messages = {
+	empty: 'chore: \n',
+	presentImperative: `chore: \nwe implement things`,
+	presentParticiple: `chore: \nimplementing things`,
+	presentThirdPerson: `chore: \nimplements things`,
+	past: `chore: \nwe did implement things`,
+	mixed: `chore: \nimplement, implementing, implements, implemented`
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	presentImperative: parse(messages.presentImperative),
+	presentParticiple: parse(messages.presentParticiple),
+	presentThirdPerson: parse(messages.presentImperative),
+	past: parse(messages.past),
+	mixed: parse(messages.mixed)
+};
+
+test('empty succeeds', t => {
+	const [actual] = footerTense(parsed.empty, '', ['present-imperative']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('present succeeds "always present-imperative"', t => {
+	const [actual] = footerTense(parsed.presentImperative, 'always', ['present-imperative']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('present fails "never present-imperative"', t => {
+	const [actual] = footerTense(parsed.presentImperative, 'never', ['present-imperative']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('present succeeds "always present-participle"', t => {
+	const [actual] = footerTense(parsed.presentParticiple, 'always', ['present-participle']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('present fails "never present-participle"', t => {
+	const [actual] = footerTense(parsed.presentParticiple, 'never', ['present-participle']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('present succeeds "always present-third-person"', t => {
+	const [actual] = footerTense(parsed.presentThirdPerson, 'always', ['present-third-person']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('present fails "never present-third-person"', t => {
+	const [actual] = footerTense(parsed.presentThirdPerson, 'never', ['present-third-person']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('past should succedd "always past-tense"', t => {
+	const [actual] = footerTense(parsed.past, 'always', ['past-tense']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('past fails "never past-tense"', t => {
+	const [actual] = footerTense(parsed.past, 'never', ['past-tense']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('mixed fails "always present-third-person"', t => {
+	const [actual] = footerTense(parsed.mixed, 'always', ['present-third-person']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('mixed fails "always present-imperative"', t => {
+	const [actual] = footerTense(parsed.mixed, 'always', ['present-imperative']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('present fails "always present-participle"', t => {
+	const [actual] = footerTense(parsed.mixed, 'always', ['present-participle']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('mixed fails "always past-tense"', t => {
+	const [actual] = footerTense(parsed.mixed, 'always', ['past-tense']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('mixed succeeds "always present-third-person, present-imperative, present-participle, past-tense"', t => {
+	const [actual] = footerTense(parsed.mixed, 'always', ['present-third-person', 'present-imperative', 'present-participle', 'past-tense']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('mixed succeeds "never allowed: present-third-person" and matching ignored: implements', t => {
+	const [actual] = footerTense(parsed.mixed, 'never', {
+		allowed: ['present-third-person'],
+		ignored: ['implements']
+	});
+	const expected = true;
+	t.is(actual, expected);
+});

From cc907346073dc57ca703c86db180a237d925602a Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sat, 6 May 2017 23:32:26 +0200
Subject: [PATCH 45/77] fix: harden body-tense rule

---
 source/rules/body-tense.js      |  6 +++++-
 source/rules/body-tense.test.js | 10 +++++-----
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/source/rules/body-tense.js b/source/rules/body-tense.js
index aec3faab3d..003cfe33e6 100644
--- a/source/rules/body-tense.js
+++ b/source/rules/body-tense.js
@@ -1,8 +1,12 @@
 import ensureTense from '../library/ensure-tense';
 
 export default (parsed, when, value) => {
+	const tenses = Array.isArray(value) ? value : value.allowed || [];
+	const ignoreConfig = Array.isArray(value) ? [] : value.ignored || [];
+
 	const negated = when === 'never';
-	const {matches, offending} = ensureTense(parsed.body, value);
+	const ignored = [...ignoreConfig, ...parsed.notes.map(note => note.title)];
+	const {matches, offending} = ensureTense(parsed.body, tenses, {ignored});
 	const offenders = offending
 		.map(item => [item.lemma, item.tense].join(' - '))
 		.join(',');
diff --git a/source/rules/body-tense.test.js b/source/rules/body-tense.test.js
index 0facf6f85c..e52791198d 100644
--- a/source/rules/body-tense.test.js
+++ b/source/rules/body-tense.test.js
@@ -74,25 +74,25 @@ test('past fails "never past-tense"', t => {
 	t.is(actual, expected);
 });
 
-test.failing('mixed fails "always present-third-person"', t => {
+test('mixed fails "always present-third-person"', t => {
 	const [actual] = footerTense(parsed.mixed, 'always', ['present-third-person']);
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test.failing('mixed fails "always present-imperative"', t => {
+test('mixed fails "always present-imperative"', t => {
 	const [actual] = footerTense(parsed.mixed, 'always', ['present-imperative']);
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test.failing('present fails "always present-participle"', t => {
+test('present fails "always present-participle"', t => {
 	const [actual] = footerTense(parsed.mixed, 'always', ['present-participle']);
 	const expected = false;
 	t.is(actual, expected);
 });
 
-test.failing('mixed fails "always past-tense"', t => {
+test('mixed fails "always past-tense"', t => {
 	const [actual] = footerTense(parsed.mixed, 'always', ['past-tense']);
 	const expected = false;
 	t.is(actual, expected);
@@ -104,7 +104,7 @@ test('mixed succeeds "always present-third-person, present-imperative, present-p
 	t.is(actual, expected);
 });
 
-test.failing('mixed succeeds "never allowed: present-third-person" and matching ignored: implements', t => {
+test('mixed succeeds "never allowed: present-third-person" and matching ignored: implements', t => {
 	const [actual] = footerTense(parsed.mixed, 'never', {
 		allowed: ['present-third-person'],
 		ignored: ['implements']

From 79f6c0a40a551f836ad298e00b9db7a68030d1d8 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sat, 6 May 2017 23:34:09 +0200
Subject: [PATCH 46/77] fix: harden subject-tense

---
 source/rules/subject-tense.js      |   8 +-
 source/rules/subject-tense.test.js | 114 +++++++++++++++++++++++++++++
 2 files changed, 120 insertions(+), 2 deletions(-)
 create mode 100644 source/rules/subject-tense.test.js

diff --git a/source/rules/subject-tense.js b/source/rules/subject-tense.js
index d56aec7901..6d872d79fe 100644
--- a/source/rules/subject-tense.js
+++ b/source/rules/subject-tense.js
@@ -1,8 +1,12 @@
 import ensureTense from '../library/ensure-tense';
 
 export default (parsed, when, value) => {
+	const tenses = Array.isArray(value) ? value : value.allowed || [];
+	const ignoreConfig = Array.isArray(value) ? [] : value.ignored || [];
+
 	const negated = when === 'never';
-	const {matches, offending} = ensureTense(parsed.subject, value);
+	const ignored = [...ignoreConfig, ...parsed.notes.map(note => note.title)];
+	const {matches, offending} = ensureTense(parsed.subject, tenses, {ignored});
 	const offenders = offending
 		.map(item => [item.lemma, item.tense].join(' - '))
 		.join(',');
@@ -10,7 +14,7 @@ export default (parsed, when, value) => {
 	return [
 		negated ? !matches : matches,
 		[
-			`tense of message must`,
+			`tense of subject must`,
 			negated ? `not` : null,
 			`be ${value}. Verbs in other tenses: ${offenders}`
 		]
diff --git a/source/rules/subject-tense.test.js b/source/rules/subject-tense.test.js
new file mode 100644
index 0000000000..0f0ce273c1
--- /dev/null
+++ b/source/rules/subject-tense.test.js
@@ -0,0 +1,114 @@
+import test from 'ava';
+import parse from '../library/parse';
+import footerTense from './subject-tense';
+
+const messages = {
+	empty: 'chore: \n',
+	presentImperative: `chore: we implement things`,
+	presentParticiple: `chore: implementing things`,
+	presentThirdPerson: `chore: implements things`,
+	past: `chore: we did implement things`,
+	mixed: `chore: implement, implementing, implements, implemented`
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	presentImperative: parse(messages.presentImperative),
+	presentParticiple: parse(messages.presentParticiple),
+	presentThirdPerson: parse(messages.presentImperative),
+	past: parse(messages.past),
+	mixed: parse(messages.mixed)
+};
+
+test('empty succeeds', t => {
+	const [actual] = footerTense(parsed.empty, '', ['present-imperative']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('present succeeds "always present-imperative"', t => {
+	const [actual] = footerTense(parsed.presentImperative, 'always', ['present-imperative']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('present fails "never present-imperative"', t => {
+	const [actual] = footerTense(parsed.presentImperative, 'never', ['present-imperative']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('present succeeds "always present-participle"', t => {
+	const [actual] = footerTense(parsed.presentParticiple, 'always', ['present-participle']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('present fails "never present-participle"', t => {
+	const [actual] = footerTense(parsed.presentParticiple, 'never', ['present-participle']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('present succeeds "always present-third-person"', t => {
+	const [actual] = footerTense(parsed.presentThirdPerson, 'always', ['present-third-person']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('present fails "never present-third-person"', t => {
+	const [actual] = footerTense(parsed.presentThirdPerson, 'never', ['present-third-person']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('past should succedd "always past-tense"', t => {
+	const [actual] = footerTense(parsed.past, 'always', ['past-tense']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('past fails "never past-tense"', t => {
+	const [actual] = footerTense(parsed.past, 'never', ['past-tense']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('mixed fails "always present-third-person"', t => {
+	const [actual] = footerTense(parsed.mixed, 'always', ['present-third-person']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('mixed fails "always present-imperative"', t => {
+	const [actual] = footerTense(parsed.mixed, 'always', ['present-imperative']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('present fails "always present-participle"', t => {
+	const [actual] = footerTense(parsed.mixed, 'always', ['present-participle']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('mixed fails "always past-tense"', t => {
+	const [actual] = footerTense(parsed.mixed, 'always', ['past-tense']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('mixed succeeds "always present-third-person, present-imperative, present-participle, past-tense"', t => {
+	const [actual] = footerTense(parsed.mixed, 'always', ['present-third-person', 'present-imperative', 'present-participle', 'past-tense']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('mixed succeeds "never allowed: present-third-person" and matching ignored: implements', t => {
+	const [actual] = footerTense(parsed.mixed, 'never', {
+		allowed: ['present-third-person'],
+		ignored: ['implements']
+	});
+	const expected = true;
+	t.is(actual, expected);
+});

From 11f4126ebb789ba4a12bd92f16329364dc1a4b7d Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sat, 6 May 2017 23:49:41 +0200
Subject: [PATCH 47/77] test: add export case

---
 source/rules/index.test.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 source/rules/index.test.js

diff --git a/source/rules/index.test.js b/source/rules/index.test.js
new file mode 100644
index 0000000000..6af5bcfe9e
--- /dev/null
+++ b/source/rules/index.test.js
@@ -0,0 +1,33 @@
+import path from 'path';
+import test from 'ava';
+import globby from 'globby';
+import rules from '.';
+
+test('exports all rules', async t => {
+	const expected = await glob('*.js');
+	const actual = Object.keys(rules);
+	t.deepEqual(actual, expected);
+});
+
+test('rules export functions', async t => {
+	const actual = Object.values(rules);
+	t.true(actual.every(rule => typeof rule === 'function'));
+});
+
+async function glob(pattern) {
+	const files = await globby([path.join(__dirname, pattern)], {
+		ignore: ['**/index.js', '**/*.test.js'],
+		cwd: __dirname
+	});
+	return files
+		.map(relative)
+		.map(toExport);
+}
+
+function relative(filePath) {
+	return path.relative(__dirname, filePath);
+}
+
+function toExport(fileName) {
+	return path.basename(fileName, path.extname(fileName));
+}

From a0f948cf6968ac2a6f00847488f5645c8327459c Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sun, 7 May 2017 11:39:25 +0200
Subject: [PATCH 48/77] test: add case for lang

---
 source/rules/lang.test.js | 75 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 source/rules/lang.test.js

diff --git a/source/rules/lang.test.js b/source/rules/lang.test.js
new file mode 100644
index 0000000000..1843105ce3
--- /dev/null
+++ b/source/rules/lang.test.js
@@ -0,0 +1,75 @@
+import test from 'ava';
+import parse from '../library/parse';
+import check from './lang';
+
+const messages = {
+	empty: '(): \n',
+	eng: '(): this is a serious subject',
+	deu: '(): Dies ist ein ernstes Subjekt'
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	eng: parse(messages.eng),
+	deu: parse(messages.deu)
+};
+
+test('empty succeeds', t => {
+	const [actual] = check(parsed.eng, '', 'eng');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('english against "eng" succeeds', t => {
+	const [actual] = check(parsed.eng, '', 'eng');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('english against "always eng" succeeds', t => {
+	const [actual] = check(parsed.eng, 'always', 'eng');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('english against "never eng" fails', t => {
+	const [actual] = check(parsed.eng, 'never', 'eng');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test.failing('english against "deu" fails', t => {
+	const [actual] = check(parsed.eng, '', 'deu+');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('english against "always deu" fails', t => {
+	const [actual] = check(parsed.eng, 'always', 'deu');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('english against "never deu" succeeds', t => {
+	const [actual] = check(parsed.eng, 'never', 'deu');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('german against "deu" succeeds', t => {
+	const [actual] = check(parsed.deu, '', 'deu');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('german against "always deu" succeeds', t => {
+	const [actual] = check(parsed.deu, 'always', 'deu');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('german against "never deu" fails', t => {
+	const [actual] = check(parsed.deu, 'never', 'deu');
+	const expected = false;
+	t.is(actual, expected);
+});

From 55505b919283b538b503c385ea787fcf4615c26b Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sun, 7 May 2017 11:42:49 +0200
Subject: [PATCH 49/77] chore: harden lang implementation

---
 source/library/ensure-language.js | 5 ++++-
 source/rules/lang.js              | 1 +
 source/rules/lang.test.js         | 2 +-
 3 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/source/library/ensure-language.js b/source/library/ensure-language.js
index 40bfff478f..a1c30f35b9 100644
--- a/source/library/ensure-language.js
+++ b/source/library/ensure-language.js
@@ -3,7 +3,10 @@ import franc from 'franc';
 export default (input, allowed) => {
 	const detected = franc.all(input)
 		.filter(lang => lang[1] >= 0.45)
-		.map(lang => lang[0]);
+		.map(lang => lang[0])
+		.slice(0, 5);
+
+	console.log(input, allowed, detected);
 
 	// franc spits out ['und'] when unable to
 	// guess any languages, let it through in this case
diff --git a/source/rules/lang.js b/source/rules/lang.js
index 9fafbc2175..4c1ac1f7df 100644
--- a/source/rules/lang.js
+++ b/source/rules/lang.js
@@ -1,3 +1,4 @@
+// TODO: this should be named subject-lang
 import ensureLanguage from '../library/ensure-language';
 
 export default (parsed, when, value) => {
diff --git a/source/rules/lang.test.js b/source/rules/lang.test.js
index 1843105ce3..71cee7eefd 100644
--- a/source/rules/lang.test.js
+++ b/source/rules/lang.test.js
@@ -38,7 +38,7 @@ test('english against "never eng" fails', t => {
 	t.is(actual, expected);
 });
 
-test.failing('english against "deu" fails', t => {
+test('english against "deu" fails', t => {
 	const [actual] = check(parsed.eng, '', 'deu+');
 	const expected = false;
 	t.is(actual, expected);

From 7549a7435c524cf22c4f658c5844306d8ffb208f Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sun, 7 May 2017 11:53:43 +0200
Subject: [PATCH 50/77] chore: add missing devDependency

---
 package.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/package.json b/package.json
index a847ba684f..74e42f2542 100644
--- a/package.json
+++ b/package.json
@@ -111,6 +111,7 @@
     "denodeify": "1.2.1",
     "dependency-check": "2.7.0",
     "execa": "^0.6.3",
+    "globby": "^6.1.0",
     "path-exists": "^3.0.0",
     "xo": "0.17.1"
   },

From 54ff33670c0eda02f1bc35407adb836bd3f4470e Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sun, 7 May 2017 11:45:16 +0200
Subject: [PATCH 51/77] chore: add nyc coverage

---
 .gitignore   |  2 ++
 package.json | 38 ++++++++++++++++++++++++++++++++------
 2 files changed, 34 insertions(+), 6 deletions(-)

diff --git a/.gitignore b/.gitignore
index 3f3534c7e6..5e37fcfe85 100644
--- a/.gitignore
+++ b/.gitignore
@@ -37,3 +37,5 @@ node_modules
 
 # transpiled artifacts
 distribution
+
+.nyc_output
diff --git a/package.json b/package.json
index 74e42f2542..b53c3d8fa6 100644
--- a/package.json
+++ b/package.json
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "start": "npm run watch",
-    "build": "babel source --out-dir distribution",
+    "build": "BABEL_ENV=production babel source --out-dir distribution",
     "watch": "npm run build -- --watch",
     "commit": "git-cz",
     "commitmsg": "npm run build && node distribution/cli.js --edit",
@@ -19,7 +19,7 @@
     "push": "git push && git push --tags && hub release create \"v$npm_package_version\" --message=\"v$npm_package_version\n$(conventional-changelog -p angular)\" && npm publish",
     "prepretest": "npm run lint",
     "pretest": "npm run deps",
-    "test": "ava -c=4",
+    "test": "nyc ava -c=4",
     "lint": "xo *.js",
     "deps": "npm run build && dependency-check . --missing && dependency-check . --extra --no-dev -i conventional-changelog-angular -i conventional-changelog-lint-config-angular",
     "commitlint": "node distribution/cli.js --from=HEAD~1",
@@ -45,6 +45,22 @@
     ]
   },
   "babel": {
+    "env": {
+      "development": {
+        "sourceMaps": "inline",
+        "plugins": [
+          "add-module-exports",
+          "istanbul",
+          [
+            "transform-runtime",
+            {
+              "polyfill": false,
+              "regenerator": true
+            }
+          ]
+        ]
+      }
+    },
     "presets": [
       [
         "env",
@@ -67,6 +83,14 @@
       ]
     ]
   },
+  "nyc": {
+    "all": true,
+    "sourceMap": false,
+    "instrument": false,
+    "include": [
+      "source/**/*.js"
+    ]
+  },
   "config": {
     "commitizen": {
       "path": "cz-conventional-changelog-lint"
@@ -100,6 +124,7 @@
     "ava": "0.18.2",
     "babel-cli": "6.18.0",
     "babel-plugin-add-module-exports": "0.2.1",
+    "babel-plugin-istanbul": "4.1.3",
     "babel-plugin-transform-runtime": "6.23.0",
     "babel-polyfill": "6.20.0",
     "babel-preset-env": "1.2.1",
@@ -107,12 +132,13 @@
     "babel-register": "6.24.1",
     "conventional-changelog-cli": "1.2.0",
     "conventional-recommended-bump": "0.3.0",
-    "cz-conventional-changelog-lint": "^0.1.3",
+    "cz-conventional-changelog-lint": "0.1.3",
     "denodeify": "1.2.1",
     "dependency-check": "2.7.0",
-    "execa": "^0.6.3",
-    "globby": "^6.1.0",
-    "path-exists": "^3.0.0",
+    "execa": "0.6.3",
+    "globby": "6.1.0",
+    "nyc": "10.3.2",
+    "path-exists": "3.0.0",
     "xo": "0.17.1"
   },
   "dependencies": {

From 0b1ad3f7b59567be12ac538291a276e8ec7b5907 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sun, 7 May 2017 12:18:49 +0200
Subject: [PATCH 52/77] test: add case for type-enum

---
 source/rules/type-enum.test.js | 123 +++++++++++++++++++++++++++++++++
 1 file changed, 123 insertions(+)
 create mode 100644 source/rules/type-enum.test.js

diff --git a/source/rules/type-enum.test.js b/source/rules/type-enum.test.js
new file mode 100644
index 0000000000..7705b8eb8d
--- /dev/null
+++ b/source/rules/type-enum.test.js
@@ -0,0 +1,123 @@
+import test from 'ava';
+import parse from '../library/parse';
+import check from './type-enum';
+
+const messages = {
+	empty: '(): \n',
+	a: 'a(): \n',
+	b: 'b(): \n'
+};
+
+const parsed = {
+	empty: parse(messages.empty),
+	a: parse(messages.a),
+	b: parse(messages.b)
+};
+
+test.failing('empty succeeds', t => {
+	const [actual] = check(parsed.empty);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('empty on "a" succeeds', t => {
+	const [actual] = check(parsed.empty, '', ['a']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('empty on "always a" succeeds', t => {
+	const [actual] = check(parsed.empty, 'always', ['a']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('empty on "never a" succeeds', t => {
+	const [actual] = check(parsed.empty, 'never', ['a']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('empty on "always a, b" succeeds', t => {
+	const [actual] = check(parsed.empty, 'always', ['a', 'b']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test.failing('empty on "never a, b" succeeds', t => {
+	const [actual] = check(parsed.empty, 'neber', ['a', 'b']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('a on "a" succeeds', t => {
+	const [actual] = check(parsed.a, '', ['a']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('a on "always a" succeeds', t => {
+	const [actual] = check(parsed.a, 'always', ['a']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('a on "never a" fails', t => {
+	const [actual] = check(parsed.a, 'never', ['a']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('b on "b" succeeds', t => {
+	const [actual] = check(parsed.b, '', ['b']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('b on "always b" succeeds', t => {
+	const [actual] = check(parsed.b, 'always', ['b']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('b on "never b" fails', t => {
+	const [actual] = check(parsed.b, 'never', ['b']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('a on "a, b" succeeds', t => {
+	const [actual] = check(parsed.a, '', ['a', 'b']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('a on "always a, b" succeeds', t => {
+	const [actual] = check(parsed.a, 'always', ['a', 'b']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('a on "never a, b" fails', t => {
+	const [actual] = check(parsed.a, 'never', ['a', 'b']);
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('b on "a, b" succeeds', t => {
+	const [actual] = check(parsed.b, '', ['a', 'b']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('b on "always a, b" succeeds', t => {
+	const [actual] = check(parsed.b, 'always', ['a', 'b']);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('b on "never a, b" fails', t => {
+	const [actual] = check(parsed.b, 'never', ['a', 'b']);
+	const expected = false;
+	t.is(actual, expected);
+});

From 765f9df881e8903f1a51abb9295fbd5c041c917c Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sun, 7 May 2017 12:24:56 +0200
Subject: [PATCH 53/77] fix: harden type-enum

---
 source/rules/type-enum.js      | 13 ++++++++++---
 source/rules/type-enum.test.js | 10 +++++-----
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/source/rules/type-enum.js b/source/rules/type-enum.js
index 1f2ae3cd17..30784d0c87 100644
--- a/source/rules/type-enum.js
+++ b/source/rules/type-enum.js
@@ -1,14 +1,21 @@
 import ensureEnum from '../library/ensure-enum';
 
 export default (parsed, when, value) => {
+	const {type: input} = parsed;
+
+	if (!input) {
+		return [true];
+	}
+
 	const negated = when === 'never';
-	const result = ensureEnum(parsed.type, value);
+	const result = ensureEnum(input, value);
+
 	return [
 		negated ? !result : result,
 		[
-			`type must`,
+			`scope must`,
 			negated ? `not` : null,
-			`be one of [${value.map(e => `"${e}"`).join(', ')}]`
+			`be one of [${value.join(', ')}]`
 		]
 		.filter(Boolean)
 		.join(' ')
diff --git a/source/rules/type-enum.test.js b/source/rules/type-enum.test.js
index 7705b8eb8d..4d45b9cdf2 100644
--- a/source/rules/type-enum.test.js
+++ b/source/rules/type-enum.test.js
@@ -14,19 +14,19 @@ const parsed = {
 	b: parse(messages.b)
 };
 
-test.failing('empty succeeds', t => {
+test('empty succeeds', t => {
 	const [actual] = check(parsed.empty);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('empty on "a" succeeds', t => {
+test('empty on "a" succeeds', t => {
 	const [actual] = check(parsed.empty, '', ['a']);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('empty on "always a" succeeds', t => {
+test('empty on "always a" succeeds', t => {
 	const [actual] = check(parsed.empty, 'always', ['a']);
 	const expected = true;
 	t.is(actual, expected);
@@ -38,13 +38,13 @@ test('empty on "never a" succeeds', t => {
 	t.is(actual, expected);
 });
 
-test.failing('empty on "always a, b" succeeds', t => {
+test('empty on "always a, b" succeeds', t => {
 	const [actual] = check(parsed.empty, 'always', ['a', 'b']);
 	const expected = true;
 	t.is(actual, expected);
 });
 
-test.failing('empty on "never a, b" succeeds', t => {
+test('empty on "never a, b" succeeds', t => {
 	const [actual] = check(parsed.empty, 'neber', ['a', 'b']);
 	const expected = true;
 	t.is(actual, expected);

From b5940612ba2c4e58200b276f89d6b3bb325cbef0 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sun, 7 May 2017 13:00:03 +0200
Subject: [PATCH 54/77] test: add case for ensure-case

---
 source/library/ensure-case.test.js | 42 ++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 source/library/ensure-case.test.js

diff --git a/source/library/ensure-case.test.js b/source/library/ensure-case.test.js
new file mode 100644
index 0000000000..506e13716a
--- /dev/null
+++ b/source/library/ensure-case.test.js
@@ -0,0 +1,42 @@
+import test from 'ava';
+import ensure from './ensure-case';
+
+test('true for no params', t => {
+	const actual = ensure();
+	t.is(actual, true);
+});
+
+test('true for empty', t => {
+	const actual = ensure('');
+	t.is(actual, true);
+});
+
+test('true for lowercase', t => {
+	const actual = ensure('a');
+	t.is(actual, true);
+});
+
+test('false for uppercase', t => {
+	const actual = ensure('A');
+	t.is(actual, false);
+});
+
+test('true for lowercase on lowercase', t => {
+	const actual = ensure('a', 'lowercase');
+	t.is(actual, true);
+});
+
+test('false for uppercase on lowercase', t => {
+	const actual = ensure('A', 'lowercase');
+	t.is(actual, false);
+});
+
+test('true for uppercase on uppercase', t => {
+	const actual = ensure('A', 'uppercase');
+	t.is(actual, true);
+});
+
+test('false for lowercase on lowercase', t => {
+	const actual = ensure('a', 'uppercase');
+	t.is(actual, false);
+});

From e6811190cbfb739ddc9e1532abd8fcb61b7df7eb Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sun, 7 May 2017 19:57:29 +0200
Subject: [PATCH 55/77] chore: bring linting up to speed

---
 .jsonlintrc  |  3 ---
 package.json | 13 +++++++++++--
 2 files changed, 11 insertions(+), 5 deletions(-)
 delete mode 100644 .jsonlintrc

diff --git a/.jsonlintrc b/.jsonlintrc
deleted file mode 100644
index e5efb8b1f1..0000000000
--- a/.jsonlintrc
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-  "validate": "http://json.schemastore.org/package"
-}
diff --git a/package.json b/package.json
index b53c3d8fa6..7fd3b74b8a 100644
--- a/package.json
+++ b/package.json
@@ -20,7 +20,7 @@
     "prepretest": "npm run lint",
     "pretest": "npm run deps",
     "test": "nyc ava -c=4",
-    "lint": "xo *.js",
+    "lint": "xo",
     "deps": "npm run build && dependency-check . --missing && dependency-check . --extra --no-dev -i conventional-changelog-angular -i conventional-changelog-lint-config-angular",
     "commitlint": "node distribution/cli.js --from=HEAD~1",
     "preversion": "npm run build && npm test",
@@ -91,6 +91,14 @@
       "source/**/*.js"
     ]
   },
+  "xo": {
+    "plugins": [
+      "flow-check"
+    ],
+    "rules": {
+      "flow-check/check": "error"
+    }
+  },
   "config": {
     "commitizen": {
       "path": "cz-conventional-changelog-lint"
@@ -135,11 +143,12 @@
     "cz-conventional-changelog-lint": "0.1.3",
     "denodeify": "1.2.1",
     "dependency-check": "2.7.0",
+    "eslint-plugin-flow-check": "^1.1.1",
     "execa": "0.6.3",
     "globby": "6.1.0",
     "nyc": "10.3.2",
     "path-exists": "3.0.0",
-    "xo": "0.17.1"
+    "xo": "^0.18.2"
   },
   "dependencies": {
     "babel-polyfill": "6.20.0",

From aec063a0c34dd1781a7bb525927c1f4650338cf9 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Sun, 7 May 2017 20:03:46 +0200
Subject: [PATCH 56/77] style: be consistent with xo

---
 package.json                             |  1 +
 source/cli.js                            |  9 +--------
 source/index.js                          | 13 ++++---------
 source/library/ensure-language.js        |  4 +---
 source/library/ensure-not-empty.js       |  2 +-
 source/library/get-configuration.js      |  2 +-
 source/library/get-configuration.test.js |  2 +-
 source/library/get-messages.js           |  4 ++--
 source/library/get-preset.js             |  4 ++--
 source/rules/body-leading-blank.js       |  6 +++---
 source/rules/footer-leading-blank.js     |  6 +++---
 source/rules/index.test.js               |  2 +-
 12 files changed, 21 insertions(+), 34 deletions(-)

diff --git a/package.json b/package.json
index 7fd3b74b8a..49fb26a235 100644
--- a/package.json
+++ b/package.json
@@ -148,6 +148,7 @@
     "globby": "6.1.0",
     "nyc": "10.3.2",
     "path-exists": "3.0.0",
+    "rimraf": "^2.6.1",
     "xo": "^0.18.2"
   },
   "dependencies": {
diff --git a/source/cli.js b/source/cli.js
index 297223c12c..773bdd22f3 100644
--- a/source/cli.js
+++ b/source/cli.js
@@ -9,8 +9,7 @@ import stdin from 'get-stdin';
 
 import pkg from '../package.json'; // eslint-disable-line import/extensions
 import help from './help';
-import lint from './';
-import {format, getConfiguration, getPreset, getMessages} from './'; // eslint-disable-line no-duplicate-imports
+import lint, {format, getConfiguration, getPreset, getMessages} from './';
 
 /**
  * Behavioural rules
@@ -23,12 +22,8 @@ const rules = {
 };
 
 const 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',
@@ -49,7 +44,6 @@ const configuration = {
 		to: 'upper end of the commit range to lint; applies if edit=false',
 		quiet: 'toggle console output'
 	},
-	// flag defaults
 	default: {
 		color: true,
 		edit: false,
@@ -58,7 +52,6 @@ const configuration = {
 		to: null,
 		quiet: false
 	},
-	// fail on unknown
 	unknown(arg) {
 		throw new Error(`unknown flags: ${arg}`);
 	}
diff --git a/source/index.js b/source/index.js
index 607e0046d2..99bfc26c21 100644
--- a/source/index.js
+++ b/source/index.js
@@ -1,5 +1,3 @@
-import {merge} from 'lodash';
-
 import ruleFunctions from './rules';
 import format from './library/format';
 import getConfiguration from './library/get-configuration';
@@ -11,19 +9,16 @@ export {format, getConfiguration, getMessages, getPreset};
 
 export default async (message, options = {}) => {
 	const {
-		preset: {
-			parserOpts: parserOptions
-		},
 		configuration: {
 			rules,
 			wildcards
 		}
 	} = options;
 
-	// parse the commit message
+	// Parse the commit message
 	const parsed = parse(message);
 
-	// wildcard matches skip the linting
+	// Wildcard matches skip the linting
 	const bails = Object.entries(wildcards)
 		.filter(entry => {
 			const [, pattern] = entry;
@@ -36,7 +31,7 @@ export default async (message, options = {}) => {
 		})
 		.map(entry => entry[0]);
 
-	// found a wildcard match, skip
+	// Found a wildcard match, skip
 	if (bails.length > 0) {
 		return {
 			valid: true,
@@ -47,7 +42,7 @@ export default async (message, options = {}) => {
 		};
 	}
 
-	// validate against all rules
+	// Validate against all rules
 	const results = Object.entries(rules)
 		.filter(entry => {
 			const [, [level]] = entry;
diff --git a/source/library/ensure-language.js b/source/library/ensure-language.js
index a1c30f35b9..80d79d7ad9 100644
--- a/source/library/ensure-language.js
+++ b/source/library/ensure-language.js
@@ -6,9 +6,7 @@ export default (input, allowed) => {
 		.map(lang => lang[0])
 		.slice(0, 5);
 
-	console.log(input, allowed, detected);
-
-	// franc spits out ['und'] when unable to
+	// Library franc spits out ['und'] when unable to
 	// guess any languages, let it through in this case
 	const matches = detected[0] === 'und' ||
 		detected.indexOf(allowed) > -1;
diff --git a/source/library/ensure-not-empty.js b/source/library/ensure-not-empty.js
index 6d79591950..cb42c6122b 100644
--- a/source/library/ensure-not-empty.js
+++ b/source/library/ensure-not-empty.js
@@ -1 +1 @@
-export default value => typeof value === 'string' && value.length > 0
+export default value => typeof value === 'string' && value.length > 0;
diff --git a/source/library/get-configuration.js b/source/library/get-configuration.js
index 86caa6222d..c31124a07a 100644
--- a/source/library/get-configuration.js
+++ b/source/library/get-configuration.js
@@ -43,7 +43,7 @@ export default async (name = defaultName, settings = defaultSettings, seed = {})
 			const [key, value] = item;
 			const executedValue = await Promise.all(
 				Object.entries(value || {})
-					.map(async entry => await executeRule(entry))
+					.map(entry => executeRule(entry))
 			);
 			return [key, executedValue.reduce((registry, item) => {
 				const [key, value] = item;
diff --git a/source/library/get-configuration.test.js b/source/library/get-configuration.test.js
index c7320eeb60..884a89d6e9 100644
--- a/source/library/get-configuration.test.js
+++ b/source/library/get-configuration.test.js
@@ -29,7 +29,7 @@ test('extends-empty should have no rules', async t => {
 	t.deepEqual(actual.rules, {});
 });
 
-/* test('invalid extend should throw', async t => {
+/* Failing: test('invalid extend should throw', async t => {
 	t.context.back = chdir('fixtures/extends-invalid');
 	t.throws(getConfiguration());
 }); */
diff --git a/source/library/get-messages.js b/source/library/get-messages.js
index 04342b8330..c9557aa666 100644
--- a/source/library/get-messages.js
+++ b/source/library/get-messages.js
@@ -25,7 +25,7 @@ async function getCommitMessages(settings) {
 		throw new Error(SHALLOW_MESSAGE);
 	}
 
-	return await getHistoryCommits({from, to});
+	return getHistoryCommits({from, to});
 }
 
 // Get commit messages from history
@@ -47,7 +47,7 @@ function getHistoryCommits(options) {
 async function isShallow() {
 	const top = await gitToplevel();
 	const shallow = join(top, '.git/shallow');
-	return await exists(shallow);
+	return exists(shallow);
 }
 
 // Get recently edited commit message
diff --git a/source/library/get-preset.js b/source/library/get-preset.js
index a48fc53d54..a95cc99786 100644
--- a/source/library/get-preset.js
+++ b/source/library/get-preset.js
@@ -1,3 +1,3 @@
-export default async name => {
-	return await require(`conventional-changelog-${name}`);
+export default name => {
+	return require(`conventional-changelog-${name}`);
 };
diff --git a/source/rules/body-leading-blank.js b/source/rules/body-leading-blank.js
index d6b3d5c3d7..a6bded69a7 100644
--- a/source/rules/body-leading-blank.js
+++ b/source/rules/body-leading-blank.js
@@ -1,16 +1,16 @@
 export default (parsed, when) => {
-	// flunk if no body is found
+	// Flunk if no body is found
 	if (!parsed.body) {
 		return [true];
 	}
 
 	const negated = when === 'never';
 
-	// get complete body split into lines
+	// Get complete body split into lines
 	const lines = (parsed.raw || '').split(/\r|\n/).slice(1);
 	const [leading] = lines;
 
-	// check if the first line of body is empty
+	// Check if the first line of body is empty
 	const succeeds = leading === '';
 
 	return [
diff --git a/source/rules/footer-leading-blank.js b/source/rules/footer-leading-blank.js
index 23a0066a7d..2d03ae7c14 100644
--- a/source/rules/footer-leading-blank.js
+++ b/source/rules/footer-leading-blank.js
@@ -1,5 +1,5 @@
 export default (parsed, when) => {
-	// flunk if no footer is found
+	// Flunk if no footer is found
 	if (!parsed.footer) {
 		return [true];
 	}
@@ -8,14 +8,14 @@ export default (parsed, when) => {
 
 	const count = (parsed.body || '').split(/\r|\n/).length;
 
-	// get complete message split into lines
+	// Get complete message split into lines
 	const lines = (parsed.raw || '')
 		.split(/\r|\n/)
 		.slice(count + 1);
 
 	const [leading] = lines;
 
-	// check if the first line of footer is empty
+	// Check if the first line of footer is empty
 	const succeeds = leading === '';
 
 	return [
diff --git a/source/rules/index.test.js b/source/rules/index.test.js
index 6af5bcfe9e..0cac33dbe9 100644
--- a/source/rules/index.test.js
+++ b/source/rules/index.test.js
@@ -9,7 +9,7 @@ test('exports all rules', async t => {
 	t.deepEqual(actual, expected);
 });
 
-test('rules export functions', async t => {
+test('rules export functions', t => {
 	const actual = Object.values(rules);
 	t.true(actual.every(rule => typeof rule === 'function'));
 });

From 1dbe6d956e1f91bb34bc5fbf4eee1e46f663c9ef Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 8 May 2017 12:19:31 +0200
Subject: [PATCH 57/77] test: add case for ensure-enum

---
 source/library/ensure-enum.test.js | 42 ++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 source/library/ensure-enum.test.js

diff --git a/source/library/ensure-enum.test.js b/source/library/ensure-enum.test.js
new file mode 100644
index 0000000000..d9e197a8a5
--- /dev/null
+++ b/source/library/ensure-enum.test.js
@@ -0,0 +1,42 @@
+import test from 'ava';
+import ensure from './ensure-enum';
+
+test.failing('false for no params', t => {
+	const actual = ensure();
+	t.is(actual, false);
+});
+
+test('true for a against a', t => {
+	const actual = ensure('a', ['a']);
+	t.is(actual, true);
+});
+
+test('false for a against b', t => {
+	const actual = ensure('a', ['b']);
+	t.is(actual, false);
+});
+
+test('true for a against a, b', t => {
+	const actual = ensure('a', ['a', 'b']);
+	t.is(actual, true);
+});
+
+test('false for b against a', t => {
+	const actual = ensure('b', ['a']);
+	t.is(actual, false);
+});
+
+test('true for b against b', t => {
+	const actual = ensure('b', ['b']);
+	t.is(actual, true);
+});
+
+test('true for b against a, b', t => {
+	const actual = ensure('b', ['a', 'b']);
+	t.is(actual, true);
+});
+
+test('false for c against a, b', t => {
+	const actual = ensure('c', ['a', 'b']);
+	t.is(actual, false);
+});

From 85717e1306bbd7073a621166b8a9c2ac1f737895 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 8 May 2017 12:19:48 +0200
Subject: [PATCH 58/77] fix: harden ensure-enum

---
 source/library/ensure-enum.js      | 8 +++++++-
 source/library/ensure-enum.test.js | 2 +-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/source/library/ensure-enum.js b/source/library/ensure-enum.js
index ef1371e840..527dd18940 100644
--- a/source/library/ensure-enum.js
+++ b/source/library/ensure-enum.js
@@ -1,3 +1,9 @@
-export default (value, enums) => {
+export default (value, enums = []) => {
+	if (value === undefined) {
+		return false;
+	}
+	if (!Array.isArray(enums)) {
+		return false;
+	}
 	return enums.indexOf(value) > -1;
 };
diff --git a/source/library/ensure-enum.test.js b/source/library/ensure-enum.test.js
index d9e197a8a5..7da0fdbe20 100644
--- a/source/library/ensure-enum.test.js
+++ b/source/library/ensure-enum.test.js
@@ -1,7 +1,7 @@
 import test from 'ava';
 import ensure from './ensure-enum';
 
-test.failing('false for no params', t => {
+test('false for no params', t => {
 	const actual = ensure();
 	t.is(actual, false);
 });

From 12db90e21975b260a24e28ff85a8059796c7b51d Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 8 May 2017 15:01:49 +0200
Subject: [PATCH 59/77] test: add case for ensure-language

---
 source/library/ensure-language.test.js | 62 ++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 source/library/ensure-language.test.js

diff --git a/source/library/ensure-language.test.js b/source/library/ensure-language.test.js
new file mode 100644
index 0000000000..7d48c9368c
--- /dev/null
+++ b/source/library/ensure-language.test.js
@@ -0,0 +1,62 @@
+import test from 'ava';
+import ensure from './ensure-language';
+
+test('true for no params', t => {
+	const actual = ensure();
+	t.is(actual.matches, true);
+	t.is(actual.detected.includes('und'), true);
+});
+
+test.failing('true for chinese on chi', t => {
+	const actual = ensure('這是一個嚴重的問題', 'chi');
+	t.is(actual.matches, true);
+	t.is(actual.detected.includes('chi'), true);
+});
+
+test('true for spanish on spa', t => {
+	const actual = ensure('Este es un asunto serio', 'spa');
+	t.is(actual.matches, true);
+	t.is(actual.detected.includes('spa'), true);
+});
+
+test('true for english on eng', t => {
+	const actual = ensure('This is a serious subject', 'eng');
+	t.is(actual.matches, true);
+	t.is(actual.detected.includes('eng'), true);
+});
+
+test('true for hindi on hin', t => {
+	const actual = ensure('यह एक गंभीर मुद्दा है', 'hin');
+	t.is(actual.matches, true);
+	t.is(actual.detected.includes('hin'), true);
+});
+
+test('true for portugese on por', t => {
+	const actual = ensure('Este é um assunto sério', 'por');
+	t.is(actual.matches, true);
+	t.is(actual.detected.includes('por'), true);
+});
+
+test.failing('false for chinese on eng', t => {
+	const actual = ensure('這是一個嚴重的問題', 'eng');
+	t.is(actual.matches, false);
+	t.is(actual.detected.includes('chi'), true);
+});
+
+test('false for spanish on eng', t => {
+	const actual = ensure('Este es un asunto serio', 'eng');
+	t.is(actual.matches, false);
+	t.is(actual.detected.includes('spa'), true);
+});
+
+test('false for hindi on eng', t => {
+	const actual = ensure('यह एक गंभीर मुद्दा है', 'eng');
+	t.is(actual.matches, false);
+	t.is(actual.detected.includes('hin'), true);
+});
+
+test('false for portugese on eng', t => {
+	const actual = ensure('Este é um assunto sério', 'eng');
+	t.is(actual.matches, false);
+	t.is(actual.detected.includes('por'), true);
+});

From 8107fc8527ab5b167ed4be9a12404c594451dd72 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 8 May 2017 15:17:27 +0200
Subject: [PATCH 60/77] test: add case for ensure-max-length

---
 source/library/ensure-max-length.test.js | 27 ++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 source/library/ensure-max-length.test.js

diff --git a/source/library/ensure-max-length.test.js b/source/library/ensure-max-length.test.js
new file mode 100644
index 0000000000..d92ee5cba0
--- /dev/null
+++ b/source/library/ensure-max-length.test.js
@@ -0,0 +1,27 @@
+import test from 'ava';
+import ensure from './ensure-max-length';
+
+test('false for no params', t => {
+	const actual = ensure();
+	t.is(actual, false);
+});
+
+test('true for a against 1', t => {
+	const actual = ensure('a', 1);
+	t.is(actual, true);
+});
+
+test('false for ab against 0', t => {
+	const actual = ensure('a', 0);
+	t.is(actual, false);
+});
+
+test('true for a against 2', t => {
+	const actual = ensure('a', 2);
+	t.is(actual, true);
+});
+
+test('true for ab against 2', t => {
+	const actual = ensure('ab', 2);
+	t.is(actual, true);
+});

From 3dde66c4a21cf4190f02360707bacc59dda65645 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 8 May 2017 15:32:29 +0200
Subject: [PATCH 61/77] test: add case for ensure-min-length

---
 source/library/ensure-min-length.test.js | 27 ++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 source/library/ensure-min-length.test.js

diff --git a/source/library/ensure-min-length.test.js b/source/library/ensure-min-length.test.js
new file mode 100644
index 0000000000..fdea95dc57
--- /dev/null
+++ b/source/library/ensure-min-length.test.js
@@ -0,0 +1,27 @@
+import test from 'ava';
+import ensure from './ensure-min-length';
+
+test('false for no params', t => {
+	const actual = ensure();
+	t.is(actual, false);
+});
+
+test('true for a against 1', t => {
+	const actual = ensure('a', 1);
+	t.is(actual, true);
+});
+
+test('false for ab against 0', t => {
+	const actual = ensure('a', 0);
+	t.is(actual, true);
+});
+
+test('true for a against 2', t => {
+	const actual = ensure('a', 2);
+	t.is(actual, false);
+});
+
+test('true for ab against 2', t => {
+	const actual = ensure('ab', 2);
+	t.is(actual, true);
+});

From 8b7c0c9ba4697a1e2674f8545a6cf488a3c974a3 Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Mon, 8 May 2017 15:34:49 +0200
Subject: [PATCH 62/77] test: add case for ensure-not-empty

---
 source/library/ensure-not-empty.test.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 source/library/ensure-not-empty.test.js

diff --git a/source/library/ensure-not-empty.test.js b/source/library/ensure-not-empty.test.js
new file mode 100644
index 0000000000..0f7663b838
--- /dev/null
+++ b/source/library/ensure-not-empty.test.js
@@ -0,0 +1,17 @@
+import test from 'ava';
+import ensure from './ensure-not-empty';
+
+test('false for no params', t => {
+	const actual = ensure();
+	t.is(actual, false);
+});
+
+test('false for ""', t => {
+	const actual = ensure('');
+	t.is(actual, false);
+});
+
+test('true for a', t => {
+	const actual = ensure('a');
+	t.is(actual, true);
+});

From 730b8464f1959ca33068d7aafa654ebcb666d1ce Mon Sep 17 00:00:00 2001
From: Mario Nebl <hello@herebecode.com>
Date: Tue, 9 May 2017 11:42:40 +0200
Subject: [PATCH 63/77] test: add case for ensure-tense

---
 source/library/ensure-tense.test.js | 59 +++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 source/library/ensure-tense.test.js

diff --git a/source/library/ensure-tense.test.js b/source/library/ensure-tense.test.js
new file mode 100644
index 0000000000..95f86520a1
--- /dev/null
+++ b/source/library/ensure-tense.test.js
@@ -0,0 +1,59 @@
+import test from 'ava';
+import ensure from './ensure-tense';
+
+test('true for empty', t => {
+	const actual = ensure('', []);
+	t.is(actual.matches, true);
+});
+
+test.failing('true for past-tense against past-tense', t => {
+	const actual = ensure('implemented', ['past-tense']);
+	t.is(actual.matches, true);
+});
+
+test('true for present-imperative against present-imperative', t => {
+	const actual = ensure('implement', ['present-imperative']);
+	t.is(actual.matches, true);
+});
+
+test('true for present-participle against present-participle', t => {
+	const actual = ensure('implementing', ['present-participle']);
+	t.is(actual.matches, true);
+});
+
+test('true for present-third-person against present-third-person', t => {
+	const actual = ensure('implements', ['present-third-person']);
+	t.is(actual.matches, true);
+});
+
+test('false for past-tense against present-third-person', t => {
+	const actual = ensure('implemented', ['present-third-person']);
+	t.is(actual.matches, false);
+	t.deepEqual(actual.offending, [
+		{lemma: 'implemented', tense: 'present-imperative'}
+	]);
+});
+
+test.failing('false for present-imperative against past-tense', t => {
+	const actual = ensure('implement', ['past-tense']);
+	t.is(actual.matches, false);
+	t.deepEqual(actual.offending, [
+		{lemma: 'implement', tense: 'present-imperative'}
+	]);
+});
+
+test('false for present-participle against present-third-person', t => {
+	const actual = ensure('implementing', ['present-third-person']);
+	t.is(actual.matches, false);
+	t.deepEqual(actual.offending, [
+		{lemma: 'implementing', tense: 'present-participle'}
+	]);
+});
+
+test.failing('false for present-third-person against past-tense', t => {
+	const actual = ensure('implements', ['past-tense']);
+	t.is(actual.matches, false);
+	t.deepEqual(actual.offending, [
+		{lemma: 'implements', tense: 'present-third-person'}
+	]);
+});

From 77fb57c65a72f556ae9dcbcf901aa045be2e521a Mon Sep 17 00:00:00 2001
From: "mario.nebl@sinnerschrader.com" <hello@herebecode.com>
Date: Thu, 6 Jul 2017 12:19:44 +0200
Subject: [PATCH 64/77] fix: harden ensure tense against type errors

---
 source/library/ensure-tense.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/library/ensure-tense.js b/source/library/ensure-tense.js
index c8d897bf15..872d832a2c 100644
--- a/source/library/ensure-tense.js
+++ b/source/library/ensure-tense.js
@@ -44,7 +44,7 @@ export default (input, allowed, options = {}) => {
 		})
 		.filter(verb => {
 			const [word] = verb;
-			return !options.ignored.some(ignored => ignored.indexOf(word) > -1);
+			return !(options.ignored || []).some(ignored => ignored.indexOf(word) > -1);
 		})
 		.filter(Boolean)
 		.map(verb => {

From aea421b6df34b7d8e9936fb4aa56303a5549f9a4 Mon Sep 17 00:00:00 2001
From: "mario.nebl@sinnerschrader.com" <hello@herebecode.com>
Date: Thu, 6 Jul 2017 12:32:04 +0200
Subject: [PATCH 65/77] chore: fix babel build on win32 platforms

---
 package.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 49fb26a235..98b3220834 100644
--- a/package.json
+++ b/package.json
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "start": "npm run watch",
-    "build": "BABEL_ENV=production babel source --out-dir distribution",
+    "build": "cross-env BABEL_ENV=production babel source --out-dir distribution",
     "watch": "npm run build -- --watch",
     "commit": "git-cz",
     "commitmsg": "npm run build && node distribution/cli.js --edit",
@@ -140,6 +140,7 @@
     "babel-register": "6.24.1",
     "conventional-changelog-cli": "1.2.0",
     "conventional-recommended-bump": "0.3.0",
+    "cross-env": "^5.0.1",
     "cz-conventional-changelog-lint": "0.1.3",
     "denodeify": "1.2.1",
     "dependency-check": "2.7.0",

From da2b6db7a7e7fa02d9ff3c0c0a19e2ab0a64b0bc Mon Sep 17 00:00:00 2001
From: "mario.nebl@sinnerschrader.com" <hello@herebecode.com>
Date: Thu, 6 Jul 2017 12:33:50 +0200
Subject: [PATCH 66/77] test: add test cases for execute-rule

---
 source/library/execute-rule.test.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 source/library/execute-rule.test.js

diff --git a/source/library/execute-rule.test.js b/source/library/execute-rule.test.js
new file mode 100644
index 0000000000..960f6f7b77
--- /dev/null
+++ b/source/library/execute-rule.test.js
@@ -0,0 +1,27 @@
+import test from 'ava';
+import execute from './execute-rule';
+
+test.failing('does nothing without params', async t => {
+	const actual = await execute();
+	t.is(actual, null);
+});
+
+test('returns plain config', async t => {
+	const actual = await execute(['name', 'config']);
+	t.deepEqual(actual, ['name', 'config']);
+});
+
+test('unwraps promised config', async t => {
+	const actual = await execute(['name', Promise.resolve('config')]);
+	t.deepEqual(actual, ['name', 'config']);
+});
+
+test('executes config functions', async t => {
+	const actual = await execute(['name', () => 'config']);
+	t.deepEqual(actual, ['name', 'config']);
+});
+
+test('executes async config functions', async t => {
+	const actual = await execute(['name', async () => 'config']);
+	t.deepEqual(actual, ['name', 'config']);
+});

From 2762921860f67185d5667c5ec64d4c11aff05273 Mon Sep 17 00:00:00 2001
From: "mario.nebl@sinnerschrader.com" <hello@herebecode.com>
Date: Thu, 6 Jul 2017 12:34:29 +0200
Subject: [PATCH 67/77] fix: handle noop calls gracefully

---
 source/library/execute-rule.js      | 3 +++
 source/library/execute-rule.test.js | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/source/library/execute-rule.js b/source/library/execute-rule.js
index 72515c56f7..8d041daca1 100644
--- a/source/library/execute-rule.js
+++ b/source/library/execute-rule.js
@@ -1,4 +1,7 @@
 export default async entry => {
+	if (!Array.isArray(entry)) {
+		return null;
+	}
 	const [name, config] = entry;
 	return typeof config === 'function' ?
 		[name, await config()] :
diff --git a/source/library/execute-rule.test.js b/source/library/execute-rule.test.js
index 960f6f7b77..ffcc80012b 100644
--- a/source/library/execute-rule.test.js
+++ b/source/library/execute-rule.test.js
@@ -1,7 +1,7 @@
 import test from 'ava';
 import execute from './execute-rule';
 
-test.failing('does nothing without params', async t => {
+test('does nothing without params', async t => {
 	const actual = await execute();
 	t.is(actual, null);
 });

From e0719d99d4980db781889d74ee7bf4dae41e7e6e Mon Sep 17 00:00:00 2001
From: "mario.nebl@sinnerschrader.com" <hello@herebecode.com>
Date: Thu, 6 Jul 2017 12:42:56 +0200
Subject: [PATCH 68/77] test: add test cases for get-preset

---
 source/library/get-preset.js      |  2 +-
 source/library/get-preset.test.js | 22 ++++++++++++++++++++++
 2 files changed, 23 insertions(+), 1 deletion(-)
 create mode 100644 source/library/get-preset.test.js

diff --git a/source/library/get-preset.js b/source/library/get-preset.js
index a95cc99786..ac6a4ae30a 100644
--- a/source/library/get-preset.js
+++ b/source/library/get-preset.js
@@ -1,3 +1,3 @@
-export default name => {
+export default (name, require = module.require) => {
 	return require(`conventional-changelog-${name}`);
 };
diff --git a/source/library/get-preset.test.js b/source/library/get-preset.test.js
new file mode 100644
index 0000000000..fc5463e486
--- /dev/null
+++ b/source/library/get-preset.test.js
@@ -0,0 +1,22 @@
+import test from 'ava';
+import getPreset from './get-preset';
+
+function require(id) {
+	if (id !== 'conventional-changelog-existing') {
+		throw new Error(`Module "${id}" not found.`);
+	}
+	return true;
+}
+
+test('throws when called without params', t => {
+	t.throws(() => getPreset(), Error);
+});
+
+test('throws when called for non-existing module', t => {
+	t.throws(() => getPreset('non-existing', require), Error);
+});
+
+test('return module when called for existing module', async t => {
+	const actual = await getPreset('existing', require);
+	t.is(actual, true);
+});

From a9dd020e7758a15d971922c741f66a35427c5b12 Mon Sep 17 00:00:00 2001
From: "mario.nebl@sinnerschrader.com" <hello@herebecode.com>
Date: Thu, 6 Jul 2017 13:30:00 +0200
Subject: [PATCH 69/77] test: add test cases for format

---
 package.json                  |   2 +
 source/library/format.test.js | 148 ++++++++++++++++++++++++++++++++++
 2 files changed, 150 insertions(+)
 create mode 100644 source/library/format.test.js

diff --git a/package.json b/package.json
index 98b3220834..103cd9afd3 100644
--- a/package.json
+++ b/package.json
@@ -129,6 +129,7 @@
   },
   "license": "MIT",
   "devDependencies": {
+    "ansi-styles": "^3.1.0",
     "ava": "0.18.2",
     "babel-cli": "6.18.0",
     "babel-plugin-add-module-exports": "0.2.1",
@@ -147,6 +148,7 @@
     "eslint-plugin-flow-check": "^1.1.1",
     "execa": "0.6.3",
     "globby": "6.1.0",
+    "has-ansi": "^3.0.0",
     "nyc": "10.3.2",
     "path-exists": "3.0.0",
     "rimraf": "^2.6.1",
diff --git a/source/library/format.test.js b/source/library/format.test.js
new file mode 100644
index 0000000000..b1290a35d0
--- /dev/null
+++ b/source/library/format.test.js
@@ -0,0 +1,148 @@
+import test from 'ava';
+import hasAnsi from 'has-ansi';
+import {yellow, red, magenta, blue} from 'ansi-styles';
+import format from './format';
+
+test.failing('does nothing without arguments', t => {
+	const actual = format();
+	t.is(actual, null);
+});
+
+test.failing('does nothing without .errors and .warnings', t => {
+	const actual = format({});
+	t.is(actual, null);
+});
+
+test('returns empty summary of problems for empty .errors and .warnings', t => {
+	const [msg] = format({
+		errors: [],
+		warnings: []
+	});
+
+	t.true(msg.includes('0 problems, 0 warnings'));
+});
+
+test.failing('returns a correct of empty .errors and .warnings', t => {
+	const [err, prob, msg] = format({
+		errors: [
+			{
+				level: 2,
+				name: 'error-name',
+				message: 'There was an error'
+			}
+		],
+		warnings: [
+			{
+				level: 1,
+				name: 'warning-name',
+				message: 'There was a problem'
+			}
+		]
+	});
+
+	t.true(err.includes('There was an error'));
+	t.true(prob.includes('There was a problem'));
+	t.true(msg.includes('1 problems, 1 warnings'));
+});
+
+test.failing('colors messages by default', t => {
+	const [msg] = format({});
+	t.true(hasAnsi(msg));
+});
+
+test.failing('does not color messages if configured', t => {
+	const [msg] = format({}, {color: false});
+	t.false(hasAnsi(msg));
+});
+
+test.failing('uses appropriate signs by default', t => {
+	const [err, warn] = format({
+		errors: [
+			{
+				level: 2,
+				name: 'error-name',
+				message: 'There was an error'
+			}
+		],
+		warnings: [
+			{
+				level: 1,
+				name: 'warning-name',
+				message: 'There was a problem'
+			}
+		]
+	});
+
+	t.true(err.includes('✖'));
+	t.true(warn.includes('⚠'));
+});
+
+test.failing('uses signs as configured', t => {
+	const [err, warn] = format({
+		errors: [
+			{
+				level: 2,
+				name: 'error-name',
+				message: 'There was an error'
+			}
+		],
+		warnings: [
+			{
+				level: 1,
+				name: 'warning-name',
+				message: 'There was a problem'
+			}
+		]
+	}, {
+		signs: ['HNT', 'WRN', 'ERR']
+	});
+
+	t.true(err.includes('ERR'));
+	t.true(warn.includes('WRN'));
+});
+
+test.failing('uses appropriate colors by default', t => {
+	const [err, warn] = format({
+		errors: [
+			{
+				level: 2,
+				name: 'error-name',
+				message: 'There was an error'
+			}
+		],
+		warnings: [
+			{
+				level: 1,
+				name: 'warning-name',
+				message: 'There was a problem'
+			}
+		]
+	});
+
+	t.true(err.includes(red.open));
+	t.true(warn.includes(yellow.open));
+});
+
+test.failing('uses colors as configured', t => {
+	const [err, warn] = format({
+		errors: [
+			{
+				level: 2,
+				name: 'error-name',
+				message: 'There was an error'
+			}
+		],
+		warnings: [
+			{
+				level: 1,
+				name: 'warning-name',
+				message: 'There was a problem'
+			}
+		]
+	}, {
+		colors: ['white', 'magenta', 'blue']
+	});
+
+	t.true(err.includes(blue.open));
+	t.true(warn.includes(magenta.open));
+});

From b3f2ca5ee9d131f61c8c40e584012aea442148a6 Mon Sep 17 00:00:00 2001
From: "mario.nebl@sinnerschrader.com" <hello@herebecode.com>
Date: Thu, 6 Jul 2017 17:10:57 +0200
Subject: [PATCH 70/77] fix: more solid formatter implementation

---
 source/cli.js                 |  8 ++----
 source/library/format.js      | 48 ++++++++++++++++++++---------------
 source/library/format.test.js | 30 +++++++++++++---------
 3 files changed, 48 insertions(+), 38 deletions(-)

diff --git a/source/cli.js b/source/cli.js
index 773bdd22f3..71437c97b9 100644
--- a/source/cli.js
+++ b/source/cli.js
@@ -36,7 +36,7 @@ const configuration = {
 		x: 'extends'
 	},
 	description: {
-		color: 'toggle formatted output',
+		color: 'toggle colored 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',
@@ -94,11 +94,7 @@ async function main(options) {
 				)
 			});
 
-			const formatted = format(report, {
-				color: flags.color,
-				signs: [' ', '⚠', '✖'],
-				colors: ['white', 'yellow', 'red']
-			});
+			const formatted = format(report, {color: flags.color});
 
 			if (!flags.quiet) {
 				console.log(`${fmt.grey('⧗')}   input: ${fmt.bold(commit.split('\n')[0])}`);
diff --git a/source/library/format.js b/source/library/format.js
index 742a65951e..c8da5c6a7c 100644
--- a/source/library/format.js
+++ b/source/library/format.js
@@ -1,31 +1,39 @@
 import chalk from 'chalk';
 
-export default function format(report, options = {}) {
-	const {signs, colors, color: enabled} = options;
-	const fmt = new chalk.constructor({enabled});
+const DEFAULT_SIGNS = [' ', '⚠', '✖'];
+const DEFAULT_COLORS = ['white', 'yellow', 'red'];
 
-	const problems = [...report.errors, ...report.warnings]
+export default function format(report = {}, options = {}) {
+	const {signs = DEFAULT_SIGNS, colors = DEFAULT_COLORS, color: enabled = true} = options;
+	const {errors = [], warnings = []} = report;
+
+	const problems = [...errors, ...warnings]
 		.map(problem => {
-			const sign = signs[problem.level];
-			const color = colors[problem.level];
-			const decoration = fmt[color](sign);
+			const sign = signs[problem.level] || '';
+			const color = colors[problem.level] || 'white';
+			const decoration = enabled ? chalk[color](sign) : sign;
 			const name = chalk.grey(`[${problem.name}]`);
 			return `${decoration}   ${problem.message} ${name}`;
 		});
 
-	const sign = report.errors.length ? // eslint-disable-line no-nested-ternary
-		'✖' :
-		report.warnings.length ?
-		'⚠' :
-		'✔';
+	const sign = selectSign({errors, warnings});
+	const color = selectColor({errors, warnings});
+
+	const decoration = enabled ? chalk[color](sign) : sign;
+	const summary = `${decoration}   found ${errors.length} problems, ${warnings.length} warnings`;
+	return [...problems, enabled ? chalk.bold(summary) : summary];
+}
 
-	const color = report.errors.length ? // eslint-disable-line no-nested-ternary
-		'red' :
-		report.warnings.length ?
-		'yellow' :
-		'green';
+function selectSign(report) {
+	if (report.errors.length > 0) {
+		return '✖';
+	}
+	return report.warnings.length ? '⚠' : '✔';
+}
 
-	const decoration = fmt[color](sign);
-	const summary = `${decoration}   found ${report.errors.length} problems, ${report.warnings.length} warnings`;
-	return [...problems, chalk.bold(summary)];
+function selectColor(report) {
+	if (report.errors.length > 0) {
+		return 'red';
+	}
+	return report.warnings.length ? 'yellow' : 'green';
 }
diff --git a/source/library/format.test.js b/source/library/format.test.js
index b1290a35d0..4df1a5fc8f 100644
--- a/source/library/format.test.js
+++ b/source/library/format.test.js
@@ -1,16 +1,19 @@
 import test from 'ava';
 import hasAnsi from 'has-ansi';
+import chalk from 'chalk';
 import {yellow, red, magenta, blue} from 'ansi-styles';
 import format from './format';
 
-test.failing('does nothing without arguments', t => {
+const ok = chalk.bold(`${chalk.green('✔')}   found 0 problems, 0 warnings`);
+
+test('does nothing without arguments', t => {
 	const actual = format();
-	t.is(actual, null);
+	t.deepEqual(actual, [ok]);
 });
 
-test.failing('does nothing without .errors and .warnings', t => {
+test('does nothing without .errors and .warnings', t => {
 	const actual = format({});
-	t.is(actual, null);
+	t.deepEqual(actual, [ok]);
 });
 
 test('returns empty summary of problems for empty .errors and .warnings', t => {
@@ -22,7 +25,7 @@ test('returns empty summary of problems for empty .errors and .warnings', t => {
 	t.true(msg.includes('0 problems, 0 warnings'));
 });
 
-test.failing('returns a correct of empty .errors and .warnings', t => {
+test('returns a correct of empty .errors and .warnings', t => {
 	const [err, prob, msg] = format({
 		errors: [
 			{
@@ -45,17 +48,20 @@ test.failing('returns a correct of empty .errors and .warnings', t => {
 	t.true(msg.includes('1 problems, 1 warnings'));
 });
 
-test.failing('colors messages by default', t => {
-	const [msg] = format({});
+test('colors messages by default', t => {
+	const [msg] = format({
+		errors: [],
+		warnings: []
+	});
 	t.true(hasAnsi(msg));
 });
 
-test.failing('does not color messages if configured', t => {
+test('does not color messages if configured', t => {
 	const [msg] = format({}, {color: false});
 	t.false(hasAnsi(msg));
 });
 
-test.failing('uses appropriate signs by default', t => {
+test('uses appropriate signs by default', t => {
 	const [err, warn] = format({
 		errors: [
 			{
@@ -77,7 +83,7 @@ test.failing('uses appropriate signs by default', t => {
 	t.true(warn.includes('⚠'));
 });
 
-test.failing('uses signs as configured', t => {
+test('uses signs as configured', t => {
 	const [err, warn] = format({
 		errors: [
 			{
@@ -101,7 +107,7 @@ test.failing('uses signs as configured', t => {
 	t.true(warn.includes('WRN'));
 });
 
-test.failing('uses appropriate colors by default', t => {
+test('uses appropriate colors by default', t => {
 	const [err, warn] = format({
 		errors: [
 			{
@@ -123,7 +129,7 @@ test.failing('uses appropriate colors by default', t => {
 	t.true(warn.includes(yellow.open));
 });
 
-test.failing('uses colors as configured', t => {
+test('uses colors as configured', t => {
 	const [err, warn] = format({
 		errors: [
 			{

From 0c6e27577544b66b40fb9005dca41c21f984279b Mon Sep 17 00:00:00 2001
From: "mario.nebl@sinnerschrader.com" <hello@herebecode.com>
Date: Thu, 6 Jul 2017 18:04:33 +0200
Subject: [PATCH 71/77] test: add shell tests for parse method

---
 source/library/parse.js      |  4 ++--
 source/library/parse.test.js | 35 +++++++++++++++++++++++++++++++++++
 2 files changed, 37 insertions(+), 2 deletions(-)
 create mode 100644 source/library/parse.test.js

diff --git a/source/library/parse.js b/source/library/parse.js
index 74935d4a7b..af3c48db54 100644
--- a/source/library/parse.js
+++ b/source/library/parse.js
@@ -2,8 +2,8 @@ import {sync} from 'conventional-commits-parser';
 
 export default parse;
 
-function parse(message, options) {
-	const parsed = sync(message, options);
+function parse(message, options, parser = sync) {
+	const parsed = parser(message, options);
 	parsed.raw = message;
 	return parsed;
 }
diff --git a/source/library/parse.test.js b/source/library/parse.test.js
new file mode 100644
index 0000000000..d312ed1776
--- /dev/null
+++ b/source/library/parse.test.js
@@ -0,0 +1,35 @@
+import test from 'ava';
+import parse from './parse';
+
+test('throws when called without params', t => {
+	t.throws(() => parse(), /Expected a raw commit/);
+});
+
+test('throws when called with empty message', t => {
+	t.throws(() => parse(''), /Expected a raw commit/);
+});
+
+test('returns object with raw message', t => {
+	const message = 'type(scope): subject';
+	const actual = 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) => {
+		t.is(message, m);
+		t.is(options, o);
+		return {};
+	});
+});
+
+test('passes object up from parser function', t => {
+	const message = 'message';
+	const options = {};
+	const result = {};
+	const actual = parse(message, options, () => result);
+	t.is(actual, result);
+});

From b80fcf6ad9eb1cecb59db914953f2cb9f75795d4 Mon Sep 17 00:00:00 2001
From: "mario.nebl@sinnerschrader.com" <hello@herebecode.com>
Date: Fri, 7 Jul 2017 11:15:19 +0200
Subject: [PATCH 72/77] fix: solidify and test resolve-extends

---
 package.json                           |   2 +
 source/library/resolve-extends.js      |  31 ++---
 source/library/resolve-extends.test.js | 150 +++++++++++++++++++++++++
 3 files changed, 170 insertions(+), 13 deletions(-)
 create mode 100644 source/library/resolve-extends.test.js

diff --git a/package.json b/package.json
index 103cd9afd3..607f59df17 100644
--- a/package.json
+++ b/package.json
@@ -149,8 +149,10 @@
     "execa": "0.6.3",
     "globby": "6.1.0",
     "has-ansi": "^3.0.0",
+    "import-from": "^2.1.0",
     "nyc": "10.3.2",
     "path-exists": "3.0.0",
+    "resolve-from": "^3.0.0",
     "rimraf": "^2.6.1",
     "xo": "^0.18.2"
   },
diff --git a/source/library/resolve-extends.js b/source/library/resolve-extends.js
index a10000ded2..bb9d6ce551 100644
--- a/source/library/resolve-extends.js
+++ b/source/library/resolve-extends.js
@@ -1,16 +1,21 @@
-import {merge} from 'lodash';
+import importFrom from 'import-from';
+import {merge, omit} from 'lodash';
+
+const cwd = importFrom.bind(null, process.cwd());
 
 // Resolve extend configs
-export default function resolveExtends(config, prefix = '', key = 'extends') {
-	return Object.values(config[key] || [])
-		.reduce((merged, extender) => {
-			const name = [prefix, extender]
-				.filter(String)
-				.join('-');
-			return merge(
-				{},
-				merged,
-				resolveExtends(require(name))
-			);
-		}, config);
+export default function resolveExtends(config = {}, prefix = '', key = 'extends', require = cwd) {
+	const extended = loadExtends(config, prefix, key, require)
+		.reduceRight((r, c) => merge(r, omit(c, [key])), config[key] ? {[key]: config[key]} : {});
+	return merge({}, extended, config);
+}
+
+// (any, string, string, Function) => any[];
+function loadExtends(config = {}, prefix = '', key = 'extends', require = cwd) {
+	const toExtend = Object.values(config[key] || []);
+	return toExtend.reduce((configs, raw) => {
+		const id = [prefix, raw].filter(String).join('-');
+		const c = require(id);
+		return [...configs, c, ...loadExtends(c, prefix, key, require)];
+	}, []);
 }
diff --git a/source/library/resolve-extends.test.js b/source/library/resolve-extends.test.js
new file mode 100644
index 0000000000..097de1e66a
--- /dev/null
+++ b/source/library/resolve-extends.test.js
@@ -0,0 +1,150 @@
+import test from 'ava';
+import resolveExtends from './resolve-extends';
+
+const _ = undefined;
+
+test('returns empty object when called without params', t => {
+	const actual = resolveExtends();
+	t.deepEqual(actual, {});
+});
+
+test('returns an equivalent object as passed in', t => {
+	const expected = {foo: 'bar'};
+	const actual = resolveExtends(expected);
+	t.deepEqual(actual, expected);
+});
+
+test('uses empty prefix by default', t => {
+	const input = {extends: ['extender-name']};
+
+	resolveExtends(input, _, _, id => {
+		t.is(id, 'extender-name');
+	});
+});
+
+test('uses prefix as configured', t => {
+	const input = {extends: ['extender-name']};
+
+	resolveExtends(input, 'prefix', _, id => {
+		t.is(id, 'prefix-extender-name');
+	});
+});
+
+test('uses extends key as configured', t => {
+	const input = {inherit: ['extender-name'], extends: ['fails']};
+
+	resolveExtends(input, _, 'inherit', id => {
+		t.is(id, 'extender-name');
+	});
+});
+
+test('propagates return value of require function', t => {
+	const input = {extends: ['extender-name']};
+	const propagated = {foo: 'bar'};
+
+	const actual = resolveExtends(input, _, _, () => {
+		return propagated;
+	});
+
+	console.log({actual});
+
+	t.is(actual.foo, 'bar');
+});
+
+test('resolves extends recursively', t => {
+	const input = {extends: ['extender-name']};
+	const actual = [];
+
+	resolveExtends(input, _, _, id => {
+		actual.push(id);
+		if (id === 'extender-name') {
+			return {extends: ['recursive-extender-name']};
+		}
+		if (id === 'recursive-extender-name') {
+			return {foo: 'bar'};
+		}
+	});
+
+	t.deepEqual(actual, ['extender-name', 'recursive-extender-name']);
+});
+
+test('uses prefix key recursively', t => {
+	const input = {extends: ['extender-name']};
+	const actual = [];
+
+	resolveExtends(input, 'prefix', _, id => {
+		actual.push(id);
+		if (id === 'prefix-extender-name') {
+			return {extends: ['recursive-extender-name']};
+		}
+		if (id === 'prefix-recursive-extender-name') {
+			return {foo: 'bar'};
+		}
+	});
+
+	t.deepEqual(actual, ['prefix-extender-name', 'prefix-recursive-extender-name']);
+});
+
+test('uses extends key recursively', t => {
+	const input = {inherit: ['extender-name']};
+	const actual = [];
+
+	resolveExtends(input, _, 'inherit', id => {
+		actual.push(id);
+		if (id === 'extender-name') {
+			return {inherit: ['recursive-extender-name']};
+		}
+		if (id === 'recursive-extender-name') {
+			return {foo: 'bar'};
+		}
+	});
+
+	t.deepEqual(actual, ['extender-name', 'recursive-extender-name']);
+});
+
+test('propagates contents recursively', t => {
+	const input = {extends: ['extender-name']};
+
+	const actual = resolveExtends(input, _, _, id => {
+		if (id === 'extender-name') {
+			return {extends: ['recursive-extender-name'], foo: 'bar'};
+		}
+		if (id === 'recursive-extender-name') {
+			return {baz: 'bar'};
+		}
+	});
+
+	const expected = {
+		extends: ['extender-name'],
+		foo: 'bar',
+		baz: 'bar'
+	};
+
+	t.deepEqual(actual, expected);
+});
+
+test('extending contents should take precedence', t => {
+	const input = {extends: ['extender-name'], zero: 'root'};
+
+	const actual = resolveExtends(input, _, _, id => {
+		if (id === 'extender-name') {
+			return {extends: ['recursive-extender-name'], zero: id, one: id};
+		}
+		if (id === 'recursive-extender-name') {
+			return {extends: ['second-recursive-extender-name'], zero: id, one: id, two: id};
+		}
+		if (id === 'second-recursive-extender-name') {
+			return {zero: id, one: id, two: id, three: id};
+		}
+	});
+
+	const expected = {
+		extends: ['extender-name'],
+		zero: 'root',
+		one: 'extender-name',
+		two: 'recursive-extender-name',
+		three: 'second-recursive-extender-name'
+	};
+
+	t.deepEqual(actual, expected);
+});

From 2695c4e1c15c42c4519a61af9043e7b32749b82d Mon Sep 17 00:00:00 2001
From: "mario.nebl@sinnerschrader.com" <hello@herebecode.com>
Date: Fri, 7 Jul 2017 11:20:45 +0200
Subject: [PATCH 73/77] test: execute color format test only if supported

---
 package.json                  |  1 +
 source/library/format.test.js | 47 +++++++++++++++++++----------------
 2 files changed, 26 insertions(+), 22 deletions(-)

diff --git a/package.json b/package.json
index 607f59df17..40075ac5ff 100644
--- a/package.json
+++ b/package.json
@@ -154,6 +154,7 @@
     "path-exists": "3.0.0",
     "resolve-from": "^3.0.0",
     "rimraf": "^2.6.1",
+    "supports-color": "^4.2.0",
     "xo": "^0.18.2"
   },
   "dependencies": {
diff --git a/source/library/format.test.js b/source/library/format.test.js
index 4df1a5fc8f..4e296b4d14 100644
--- a/source/library/format.test.js
+++ b/source/library/format.test.js
@@ -1,4 +1,5 @@
 import test from 'ava';
+import supportsColor from 'supports-color';
 import hasAnsi from 'has-ansi';
 import chalk from 'chalk';
 import {yellow, red, magenta, blue} from 'ansi-styles';
@@ -129,26 +130,28 @@ test('uses appropriate colors by default', t => {
 	t.true(warn.includes(yellow.open));
 });
 
-test('uses colors as configured', t => {
-	const [err, warn] = format({
-		errors: [
-			{
-				level: 2,
-				name: 'error-name',
-				message: 'There was an error'
-			}
-		],
-		warnings: [
-			{
-				level: 1,
-				name: 'warning-name',
-				message: 'There was a problem'
-			}
-		]
-	}, {
-		colors: ['white', 'magenta', 'blue']
+if (supportsColor) {
+	test('uses colors as configured', t => {
+		const [err, warn] = format({
+			errors: [
+				{
+					level: 2,
+					name: 'error-name',
+					message: 'There was an error'
+				}
+			],
+			warnings: [
+				{
+					level: 1,
+					name: 'warning-name',
+					message: 'There was a problem'
+				}
+			]
+		}, {
+			colors: ['white', 'magenta', 'blue']
+		});
+
+		t.true(err.includes(blue.open));
+		t.true(warn.includes(magenta.open));
 	});
-
-	t.true(err.includes(blue.open));
-	t.true(warn.includes(magenta.open));
-});
+}

From 7fb4b3a5e8e3330122fae3371ff250536fe9d7f0 Mon Sep 17 00:00:00 2001
From: "mario.nebl@sinnerschrader.com" <hello@herebecode.com>
Date: Fri, 7 Jul 2017 11:28:04 +0200
Subject: [PATCH 74/77] fix: harmonize dynamic importers

---
 source/library/get-preset.js | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/source/library/get-preset.js b/source/library/get-preset.js
index ac6a4ae30a..a356f4ed06 100644
--- a/source/library/get-preset.js
+++ b/source/library/get-preset.js
@@ -1,3 +1,7 @@
-export default (name, require = module.require) => {
+import importFrom from 'import-from';
+
+const cwd = importFrom.bind(null, process.cwd());
+
+export default (name, require = cwd) => {
 	return require(`conventional-changelog-${name}`);
 };

From 7d04993e11f10e117f8d504264876ecd1e353337 Mon Sep 17 00:00:00 2001
From: "mario.nebl@sinnerschrader.com" <hello@herebecode.com>
Date: Fri, 7 Jul 2017 11:32:01 +0200
Subject: [PATCH 75/77] chore: cleanup

---
 package.json                  | 17 ++++++++---------
 source/library/format.test.js |  3 +--
 2 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/package.json b/package.json
index 40075ac5ff..78acf98cd5 100644
--- a/package.json
+++ b/package.json
@@ -129,7 +129,7 @@
   },
   "license": "MIT",
   "devDependencies": {
-    "ansi-styles": "^3.1.0",
+    "ansi-styles": "3.1.0",
     "ava": "0.18.2",
     "babel-cli": "6.18.0",
     "babel-plugin-add-module-exports": "0.2.1",
@@ -141,21 +141,20 @@
     "babel-register": "6.24.1",
     "conventional-changelog-cli": "1.2.0",
     "conventional-recommended-bump": "0.3.0",
-    "cross-env": "^5.0.1",
+    "cross-env": "5.0.1",
     "cz-conventional-changelog-lint": "0.1.3",
     "denodeify": "1.2.1",
     "dependency-check": "2.7.0",
-    "eslint-plugin-flow-check": "^1.1.1",
+    "eslint-plugin-flow-check": "1.1.1",
     "execa": "0.6.3",
     "globby": "6.1.0",
-    "has-ansi": "^3.0.0",
-    "import-from": "^2.1.0",
+    "has-ansi": "3.0.0",
+    "import-from": "2.1.0",
     "nyc": "10.3.2",
     "path-exists": "3.0.0",
-    "resolve-from": "^3.0.0",
-    "rimraf": "^2.6.1",
-    "supports-color": "^4.2.0",
-    "xo": "^0.18.2"
+    "resolve-from": "3.0.0",
+    "rimraf": "2.6.1",
+    "xo": "0.18.2"
   },
   "dependencies": {
     "babel-polyfill": "6.20.0",
diff --git a/source/library/format.test.js b/source/library/format.test.js
index 4e296b4d14..667b422fa6 100644
--- a/source/library/format.test.js
+++ b/source/library/format.test.js
@@ -1,5 +1,4 @@
 import test from 'ava';
-import supportsColor from 'supports-color';
 import hasAnsi from 'has-ansi';
 import chalk from 'chalk';
 import {yellow, red, magenta, blue} from 'ansi-styles';
@@ -130,7 +129,7 @@ test('uses appropriate colors by default', t => {
 	t.true(warn.includes(yellow.open));
 });
 
-if (supportsColor) {
+if (process.platform !== 'win32') {
 	test('uses colors as configured', t => {
 		const [err, warn] = format({
 			errors: [

From f4c9368178d8a7fad508cca10f71c097833b51b9 Mon Sep 17 00:00:00 2001
From: "mario.nebl@sinnerschrader.com" <hello@herebecode.com>
Date: Fri, 7 Jul 2017 13:38:30 +0200
Subject: [PATCH 76/77] chore: do not babel test files

---
 package.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/package.json b/package.json
index 78acf98cd5..58769ac7d1 100644
--- a/package.json
+++ b/package.json
@@ -45,6 +45,7 @@
     ]
   },
   "babel": {
+    "ignore": ["**/*.test.js"],
     "env": {
       "development": {
         "sourceMaps": "inline",

From 8136c14213262dd2e0fd85b2909ab39a886acbd7 Mon Sep 17 00:00:00 2001
From: "mario.nebl@sinnerschrader.com" <hello@herebecode.com>
Date: Fri, 7 Jul 2017 13:48:42 +0200
Subject: [PATCH 77/77] chore: ignore *.test only for prod builds

---
 package.json                           | 4 +++-
 source/library/resolve-extends.test.js | 2 --
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/package.json b/package.json
index 58769ac7d1..b3cf575ac9 100644
--- a/package.json
+++ b/package.json
@@ -45,7 +45,6 @@
     ]
   },
   "babel": {
-    "ignore": ["**/*.test.js"],
     "env": {
       "development": {
         "sourceMaps": "inline",
@@ -60,6 +59,9 @@
             }
           ]
         ]
+      },
+      "production": {
+        "ignore": ["**/*.test.js"]
       }
     },
     "presets": [
diff --git a/source/library/resolve-extends.test.js b/source/library/resolve-extends.test.js
index 097de1e66a..bc7b51bd40 100644
--- a/source/library/resolve-extends.test.js
+++ b/source/library/resolve-extends.test.js
@@ -46,8 +46,6 @@ test('propagates return value of require function', t => {
 		return propagated;
 	});
 
-	console.log({actual});
-
 	t.is(actual.foo, 'bar');
 });