1 use std::collections::HashMap;
2 use std::str;
3
4 use winnow::prelude::*;
5 use winnow::{
6 ascii::{alphanumeric1 as alphanumeric, multispace0 as multispace, space0 as space},
7 combinator::opt,
8 combinator::repeat,
9 combinator::{delimited, separated_pair, terminated},
10 token::take_while,
11 };
12
13 pub type Stream<'i> = &'i [u8];
14
categories<'s>(i: &mut Stream<'s>) -> PResult<HashMap<&'s str, HashMap<&'s str, &'s str>>>15 pub fn categories<'s>(i: &mut Stream<'s>) -> PResult<HashMap<&'s str, HashMap<&'s str, &'s str>>> {
16 repeat(
17 0..,
18 separated_pair(
19 category,
20 opt(multispace),
21 repeat(0.., terminated(key_value, opt(multispace))),
22 ),
23 )
24 .parse_next(i)
25 }
26
category<'s>(i: &mut Stream<'s>) -> PResult<&'s str>27 fn category<'s>(i: &mut Stream<'s>) -> PResult<&'s str> {
28 delimited('[', take_while(0.., |c| c != b']'), ']')
29 .try_map(str::from_utf8)
30 .parse_next(i)
31 }
32
key_value<'s>(i: &mut Stream<'s>) -> PResult<(&'s str, &'s str)>33 pub fn key_value<'s>(i: &mut Stream<'s>) -> PResult<(&'s str, &'s str)> {
34 let key = alphanumeric.try_map(str::from_utf8).parse_next(i)?;
35 let _ = (opt(space), '=', opt(space)).parse_next(i)?;
36 let val = take_while(0.., |c| c != b'\n' && c != b';')
37 .try_map(str::from_utf8)
38 .parse_next(i)?;
39 let _ = opt((';', take_while(0.., |c| c != b'\n'))).parse_next(i)?;
40 Ok((key, val))
41 }
42
43 #[test]
parse_category_test()44 fn parse_category_test() {
45 let ini_file = &b"[category]
46
47 parameter=value
48 key = value2"[..];
49
50 let ini_without_category = &b"\n\nparameter=value
51 key = value2"[..];
52
53 let res = category.parse_peek(ini_file);
54 println!("{:?}", res);
55 match res {
56 Ok((i, o)) => println!("i: {:?} | o: {:?}", str::from_utf8(i), o),
57 _ => println!("error"),
58 }
59
60 assert_eq!(res, Ok((ini_without_category, "category")));
61 }
62
63 #[test]
parse_key_value_test()64 fn parse_key_value_test() {
65 let ini_file = &b"parameter=value
66 key = value2"[..];
67
68 let ini_without_key_value = &b"\nkey = value2"[..];
69
70 let res = key_value.parse_peek(ini_file);
71 println!("{:?}", res);
72 match res {
73 Ok((i, (o1, o2))) => println!("i: {:?} | o: ({:?},{:?})", str::from_utf8(i), o1, o2),
74 _ => println!("error"),
75 }
76
77 assert_eq!(res, Ok((ini_without_key_value, ("parameter", "value"))));
78 }
79
80 #[test]
parse_key_value_with_space_test()81 fn parse_key_value_with_space_test() {
82 let ini_file = &b"parameter = value
83 key = value2"[..];
84
85 let ini_without_key_value = &b"\nkey = value2"[..];
86
87 let res = key_value.parse_peek(ini_file);
88 println!("{:?}", res);
89 match res {
90 Ok((i, (o1, o2))) => println!("i: {:?} | o: ({:?},{:?})", str::from_utf8(i), o1, o2),
91 _ => println!("error"),
92 }
93
94 assert_eq!(res, Ok((ini_without_key_value, ("parameter", "value"))));
95 }
96
97 #[test]
parse_key_value_with_comment_test()98 fn parse_key_value_with_comment_test() {
99 let ini_file = &b"parameter=value;abc
100 key = value2"[..];
101
102 let ini_without_key_value = &b"\nkey = value2"[..];
103
104 let res = key_value.parse_peek(ini_file);
105 println!("{:?}", res);
106 match res {
107 Ok((i, (o1, o2))) => println!("i: {:?} | o: ({:?},{:?})", str::from_utf8(i), o1, o2),
108 _ => println!("error"),
109 }
110
111 assert_eq!(res, Ok((ini_without_key_value, ("parameter", "value"))));
112 }
113
114 #[test]
parse_multiple_categories_test()115 fn parse_multiple_categories_test() {
116 let ini_file = &b"[abcd]
117
118 parameter=value;abc
119
120 key = value2
121
122 [category]
123 parameter3=value3
124 key4 = value4
125 "[..];
126
127 let ini_after_parser = &b""[..];
128
129 let res = categories.parse_peek(ini_file);
130 //println!("{:?}", res);
131 match res {
132 Ok((i, ref o)) => println!("i: {:?} | o: {:?}", str::from_utf8(i), o),
133 _ => println!("error"),
134 }
135
136 let mut expected_1: HashMap<&str, &str> = HashMap::new();
137 expected_1.insert("parameter", "value");
138 expected_1.insert("key", "value2");
139 let mut expected_2: HashMap<&str, &str> = HashMap::new();
140 expected_2.insert("parameter3", "value3");
141 expected_2.insert("key4", "value4");
142 let mut expected_h: HashMap<&str, HashMap<&str, &str>> = HashMap::new();
143 expected_h.insert("abcd", expected_1);
144 expected_h.insert("category", expected_2);
145 assert_eq!(res, Ok((ini_after_parser, expected_h)));
146 }
147