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