inflector/cases/camelcase/
mod.rs

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

inflector/cases/camelcase/
mod.rs
