mnk-vmf 0.1.0

A library for parsing Valve Map Format (VMF) files.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use chumsky::{prelude::recursive, IterParser, Parser as ChumskyParser};

use crate::{
    impl_block_properties_parser,
    parser::{close_block, key_value_numeric, open_block, InternalParser, TokenError, TokenSource},
    types::EditorData,
    Parser,
};

#[derive(Debug, Default, Clone)]
pub struct Group<'src> {
    pub id: u32,
    pub editor: Option<EditorData<'src>>,
    pub groups: Vec<Group<'src>>,
}

#[derive(Debug, Clone)]
enum GroupProperty<'src> {
    Id(u32),
    Editor(EditorData<'src>),
    Child(Group<'src>),
}

/// Public parser trait implementation that allows [`Group`] to use ::parse(input) call.
impl<'src> Parser<'src> for Group<'src> {}

/// A [`InternalParser`] implementation for [`Group`].
///
/// usage: `let editor = Group::parser().parse(input);`.
///
/// The format that is being parsed here is:
/// ```ignore
/// group
/// 	{
/// 		"id" "772983"
/// 		editor
/// 		{
/// 			"color" "254 255 0"
/// 			"groupid" "772977"
/// 			"visgroupshown" "1"
/// 			"visgroupautoshown" "1"
/// 		}
/// 	}
///```
impl<'src> InternalParser<'src> for Group<'src> {
    fn parser<I>() -> impl ChumskyParser<'src, I, Self, TokenError<'src>>
    where
        I: TokenSource<'src>,
    {
        recursive(|group_parser| {
            impl_block_properties_parser! {
                property_list: GroupProperty = {
                    p_id     = key_value_numeric("id") => GroupProperty::Id,
                    p_editor = EditorData::parser()    => GroupProperty::Editor,
                    p_child  = group_parser.clone()    => GroupProperty::Child,
                }
            }

            open_block("group")
                .boxed()
                .ignore_then(property_list.repeated().collect::<Vec<GroupProperty>>())
                .then_ignore(close_block())
                .map(|properties: Vec<GroupProperty>| {
                    let mut group = Group::default();
                    for prop in properties {
                        match prop {
                            GroupProperty::Id(val) => group.id = val,
                            GroupProperty::Editor(val) => group.editor = Some(val),
                            GroupProperty::Child(val) => group.groups.push(val),
                        }
                    }
                    group
                })
                .boxed()
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::util::lex;

    #[test]
    fn parse_simple_group() {
        let input = lex(r#"
            group
            {
                "id" "10"
                editor
                {
                    "color" "255 0 0"
                    "visgroupshown" "1"
                    "visgroupautoshown" "1"
                }
            }
        "#);

        let result = Group::parse(input);
        assert!(result.is_ok(), "Parsing failed: {:?}", result.err());
        let group = result.unwrap();
        assert_eq!(group.id, 10);
        assert!(group.editor.is_some());
    }

    #[test]
    fn parse_nested_groups() {
        let input = lex(r#"
            group
            {
                "id" "100"
                group
                {
                    "id" "101"
                }
            }
        "#);

        let result = Group::parse(input);
        assert!(result.is_ok(), "Parsing failed: {:?}", result.err());
        let group = result.unwrap();
        assert_eq!(group.id, 100);
        assert_eq!(group.groups.len(), 1);
        assert_eq!(group.groups[0].id, 101);
    }
}