Skip to content

Commit 79c0cee

Browse files
marioneblmarionebl
authored
feat(core): add additional case options (#84)
* feat(core): add kebab-case, camelCase, PascalCase options * test: use appropriate headerPattern for startCase
1 parent 91968b8 commit 79c0cee

File tree

7 files changed

+578
-12
lines changed

7 files changed

+578
-12
lines changed

‎.gitignore

+1
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,4 @@
1+
.idea/
12
npm-debug.log*
23
lerna-debug.log
34
node_modules

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

+17-3
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,25 @@
1+
import {camelCase, kebabCase, snakeCase, upperFirst, startCase} from 'lodash';
2+
13
export default (raw = '', target = 'lowercase') => {
2-
const normalized = String(raw);
4+
const input = String(raw);
35

46
switch (target) {
7+
case 'camel-case':
8+
return camelCase(input) === input;
9+
case 'kebab-case':
10+
return kebabCase(input) === input;
11+
case 'snake-case':
12+
return snakeCase(input) === input;
13+
case 'pascal-case':
14+
return upperFirst(camelCase(input)) === input;
15+
case 'start-case':
16+
return startCase(input) === input;
17+
case 'upper-case':
518
case 'uppercase':
6-
return normalized.toUpperCase() === normalized;
19+
return input.toUpperCase() === input;
20+
case 'lower-case':
721
case 'lowercase':
822
default:
9-
return normalized.toLowerCase() === normalized;
23+
return input.toLowerCase() === input;
1024
}
1125
};

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

+172-2
Original file line numberDiff line numberDiff line change
@@ -6,14 +6,24 @@ const messages = {
66
empty: 'chore: subject',
77
lowercase: 'chore(scope): subject',
88
mixedcase: 'chore(sCoPe): subject',
9-
uppercase: 'chore(SCOPE): subject'
9+
uppercase: 'chore(SCOPE): subject',
10+
camelcase: 'chore(myScope): subject',
11+
kebabcase: 'chore(my-scope): subject',
12+
pascalcase: 'chore(MyScope): subject',
13+
snakecase: 'chore(my_scope): subject',
14+
startcase: 'chore(My Scope): subject'
1015
};
1116

1217
const parsed = {
1318
empty: parse(messages.empty),
1419
lowercase: parse(messages.lowercase),
1520
mixedcase: parse(messages.mixedcase),
16-
uppercase: parse(messages.uppercase)
21+
uppercase: parse(messages.uppercase),
22+
camelcase: parse(messages.camelcase),
23+
kebabcase: parse(messages.kebabcase),
24+
pascalcase: parse(messages.pascalcase),
25+
snakecase: parse(messages.snakecase),
26+
startcase: parse(messages.startcase)
1727
};
1828

1929
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 => {
4050
t.is(actual, expected);
4151
});
4252

53+
test('with empty scope should succeed for "never camelcase"', async t => {
54+
const [actual] = scopeCase(await parsed.empty, 'never', 'camel-case');
55+
const expected = true;
56+
t.is(actual, expected);
57+
});
58+
59+
test('with empty scope should succeed for "always camelcase"', async t => {
60+
const [actual] = scopeCase(await parsed.empty, 'never', 'camel-case');
61+
const expected = true;
62+
t.is(actual, expected);
63+
});
64+
65+
test('with empty scope should succeed for "never kebabcase"', async t => {
66+
const [actual] = scopeCase(await parsed.empty, 'never', 'kebab-case');
67+
const expected = true;
68+
t.is(actual, expected);
69+
});
70+
71+
test('with empty scope should succeed for "always kebabcase"', async t => {
72+
const [actual] = scopeCase(await parsed.empty, 'never', 'kebab-case');
73+
const expected = true;
74+
t.is(actual, expected);
75+
});
76+
77+
test('with empty scope should succeed for "never pascalcase"', async t => {
78+
const [actual] = scopeCase(await parsed.empty, 'never', 'pascal-case');
79+
const expected = true;
80+
t.is(actual, expected);
81+
});
82+
83+
test('with empty scope should succeed for "always pascalcase"', async t => {
84+
const [actual] = scopeCase(await parsed.empty, 'never', 'pascal-case');
85+
const expected = true;
86+
t.is(actual, expected);
87+
});
88+
89+
test('with empty scope should succeed for "never snakecase"', async t => {
90+
const [actual] = scopeCase(await parsed.empty, 'never', 'snake-case');
91+
const expected = true;
92+
t.is(actual, expected);
93+
});
94+
95+
test('with empty scope should succeed for "always snakecase"', async t => {
96+
const [actual] = scopeCase(await parsed.empty, 'never', 'snake-case');
97+
const expected = true;
98+
t.is(actual, expected);
99+
});
100+
101+
test('with empty scope should succeed for "never startcase"', async t => {
102+
const [actual] = scopeCase(await parsed.empty, 'never', 'start-case');
103+
const expected = true;
104+
t.is(actual, expected);
105+
});
106+
107+
test('with empty scope should succeed for "always startcase"', async t => {
108+
const [actual] = scopeCase(await parsed.empty, 'never', 'start-case');
109+
const expected = true;
110+
t.is(actual, expected);
111+
});
112+
43113
test('with lowercase scope should fail for "never lowercase"', async t => {
44114
const [actual] = scopeCase(await parsed.lowercase, 'never', 'lowercase');
45115
const expected = false;
@@ -70,6 +140,106 @@ test('with mixedcase scope should succeed for "never uppercase"', async t => {
70140
t.is(actual, expected);
71141
});
72142

143+
test('with kebabcase scope should succeed for "always lowercase"', async t => {
144+
const [actual] = scopeCase(await parsed.kebabcase, 'always', 'lowercase');
145+
const expected = true;
146+
t.is(actual, expected);
147+
});
148+
149+
test('with kebabcase scope should fail for "always camelcase"', async t => {
150+
const [actual] = scopeCase(await parsed.kebabcase, 'always', 'camel-case');
151+
const expected = false;
152+
t.is(actual, expected);
153+
});
154+
155+
test('with kebabcase scope should fail for "always pascalcase"', async t => {
156+
const [actual] = scopeCase(await parsed.kebabcase, 'always', 'pascal-case');
157+
const expected = false;
158+
t.is(actual, expected);
159+
});
160+
161+
test('with kebabcase scope should succeed for "always kebabcase"', async t => {
162+
const [actual] = scopeCase(
163+
await parsed.kebabcase,
164+
'always',
165+
'kebabcase-case'
166+
);
167+
const expected = true;
168+
t.is(actual, expected);
169+
});
170+
171+
test('with snakecase scope should succeed for "always lowercase"', async t => {
172+
const [actual] = scopeCase(await parsed.snakecase, 'always', 'lowercase');
173+
const expected = true;
174+
t.is(actual, expected);
175+
});
176+
177+
test('with snakecase scope should fail for "always camelcase"', async t => {
178+
const [actual] = scopeCase(await parsed.snakecase, 'always', 'camel-case');
179+
const expected = false;
180+
t.is(actual, expected);
181+
});
182+
183+
test('with snakecase scope should fail for "always pascalcase"', async t => {
184+
const [actual] = scopeCase(await parsed.snakecase, 'always', 'pascal-case');
185+
const expected = false;
186+
t.is(actual, expected);
187+
});
188+
189+
test('with snakecase scope should succeed for "always snakecase"', async t => {
190+
const [actual] = scopeCase(await parsed.snakecase, 'always', 'snake-case');
191+
const expected = true;
192+
t.is(actual, expected);
193+
});
194+
195+
test('with camelcase scope should fail for "always lowercase"', async t => {
196+
const [actual] = scopeCase(await parsed.camelcase, 'always', 'lowercase');
197+
const expected = false;
198+
t.is(actual, expected);
199+
});
200+
201+
test('with camelcase scope should succeed for "always camelcase"', async t => {
202+
const [actual] = scopeCase(await parsed.camelcase, 'always', 'camel-case');
203+
const expected = true;
204+
t.is(actual, expected);
205+
});
206+
207+
test('with camelcase scope should fail for "always kebabcase"', async t => {
208+
const [actual] = scopeCase(await parsed.camelcase, 'always', 'kebab-case');
209+
const expected = false;
210+
t.is(actual, expected);
211+
});
212+
213+
test('with camelcase scope should fail for "always pascalcase"', async t => {
214+
const [actual] = scopeCase(await parsed.camelcase, 'always', 'pascal-case');
215+
const expected = false;
216+
t.is(actual, expected);
217+
});
218+
219+
test('with pascalcase scope should fail for "always lowercase"', async t => {
220+
const [actual] = scopeCase(await parsed.pascalcase, 'always', 'lowercase');
221+
const expected = false;
222+
t.is(actual, expected);
223+
});
224+
225+
test('with pascalcase scope should fail for "always kebabcase"', async t => {
226+
const [actual] = scopeCase(await parsed.pascalcase, 'always', 'kebab-case');
227+
const expected = false;
228+
t.is(actual, expected);
229+
});
230+
231+
test('with pascalcase scope should fail for "always camelcase"', async t => {
232+
const [actual] = scopeCase(await parsed.pascalcase, 'always', 'camel-case');
233+
const expected = false;
234+
t.is(actual, expected);
235+
});
236+
237+
test('with pascalcase scope should succeed for "always pascalcase"', async t => {
238+
const [actual] = scopeCase(await parsed.pascalcase, 'always', 'pascal-case');
239+
const expected = true;
240+
t.is(actual, expected);
241+
});
242+
73243
test('with mixedcase scope should fail for "always uppercase"', async t => {
74244
const [actual] = scopeCase(await parsed.mixedcase, 'always', 'uppercase');
75245
const expected = false;

0 commit comments

Comments
 (0)