inflector/cases/snakecase/
mod.rs

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

inflector/cases/snakecase/
mod.rs
