inflector/cases/kebabcase/mod.rs
1#![deny(warnings)]
2use cases::case::*;
3/// Determines if a `&str` is `kebab-case`
4///
5/// ```
6/// use inflector::cases::kebabcase::is_kebab_case;
7/// let mock_string: &str = "foo-bar-string-that-is-really-really-long";
8/// let asserted_bool: bool = is_kebab_case(mock_string);
9/// assert!(asserted_bool == true);
10///
11/// ```
12///
13/// ```
14/// use inflector::cases::kebabcase::is_kebab_case;
15/// let mock_string: &str = "FooBarIsAReallyReallyLongString";
16/// let asserted_bool: bool = is_kebab_case(mock_string);
17/// assert!(asserted_bool == false);
18///
19/// ```
20///
21/// ```
22/// use inflector::cases::kebabcase::is_kebab_case;
23/// let mock_string: &str = "fooBarIsAReallyReallyLongString";
24/// let asserted_bool: bool = is_kebab_case(mock_string);
25/// assert!(asserted_bool == false);
26///
27/// ```
28///
29/// ```
30/// use inflector::cases::kebabcase::is_kebab_case;
31/// let mock_string: &str = "FOO_BAR_STRING_THAT_IS_REALLY_REALLY_LONG";
32/// let asserted_bool: bool = is_kebab_case(mock_string);
33/// assert!(asserted_bool == false);
34///
35/// ```
36///
37/// ```
38/// use inflector::cases::kebabcase::is_kebab_case;
39/// let mock_string: &str = "foo_bar_string_that_is_really_really_long";
40/// let asserted_bool: bool = is_kebab_case(mock_string);
41/// assert!(asserted_bool == false);
42///
43/// ```
44///
45/// ```
46/// use inflector::cases::kebabcase::is_kebab_case;
47/// let mock_string: &str = "Foo bar string that is really really long";
48/// let asserted_bool: bool = is_kebab_case(mock_string);
49/// assert!(asserted_bool == false);
50///
51/// ```
52///
53/// ```
54/// use inflector::cases::kebabcase::is_kebab_case;
55/// let mock_string: &str = "Foo Bar Is A Really Really Long String";
56/// let asserted_bool: bool = is_kebab_case(mock_string);
57/// assert!(asserted_bool == false);
58///
59/// ```
60pub fn is_kebab_case(test_string: &str) -> bool {
61 test_string == to_kebab_case(test_string.clone())
62}
63
64/// Converts a `&str` to `kebab-case` `String`
65///
66/// ```
67/// use inflector::cases::kebabcase::to_kebab_case;
68/// let mock_string: &str = "foo-bar";
69/// let expected_string: String = "foo-bar".to_string();
70/// let asserted_string: String = to_kebab_case(mock_string);
71/// assert!(asserted_string == expected_string);
72///
73/// ```
74///
75/// ```
76/// use inflector::cases::kebabcase::to_kebab_case;
77/// let mock_string: &str = "FOO_BAR";
78/// let expected_string: String = "foo-bar".to_string();
79/// let asserted_string: String = to_kebab_case(mock_string);
80/// assert!(asserted_string == expected_string);
81///
82/// ```
83///
84/// ```
85/// use inflector::cases::kebabcase::to_kebab_case;
86/// let mock_string: &str = "foo_bar";
87/// let expected_string: String = "foo-bar".to_string();
88/// let asserted_string: String = to_kebab_case(mock_string);
89/// assert!(asserted_string == expected_string);
90///
91/// ```
92///
93/// ```
94/// use inflector::cases::kebabcase::to_kebab_case;
95/// let mock_string: &str = "Foo Bar";
96/// let expected_string: String = "foo-bar".to_string();
97/// let asserted_string: String = to_kebab_case(mock_string);
98/// assert!(asserted_string == expected_string);
99///
100/// ```
101///
102/// ```
103/// use inflector::cases::kebabcase::to_kebab_case;
104/// let mock_string: &str = "Foo bar";
105/// let expected_string: String = "foo-bar".to_string();
106/// let asserted_string: String = to_kebab_case(mock_string);
107/// assert!(asserted_string == expected_string);
108///
109/// ```
110///
111/// ```
112/// use inflector::cases::kebabcase::to_kebab_case;
113/// let mock_string: &str = "FooBar";
114/// let expected_string: String = "foo-bar".to_string();
115/// let asserted_string: String = to_kebab_case(mock_string);
116/// assert!(asserted_string == expected_string);
117///
118/// ```
119///
120/// ```
121/// use inflector::cases::kebabcase::to_kebab_case;
122/// let mock_string: &str = "fooBar";
123/// let expected_string: String = "foo-bar".to_string();
124/// let asserted_string: String = to_kebab_case(mock_string);
125/// assert!(asserted_string == expected_string);
126///
127/// ```
128pub fn to_kebab_case(non_kebab_case_string: &str) -> String {
129 to_case_snake_like(non_kebab_case_string, "-", "lower")
130}
131
132#[cfg(all(feature = "unstable", test))]
133mod benchmarks {
134 extern crate test;
135 use self::test::Bencher;
136
137 #[bench]
138 fn bench_kebab(b: &mut Bencher) {
139 b.iter(|| super::to_kebab_case("Foo bar"));
140 }
141
142 #[bench]
143 fn bench_is_kebab(b: &mut Bencher) {
144 b.iter(|| super::is_kebab_case("Foo bar"));
145 }
146
147 #[bench]
148 fn bench_kebab_from_snake(b: &mut Bencher) {
149 b.iter(|| super::to_kebab_case("test_test_test"));
150 }
151}
152
153#[cfg(test)]
154mod tests {
155 use ::to_kebab_case;
156 use ::is_kebab_case;
157
158 #[test]
159 fn from_camel_case() {
160 let convertable_string: String = "fooBar".to_owned();
161 let expected: String = "foo-bar".to_owned();
162 assert_eq!(to_kebab_case(&convertable_string), expected)
163 }
164
165 #[test]
166 fn from_pascal_case() {
167 let convertable_string: String = "FooBar".to_owned();
168 let expected: String = "foo-bar".to_owned();
169 assert_eq!(to_kebab_case(&convertable_string), expected)
170 }
171
172 #[test]
173 fn from_kebab_case() {
174 let convertable_string: String = "foo-bar".to_owned();
175 let expected: String = "foo-bar".to_owned();
176 assert_eq!(to_kebab_case(&convertable_string), expected)
177 }
178
179 #[test]
180 fn from_sentence_case() {
181 let convertable_string: String = "Foo bar".to_owned();
182 let expected: String = "foo-bar".to_owned();
183 assert_eq!(to_kebab_case(&convertable_string), expected)
184 }
185
186 #[test]
187 fn from_title_case() {
188 let convertable_string: String = "Foo Bar".to_owned();
189 let expected: String = "foo-bar".to_owned();
190 assert_eq!(to_kebab_case(&convertable_string), expected)
191 }
192
193 #[test]
194 fn from_train_case() {
195 let convertable_string: String = "Foo-Bar".to_owned();
196 let expected: String = "foo-bar".to_owned();
197 assert_eq!(to_kebab_case(&convertable_string), expected)
198 }
199
200 #[test]
201 fn from_screaming_snake_case() {
202 let convertable_string: String = "FOO_BAR".to_owned();
203 let expected: String = "foo-bar".to_owned();
204 assert_eq!(to_kebab_case(&convertable_string), expected)
205 }
206
207 #[test]
208 fn from_snake_case() {
209 let convertable_string: String = "foo_bar".to_owned();
210 let expected: String = "foo-bar".to_owned();
211 assert_eq!(to_kebab_case(&convertable_string), expected)
212 }
213
214 #[test]
215 fn is_correct_from_camel_case() {
216 let convertable_string: String = "fooBar".to_owned();
217 assert_eq!(is_kebab_case(&convertable_string), false)
218 }
219
220 #[test]
221 fn is_correct_from_pascal_case() {
222 let convertable_string: String = "FooBar".to_owned();
223 assert_eq!(is_kebab_case(&convertable_string), false)
224 }
225
226 #[test]
227 fn is_correct_from_kebab_case() {
228 let convertable_string: String = "foo-bar".to_owned();
229 assert_eq!(is_kebab_case(&convertable_string), true)
230 }
231
232 #[test]
233 fn is_correct_from_sentence_case() {
234 let convertable_string: String = "Foo bar".to_owned();
235 assert_eq!(is_kebab_case(&convertable_string), false)
236 }
237
238 #[test]
239 fn is_correct_from_title_case() {
240 let convertable_string: String = "Foo Bar".to_owned();
241 assert_eq!(is_kebab_case(&convertable_string), false)
242 }
243
244 #[test]
245 fn is_correct_from_train_case() {
246 let convertable_string: String = "Foo-Bar".to_owned();
247 assert_eq!(is_kebab_case(&convertable_string), false)
248 }
249
250 #[test]
251 fn is_correct_from_screaming_snake_case() {
252 let convertable_string: String = "FOO_BAR".to_owned();
253 assert_eq!(is_kebab_case(&convertable_string), false)
254 }
255
256 #[test]
257 fn is_correct_from_snake_case() {
258 let convertable_string: String = "foo_bar".to_owned();
259 assert_eq!(is_kebab_case(&convertable_string), false)
260 }
261}
262