inflector/cases/classcase/
mod.rs

1#![deny(warnings)]
2use cases::case::*;
3#[cfg(feature = "heavyweight")]
4use string::singularize::to_singular;
5#[cfg(feature = "heavyweight")]
6/// Converts a `&str` to `ClassCase` `String`
7///
8/// ```
9///     use inflector::cases::classcase::to_class_case;
10///     let mock_string: &str = "FooBar";
11///     let expected_string: String = "FooBar".to_string();
12///     let asserted_string: String = to_class_case(mock_string);
13///     assert!(asserted_string == expected_string);
14///
15/// ```
16///
17/// ```
18///     use inflector::cases::classcase::to_class_case;
19///     let mock_string: &str = "FooBars";
20///     let expected_string: String = "FooBar".to_string();
21///     let asserted_string: String = to_class_case(mock_string);
22///     assert!(asserted_string == expected_string);
23///
24/// ```
25///
26/// ```
27///     use inflector::cases::classcase::to_class_case;
28///     let mock_string: &str = "Foo Bar";
29///     let expected_string: String = "FooBar".to_string();
30///     let asserted_string: String = to_class_case(mock_string);
31///     assert!(asserted_string == expected_string);
32///
33/// ```
34///
35/// ```
36///     use inflector::cases::classcase::to_class_case;
37///     let mock_string: &str = "foo-bar";
38///     let expected_string: String = "FooBar".to_string();
39///     let asserted_string: String = to_class_case(mock_string);
40///     assert!(asserted_string == expected_string);
41///
42/// ```
43///
44/// ```
45///     use inflector::cases::classcase::to_class_case;
46///     let mock_string: &str = "fooBar";
47///     let expected_string: String = "FooBar".to_string();
48///     let asserted_string: String = to_class_case(mock_string);
49///     assert!(asserted_string == expected_string);
50///
51/// ```
52///
53/// ```
54///     use inflector::cases::classcase::to_class_case;
55///     let mock_string: &str = "FOO_BAR";
56///     let expected_string: String = "FooBar".to_string();
57///     let asserted_string: String = to_class_case(mock_string);
58///     assert!(asserted_string == expected_string);
59///
60/// ```
61///
62/// ```
63///     use inflector::cases::classcase::to_class_case;
64///     let mock_string: &str = "foo_bar";
65///     let expected_string: String = "FooBar".to_string();
66///     let asserted_string: String = to_class_case(mock_string);
67///     assert!(asserted_string == expected_string);
68///
69/// ```
70///
71/// ```
72///     use inflector::cases::classcase::to_class_case;
73///     let mock_string: &str = "foo_bars";
74///     let expected_string: String = "FooBar".to_string();
75///     let asserted_string: String = to_class_case(mock_string);
76///     assert!(asserted_string == expected_string);
77///
78/// ```
79///
80/// ```
81///     use inflector::cases::classcase::to_class_case;
82///     let mock_string: &str = "Foo bar";
83///     let expected_string: String = "FooBar".to_string();
84///     let asserted_string: String = to_class_case(mock_string);
85///     assert!(asserted_string == expected_string);
86///
87/// ```
88pub fn to_class_case(non_class_case_string: &str) -> String {
89    let options = CamelOptions {
90        new_word: true,
91        last_char: ' ',
92        first_word: false,
93        injectable_char: ' ',
94        has_seperator: false,
95        inverted: false,
96    };
97    let class_plural = to_case_camel_like(non_class_case_string, options);
98    let split: (&str, &str) =
99        class_plural.split_at(class_plural.rfind(char::is_uppercase).unwrap_or(0));
100    format!("{}{}", split.0, to_singular(split.1))
101}
102
103#[cfg(feature = "heavyweight")]
104/// Determines if a `&str` is `ClassCase` `bool`
105///
106/// ```
107///     use inflector::cases::classcase::is_class_case;
108///     let mock_string: &str = "Foo";
109///     let asserted_bool: bool = is_class_case(mock_string);
110///     assert!(asserted_bool == true);
111///
112/// ```
113///
114/// ```
115///     use inflector::cases::classcase::is_class_case;
116///     let mock_string: &str = "foo";
117///     let asserted_bool: bool = is_class_case(mock_string);
118///     assert!(asserted_bool == false);
119///
120/// ```
121///
122/// ```
123///     use inflector::cases::classcase::is_class_case;
124///     let mock_string: &str = "FooBarIsAReallyReallyLongStrings";
125///     let asserted_bool: bool = is_class_case(mock_string);
126///     assert!(asserted_bool == false);
127///
128/// ```
129///
130///
131/// ```
132///     use inflector::cases::classcase::is_class_case;
133///     let mock_string: &str = "FooBarIsAReallyReallyLongString";
134///     let asserted_bool: bool = is_class_case(mock_string);
135///     assert!(asserted_bool == true);
136///
137/// ```
138///
139/// ```
140///     use inflector::cases::classcase::is_class_case;
141///     let mock_string: &str = "foo-bar-string-that-is-really-really-long";
142///     let asserted_bool: bool = is_class_case(mock_string);
143///     assert!(asserted_bool == false);
144///
145/// ```
146///
147/// ```
148///     use inflector::cases::classcase::is_class_case;
149///     let mock_string: &str = "foo_bar_is_a_really_really_long_strings";
150///     let asserted_bool: bool = is_class_case(mock_string);
151///     assert!(asserted_bool == false);
152///
153/// ```
154///
155///
156/// ```
157///     use inflector::cases::classcase::is_class_case;
158///     let mock_string: &str = "fooBarIsAReallyReallyLongString";
159///     let asserted_bool: bool = is_class_case(mock_string);
160///     assert!(asserted_bool == false);
161///
162/// ```
163///
164/// ```
165///     use inflector::cases::classcase::is_class_case;
166///     let mock_string: &str = "FOO_BAR_STRING_THAT_IS_REALLY_REALLY_LONG";
167///     let asserted_bool: bool = is_class_case(mock_string);
168///     assert!(asserted_bool == false);
169///
170/// ```
171///
172/// ```
173///     use inflector::cases::classcase::is_class_case;
174///     let mock_string: &str = "foo_bar_string_that_is_really_really_long";
175///     let asserted_bool: bool = is_class_case(mock_string);
176///     assert!(asserted_bool == false);
177///
178/// ```
179///
180/// ```
181///     use inflector::cases::classcase::is_class_case;
182///     let mock_string: &str = "Foo bar string that is really really long";
183///     let asserted_bool: bool = is_class_case(mock_string);
184///     assert!(asserted_bool == false);
185///
186/// ```
187///
188/// ```
189///     use inflector::cases::classcase::is_class_case;
190///     let mock_string: &str = "Foo Bar Is A Really Really Long String";
191///     let asserted_bool: bool = is_class_case(mock_string);
192///     assert!(asserted_bool == false);
193///
194/// ```
195pub fn is_class_case(test_string: &str) -> bool {
196    to_class_case(&test_string.clone()) == test_string
197}
198
199#[cfg(all(feature = "unstable", test))]
200#[cfg(feature = "heavyweight")]
201mod benchmarks {
202    extern crate test;
203    use self::test::Bencher;
204
205    #[bench]
206    fn bench_class_case(b: &mut Bencher) {
207        b.iter(|| super::to_class_case("Foo bar"));
208    }
209
210    #[bench]
211    fn bench_is_class(b: &mut Bencher) {
212        b.iter(|| super::is_class_case("Foo bar"));
213    }
214
215    #[bench]
216    fn bench_class_from_snake(b: &mut Bencher) {
217        b.iter(|| super::to_class_case("foo_bar"));
218    }
219}
220
221#[cfg(test)]
222#[cfg(feature = "heavyweight")]
223mod tests {
224    use ::to_class_case;
225    use ::is_class_case;
226
227    #[test]
228    fn from_camel_case() {
229        let convertable_string: String = "fooBar".to_owned();
230        let expected: String = "FooBar".to_owned();
231        assert_eq!(to_class_case(&convertable_string), expected)
232    }
233
234    #[test]
235    fn from_pascal_case() {
236        let convertable_string: String = "FooBar".to_owned();
237        let expected: String = "FooBar".to_owned();
238        assert_eq!(to_class_case(&convertable_string), expected)
239    }
240
241    #[test]
242    fn from_kebab_case() {
243        let convertable_string: String = "foo-bar".to_owned();
244        let expected: String = "FooBar".to_owned();
245        assert_eq!(to_class_case(&convertable_string), expected)
246    }
247
248    #[test]
249    fn from_sentence_case() {
250        let convertable_string: String = "Foo bar".to_owned();
251        let expected: String = "FooBar".to_owned();
252        assert_eq!(to_class_case(&convertable_string), expected)
253    }
254
255    #[test]
256    fn from_title_case() {
257        let convertable_string: String = "Foo Bar".to_owned();
258        let expected: String = "FooBar".to_owned();
259        assert_eq!(to_class_case(&convertable_string), expected)
260    }
261
262    #[test]
263    fn from_train_case() {
264        let convertable_string: String = "Foo-Bar".to_owned();
265        let expected: String = "FooBar".to_owned();
266        assert_eq!(to_class_case(&convertable_string), expected)
267    }
268
269    #[test]
270    fn from_screaming_class_case() {
271        let convertable_string: String = "FOO_BAR".to_owned();
272        let expected: String = "FooBar".to_owned();
273        assert_eq!(to_class_case(&convertable_string), expected)
274    }
275
276    #[test]
277    fn from_snake_case() {
278        let convertable_string: String = "foo_bar".to_owned();
279        let expected: String = "FooBar".to_owned();
280        assert_eq!(to_class_case(&convertable_string), expected)
281    }
282
283    #[test]
284    fn from_table_case() {
285        let convertable_string: String = "foo_bars".to_owned();
286        let expected: String = "FooBar".to_owned();
287        assert_eq!(to_class_case(&convertable_string), expected)
288    }
289
290    #[test]
291    fn from_case_with_loads_of_space() {
292        let convertable_string: String = "foo           bar".to_owned();
293        let expected: String = "FooBar".to_owned();
294        assert_eq!(to_class_case(&convertable_string), expected)
295    }
296
297    #[test]
298    fn a_name_with_a_dot() {
299        let convertable_string: String = "Robert C. Martin".to_owned();
300        let expected: String = "RobertCMartin".to_owned();
301        assert_eq!(to_class_case(&convertable_string), expected)
302    }
303
304    #[test]
305    fn random_text_with_bad_chars() {
306        let convertable_string: String = "Random text with *(bad) chars".to_owned();
307        let expected: String = "RandomTextWithBadChar".to_owned();
308        assert_eq!(to_class_case(&convertable_string), expected)
309    }
310
311    #[test]
312    fn trailing_bad_chars() {
313        let convertable_string: String = "trailing bad_chars*(()())".to_owned();
314        let expected: String = "TrailingBadChar".to_owned();
315        assert_eq!(to_class_case(&convertable_string), expected)
316    }
317
318    #[test]
319    fn leading_bad_chars() {
320        let convertable_string: String = "-!#$%leading bad chars".to_owned();
321        let expected: String = "LeadingBadChar".to_owned();
322        assert_eq!(to_class_case(&convertable_string), expected)
323    }
324
325    #[test]
326    fn wrapped_in_bad_chars() {
327        let convertable_string: String = "-!#$%wrapped in bad chars&*^*&(&*^&(<><?>><?><>))".to_owned();
328        let expected: String = "WrappedInBadChar".to_owned();
329        assert_eq!(to_class_case(&convertable_string), expected)
330    }
331
332    #[test]
333    fn has_a_sign() {
334        let convertable_string: String = "has a + sign".to_owned();
335        let expected: String = "HasASign".to_owned();
336        assert_eq!(to_class_case(&convertable_string), expected)
337    }
338
339    #[test]
340    fn is_correct_from_class_case() {
341        let convertable_string: String = "fooBar".to_owned();
342        assert_eq!(is_class_case(&convertable_string), false)
343    }
344
345    #[test]
346    fn is_correct_from_pascal_case() {
347        let convertable_string: String = "FooBar".to_owned();
348        assert_eq!(is_class_case(&convertable_string), true)
349    }
350
351    #[test]
352    fn is_correct_from_kebab_case() {
353        let convertable_string: String = "foo-bar".to_owned();
354        assert_eq!(is_class_case(&convertable_string), false)
355    }
356
357    #[test]
358    fn is_correct_from_sentence_case() {
359        let convertable_string: String = "Foo bar".to_owned();
360        assert_eq!(is_class_case(&convertable_string), false)
361    }
362
363    #[test]
364    fn is_correct_from_title_case() {
365        let convertable_string: String = "Foo Bar".to_owned();
366        assert_eq!(is_class_case(&convertable_string), false)
367    }
368
369    #[test]
370    fn is_correct_from_train_case() {
371        let convertable_string: String = "Foo-Bar".to_owned();
372        assert_eq!(is_class_case(&convertable_string), false)
373    }
374
375    #[test]
376    fn is_correct_from_screaming_snake_case() {
377        let convertable_string: String = "FOO_BAR".to_owned();
378        assert_eq!(is_class_case(&convertable_string), false)
379    }
380
381    #[test]
382    fn is_correct_from_snake_case() {
383        let convertable_string: String = "foo_bar".to_owned();
384        assert_eq!(is_class_case(&convertable_string), false)
385    }
386
387    #[test]
388    fn is_correct_from_table_case() {
389        let convertable_string: String = "FooBar".to_owned();
390        assert_eq!(is_class_case(&convertable_string), true)
391    }
392}
393
inflector/cases/classcase/mod.rs

inflector/cases/classcase/
mod.rs
