refactor(rules): port next batch of rules to ts

Author: byCedric

@commitlint/rules/src/body-case.ts

@@ -2,7 +2,11 @@ import * as ensure from '@commitlint/ensure';
 import message from '@commitlint/message';
 import {Rule} from './types';
 
-const bodyCase: Rule<ensure.TargetCaseType> = (parsed, when, value) => {
+const bodyCase: Rule<ensure.TargetCaseType> = (
+	parsed,
+	when = 'always',
+	value = undefined
+) => {
 	const {body} = parsed;
 
 	if (!body) {

@commitlint/rules/src/body-empty.ts

@@ -2,7 +2,7 @@ import * as ensure from '@commitlint/ensure';
 import message from '@commitlint/message';
 import {Rule} from './types';
 
-const bodyEmpty: Rule = (parsed, when) => {
+const bodyEmpty: Rule = (parsed, when = 'always') => {
 	const negated = when === 'never';
 	const notEmpty = ensure.notEmpty(parsed.body || '');
 

@commitlint/rules/src/body-leading-blank.ts

@@ -2,7 +2,7 @@ import toLines from '@commitlint/to-lines';
 import message from '@commitlint/message';
 import {Rule} from './types';
 
-const bodyLeadingBlank: Rule = (parsed, when) => {
+const bodyLeadingBlank: Rule = (parsed, when = 'always') => {
 	// Flunk if no body is found
 	if (!parsed.body) {
 		return [true];

@commitlint/rules/src/body-max-length.ts

@@ -1,10 +1,10 @@
 import {maxLength} from '@commitlint/ensure';
 import {Rule} from './types';
 
-const bodyMaxLength: Rule<number> = (parsed, when, value) => {
+const bodyMaxLength: Rule<number> = (parsed, when = 'always', value = 0) => {
 	const input = parsed.body;
 
-	if (!input || value == undefined) {
+	if (!input) {
 		return [true];
 	}
 

@commitlint/rules/src/body-max-line-length.ts

@@ -1,10 +1,14 @@
 import {maxLineLength} from '@commitlint/ensure';
 import {Rule} from './types';
 
-const bodyMaxLineLength: Rule<number> = (parsed, when, value) => {
+const bodyMaxLineLength: Rule<number> = (
+	parsed,
+	when = 'always',
+	value = 0
+) => {
 	const input = parsed.body;
 
-	if (!input || value === undefined) {
+	if (!input) {
 		return [true];
 	}
 

@commitlint/rules/src/body-min-length.test.js

@@ -0,0 +1,34 @@
+import parse from '@commitlint/parse';
+import check from './body-min-length';
+
+const short = 'a';
+const long = 'ab';
+
+const value = long.length;
+
+const messages = {
+	simple: 'test: subject',
+	short: `test: subject\n${short}`,
+	long: `test: subject\n${long}`
+};
+
+const parsed = {
+	simple: parse(messages.simple),
+	short: parse(messages.short),
+	long: parse(messages.long)
+};
+
+test('with simple should succeed', async () => {
+	const [actual] = check(await parsed.simple, 'always', value);
+	expect(actual).toBeTruthy();
+});
+
+test('with short should fail', async () => {
+	const [actual] = check(await parsed.short, 'always', value);
+	expect(actual).toBeFalsy();
+});
+
+test('with long should succeed', async () => {
+	const [actual] = check(await parsed.long, 'always', value);
+	expect(actual).toBeTruthy();
+});

@commitlint/rules/src/body-min-length.test.ts

@@ -1,6 +1,7 @@
 import {minLength} from '@commitlint/ensure';
+import {Rule} from './types';
 
-export default (parsed, when, value) => {
+const bodyMinLength: Rule<number> = (parsed, when = 'always', value = 0) => {
 	if (!parsed.body) {
 		return [true];
 	}
@@ -10,3 +11,5 @@ export default (parsed, when, value) => {
 		`body must not be shorter than ${value} characters`
 	];
 };
+
+export default bodyMinLength;

@commitlint/rules/src/body-min-length.js renamed to @commitlint/rules/src/body-min-length.ts

@@ -1,4 +1,3 @@
-import test from 'ava';
 import parse from '@commitlint/parse';
 import footerEmpty from './footer-empty';
 
@@ -14,56 +13,47 @@ const parsed = {
 	filled: parse(messages.filled)
 };
 
-test('with simple message should succeed for empty keyword', async t => {
+test('with simple message should succeed for empty keyword', async () => {
 	const [actual] = footerEmpty(await parsed.simple);
-	const expected = true;
-	t.is(actual, expected);
+	expect(actual).toBeTruthy();
 });
 
-test('with simple message should fail for "never"', async t => {
+test('with simple message should fail for "never"', async () => {
 	const [actual] = footerEmpty(await parsed.simple, 'never');
-	const expected = false;
-	t.is(actual, expected);
+	expect(actual).toBeFalsy();
 });
 
-test('with simple message should succeed for "always"', async t => {
+test('with simple message should succeed for "always"', async () => {
 	const [actual] = footerEmpty(await parsed.simple, 'always');
-	const expected = true;
-	t.is(actual, expected);
+	expect(actual).toBeTruthy();
 });
 
-test('with empty footer should succeed for empty keyword', async t => {
+test('with empty footer should succeed for empty keyword', async () => {
 	const [actual] = footerEmpty(await parsed.empty);
-	const expected = true;
-	t.is(actual, expected);
+	expect(actual).toBeTruthy();
 });
 
-test('with empty footer should fail for "never"', async t => {
+test('with empty footer should fail for "never"', async () => {
 	const [actual] = footerEmpty(await parsed.empty, 'never');
-	const expected = false;
-	t.is(actual, expected);
+	expect(actual).toBeFalsy();
 });
 
-test('with empty footer should succeed for "always"', async t => {
+test('with empty footer should succeed for "always"', async () => {
 	const [actual] = footerEmpty(await parsed.empty, 'always');
-	const expected = true;
-	t.is(actual, expected);
+	expect(actual).toBeTruthy();
 });
 
-test('with footer should fail for empty keyword', async t => {
+test('with footer should fail for empty keyword', async () => {
 	const [actual] = footerEmpty(await parsed.filled);
-	const expected = false;
-	t.is(actual, expected);
+	expect(actual).toBeFalsy();
 });
 
-test('with footer should succeed for "never"', async t => {
+test('with footer should succeed for "never"', async () => {
 	const [actual] = footerEmpty(await parsed.filled, 'never');
-	const expected = true;
-	t.is(actual, expected);
+	expect(actual).toBeTruthy();
 });
 
-test('with footer should fail for "always"', async t => {
+test('with footer should fail for "always"', async () => {
 	const [actual] = footerEmpty(await parsed.filled, 'always');
-	const expected = false;
-	t.is(actual, expected);
+	expect(actual).toBeFalsy();
 });

@commitlint/rules/src/footer-empty.test.js renamed to @commitlint/rules/src/footer-empty.test.ts

@@ -1,12 +1,15 @@
 import * as ensure from '@commitlint/ensure';
 import message from '@commitlint/message';
+import {Rule} from './types';
 
-export default (parsed, when) => {
+const footerEmpty: Rule = (parsed, when = 'always') => {
 	const negated = when === 'never';
-	const notEmpty = ensure.notEmpty(parsed.footer);
+	const notEmpty = ensure.notEmpty(parsed.footer || '');
 
 	return [
 		negated ? notEmpty : !notEmpty,
 		message(['footer', negated ? 'may not' : 'must', 'be empty'])
 	];
 };
+
+export default footerEmpty;