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