feat(core): add kebab-case, camelCase, PascalCase options

.gitignore

@@ -1,3 +1,4 @@
+.idea/
 npm-debug.log*
 lerna-debug.log
 node_modules

@commitlint/core/src/library/ensure-case.js

@@ -1,11 +1,25 @@
+import {camelCase, kebabCase, snakeCase, upperFirst, startCase} from 'lodash';
+
 export default (raw = '', target = 'lowercase') => {
-	const normalized = String(raw);
+	const input = String(raw);
 
 	switch (target) {
+		case 'camel-case':
+			return camelCase(input) === input;
+		case 'kebab-case':
+			return kebabCase(input) === input;
+		case 'snake-case':
+			return snakeCase(input) === input;
+		case 'pascal-case':
+			return upperFirst(camelCase(input)) === input;
+		case 'start-case':
+			return startCase(input) === input;
+		case 'upper-case':
 		case 'uppercase':
-			return normalized.toUpperCase() === normalized;
+			return input.toUpperCase() === input;
+		case 'lower-case':
 		case 'lowercase':
 		default:
-			return normalized.toLowerCase() === normalized;
+			return input.toLowerCase() === input;
 	}
 };

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

@@ -6,14 +6,24 @@ const messages = {
 	empty: 'chore: subject',
 	lowercase: 'chore(scope): subject',
 	mixedcase: 'chore(sCoPe): subject',
-	uppercase: 'chore(SCOPE): subject'
+	uppercase: 'chore(SCOPE): subject',
+	camelcase: 'chore(myScope): subject',
+	kebabcase: 'chore(my-scope): subject',
+	pascalcase: 'chore(MyScope): subject',
+	snakecase: 'chore(my_scope): subject',
+	startcase: 'chore(My Scope): subject'
 };
 
 const parsed = {
 	empty: parse(messages.empty),
 	lowercase: parse(messages.lowercase),
 	mixedcase: parse(messages.mixedcase),
-	uppercase: parse(messages.uppercase)
+	uppercase: parse(messages.uppercase),
+	camelcase: parse(messages.camelcase),
+	kebabcase: parse(messages.kebabcase),
+	pascalcase: parse(messages.pascalcase),
+	snakecase: parse(messages.snakecase),
+	startcase: parse(messages.startcase)
 };
 
 test('with empty scope should succeed for "never lowercase"', async t => {
@@ -40,6 +50,66 @@ test('with empty scope should succeed for "always uppercase"', async t => {
 	t.is(actual, expected);
 });
 
+test('with empty scope should succeed for "never camelcase"', async t => {
+	const [actual] = scopeCase(await parsed.empty, 'never', 'camel-case');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with empty scope should succeed for "always camelcase"', async t => {
+	const [actual] = scopeCase(await parsed.empty, 'never', 'camel-case');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with empty scope should succeed for "never kebabcase"', async t => {
+	const [actual] = scopeCase(await parsed.empty, 'never', 'kebab-case');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with empty scope should succeed for "always kebabcase"', async t => {
+	const [actual] = scopeCase(await parsed.empty, 'never', 'kebab-case');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with empty scope should succeed for "never pascalcase"', async t => {
+	const [actual] = scopeCase(await parsed.empty, 'never', 'pascal-case');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with empty scope should succeed for "always pascalcase"', async t => {
+	const [actual] = scopeCase(await parsed.empty, 'never', 'pascal-case');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with empty scope should succeed for "never snakecase"', async t => {
+	const [actual] = scopeCase(await parsed.empty, 'never', 'snake-case');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with empty scope should succeed for "always snakecase"', async t => {
+	const [actual] = scopeCase(await parsed.empty, 'never', 'snake-case');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with empty scope should succeed for "never startcase"', async t => {
+	const [actual] = scopeCase(await parsed.empty, 'never', 'start-case');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with empty scope should succeed for "always startcase"', async t => {
+	const [actual] = scopeCase(await parsed.empty, 'never', 'start-case');
+	const expected = true;
+	t.is(actual, expected);
+});
+
 test('with lowercase scope should fail for "never lowercase"', async t => {
 	const [actual] = scopeCase(await parsed.lowercase, 'never', 'lowercase');
 	const expected = false;
@@ -70,6 +140,106 @@ test('with mixedcase scope should succeed for "never uppercase"', async t => {
 	t.is(actual, expected);
 });
 
+test('with kebabcase scope should succeed for "always lowercase"', async t => {
+	const [actual] = scopeCase(await parsed.kebabcase, 'always', 'lowercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with kebabcase scope should fail for "always camelcase"', async t => {
+	const [actual] = scopeCase(await parsed.kebabcase, 'always', 'camel-case');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with kebabcase scope should fail for "always pascalcase"', async t => {
+	const [actual] = scopeCase(await parsed.kebabcase, 'always', 'pascal-case');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with kebabcase scope should succeed for "always kebabcase"', async t => {
+	const [actual] = scopeCase(
+		await parsed.kebabcase,
+		'always',
+		'kebabcase-case'
+	);
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with snakecase scope should succeed for "always lowercase"', async t => {
+	const [actual] = scopeCase(await parsed.snakecase, 'always', 'lowercase');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with snakecase scope should fail for "always camelcase"', async t => {
+	const [actual] = scopeCase(await parsed.snakecase, 'always', 'camel-case');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with snakecase scope should fail for "always pascalcase"', async t => {
+	const [actual] = scopeCase(await parsed.snakecase, 'always', 'pascal-case');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with snakecase scope should succeed for "always snakecase"', async t => {
+	const [actual] = scopeCase(await parsed.snakecase, 'always', 'snake-case');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with camelcase scope should fail for "always lowercase"', async t => {
+	const [actual] = scopeCase(await parsed.camelcase, 'always', 'lowercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with camelcase scope should succeed for "always camelcase"', async t => {
+	const [actual] = scopeCase(await parsed.camelcase, 'always', 'camel-case');
+	const expected = true;
+	t.is(actual, expected);
+});
+
+test('with camelcase scope should fail for "always kebabcase"', async t => {
+	const [actual] = scopeCase(await parsed.camelcase, 'always', 'kebab-case');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with camelcase scope should fail for "always pascalcase"', async t => {
+	const [actual] = scopeCase(await parsed.camelcase, 'always', 'pascal-case');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with pascalcase scope should fail for "always lowercase"', async t => {
+	const [actual] = scopeCase(await parsed.pascalcase, 'always', 'lowercase');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with pascalcase scope should fail for "always kebabcase"', async t => {
+	const [actual] = scopeCase(await parsed.pascalcase, 'always', 'kebab-case');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with pascalcase scope should fail for "always camelcase"', async t => {
+	const [actual] = scopeCase(await parsed.pascalcase, 'always', 'camel-case');
+	const expected = false;
+	t.is(actual, expected);
+});
+
+test('with pascalcase scope should succeed for "always pascalcase"', async t => {
+	const [actual] = scopeCase(await parsed.pascalcase, 'always', 'pascal-case');
+	const expected = true;
+	t.is(actual, expected);
+});
+
 test('with mixedcase scope should fail for "always uppercase"', async t => {
 	const [actual] = scopeCase(await parsed.mixedcase, 'always', 'uppercase');
 	const expected = false;