Debian Codegraph @

.cargo/vendor/nom/tests/ini_str.rs

raw
1 use nom::{
2 bytes::complete::{is_a, tag, take_till, take_while},
3 character::complete::{alphanumeric1 as alphanumeric, char, space0 as space},
4 combinator::opt,
5 multi::many,
6 sequence::{delimited, pair, terminated},
7 IResult, Parser,
8 };
9
10 use std::collections::HashMap;
11
12 fn is_line_ending_or_comment(chr: char) -> bool {
13 chr == ';' || chr == '\n'
14 }
15
16 fn not_line_ending(i: &str) -> IResult<&str, &str> {
17 take_while(|c| c != '\r' && c != '\n')(i)
18 }
19
20 fn space_or_line_ending(i: &str) -> IResult<&str, &str> {
21 is_a(" \r\n")(i)
22 }
23
24 fn category(i: &str) -> IResult<&str, &str> {
25 terminated(
26 delimited(char('['), take_while(|c| c != ']'), char(']')),
27 opt(is_a(" \r\n")),
28 )
29 .parse(i)
30 }
31
32 fn key_value(i: &str) -> IResult<&str, (&str, &str)> {
33 let (i, key) = alphanumeric(i)?;
34 let (i, _) = (opt(space), tag("="), opt(space)).parse(i)?;
35 let (i, val) = take_till(is_line_ending_or_comment)(i)?;
36 let (i, _) = opt(space).parse(i)?;
37 let (i, _) = opt(pair(tag(";"), not_line_ending)).parse(i)?;
38 let (i, _) = opt(space_or_line_ending).parse(i)?;
39
40 Ok((i, (key, val)))
41 }
42
43 fn keys_and_values_aggregator(i: &str) -> IResult<&str, Vec<(&str, &str)>> {
44 many(0.., key_value).parse(i)
45 }
46
47 fn keys_and_values(input: &str) -> IResult<&str, HashMap<&str, &str>> {
48 match keys_and_values_aggregator(input) {
49 Ok((i, tuple_vec)) => Ok((i, tuple_vec.into_iter().collect())),
50 Err(e) => Err(e),
51 }
52 }
53
54 fn category_and_keys(i: &str) -> IResult<&str, (&str, HashMap<&str, &str>)> {
55 pair(category, keys_and_values).parse(i)
56 }
57
58 #[allow(clippy::type_complexity)]
59 fn categories_aggregator(i: &str) -> IResult<&str, Vec<(&str, HashMap<&str, &str>)>> {
60 many(0.., category_and_keys).parse(i)
61 }
62
63 fn categories(input: &str) -> IResult<&str, HashMap<&str, HashMap<&str, &str>>> {
64 match categories_aggregator(input) {
65 Ok((i, tuple_vec)) => Ok((i, tuple_vec.into_iter().collect())),
66 Err(e) => Err(e),
67 }
68 }
69
70 #[test]
71 fn parse_category_test() {
72 let ini_file = "[category]
73
74 parameter=value
75 key = value2";
76
77 let ini_without_category = "parameter=value
78 key = value2";
79
80 let res = category(ini_file);
81 println!("{:?}", res);
82 match res {
83 Ok((i, o)) => println!("i: {} | o: {:?}", i, o),
84 _ => println!("error"),
85 }
86
87 assert_eq!(res, Ok((ini_without_category, "category")));
88 }
89
90 #[test]
91 fn parse_key_value_test() {
92 let ini_file = "parameter=value
93 key = value2";
94
95 let ini_without_key_value = "key = value2";
96
97 let res = key_value(ini_file);
98 println!("{:?}", res);
99 match res {
100 Ok((i, (o1, o2))) => println!("i: {} | o: ({:?},{:?})", i, o1, o2),
101 _ => println!("error"),
102 }
103
104 assert_eq!(res, Ok((ini_without_key_value, ("parameter", "value"))));
105 }
106
107 #[test]
108 fn parse_key_value_with_space_test() {
109 let ini_file = "parameter = value
110 key = value2";
111
112 let ini_without_key_value = "key = value2";
113
114 let res = key_value(ini_file);
115 println!("{:?}", res);
116 match res {
117 Ok((i, (o1, o2))) => println!("i: {} | o: ({:?},{:?})", i, o1, o2),
118 _ => println!("error"),
119 }
120
121 assert_eq!(res, Ok((ini_without_key_value, ("parameter", "value"))));
122 }
123
124 #[test]
125 fn parse_key_value_with_comment_test() {
126 let ini_file = "parameter=value;abc
127 key = value2";
128
129 let ini_without_key_value = "key = value2";
130
131 let res = key_value(ini_file);
132 println!("{:?}", res);
133 match res {
134 Ok((i, (o1, o2))) => println!("i: {} | o: ({:?},{:?})", i, o1, o2),
135 _ => println!("error"),
136 }
137
138 assert_eq!(res, Ok((ini_without_key_value, ("parameter", "value"))));
139 }
140
141 #[test]
142 fn parse_multiple_keys_and_values_test() {
143 let ini_file = "parameter=value;abc
144
145 key = value2
146
147 [category]";
148
149 let ini_without_key_value = "[category]";
150
151 let res = keys_and_values(ini_file);
152 println!("{:?}", res);
153 match res {
154 Ok((i, ref o)) => println!("i: {} | o: {:?}", i, o),
155 _ => println!("error"),
156 }
157
158 let mut expected: HashMap<&str, &str> = HashMap::new();
159 expected.insert("parameter", "value");
160 expected.insert("key", "value2");
161 assert_eq!(res, Ok((ini_without_key_value, expected)));
162 }
163
164 #[test]
165 fn parse_category_then_multiple_keys_and_values_test() {
166 //FIXME: there can be an empty line or a comment line after a category
167 let ini_file = "[abcd]
168 parameter=value;abc
169
170 key = value2
171
172 [category]";
173
174 let ini_after_parser = "[category]";
175
176 let res = category_and_keys(ini_file);
177 println!("{:?}", res);
178 match res {
179 Ok((i, ref o)) => println!("i: {} | o: {:?}", i, o),
180 _ => println!("error"),
181 }
182
183 let mut expected_h: HashMap<&str, &str> = HashMap::new();
184 expected_h.insert("parameter", "value");
185 expected_h.insert("key", "value2");
186 assert_eq!(res, Ok((ini_after_parser, ("abcd", expected_h))));
187 }
188
189 #[test]
190 fn parse_multiple_categories_test() {
191 let ini_file = "[abcd]
192
193 parameter=value;abc
194
195 key = value2
196
197 [category]
198 parameter3=value3
199 key4 = value4
200 ";
201
202 let res = categories(ini_file);
203 //println!("{:?}", res);
204 match res {
205 Ok((i, ref o)) => println!("i: {} | o: {:?}", i, o),
206 _ => println!("error"),
207 }
208
209 let mut expected_1: HashMap<&str, &str> = HashMap::new();
210 expected_1.insert("parameter", "value");
211 expected_1.insert("key", "value2");
212 let mut expected_2: HashMap<&str, &str> = HashMap::new();
213 expected_2.insert("parameter3", "value3");
214 expected_2.insert("key4", "value4");
215 let mut expected_h: HashMap<&str, HashMap<&str, &str>> = HashMap::new();
216 expected_h.insert("abcd", expected_1);
217 expected_h.insert("category", expected_2);
218 assert_eq!(res, Ok(("", expected_h)));
219 }