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