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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use chumsky::Parser as ChumskyParser;

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

/// `VersionInfo` holds the VMF Header information.
#[derive(Clone, Debug)]
pub struct VersionInfo {
    pub editor_version: u32,
    pub editor_build: u32,
    pub map_version: u16,
    pub format_version: u16,
    pub prefab: u32,
}

impl VersionInfo {
    /// Crates a new [`VersionInfo`] instance.
    pub fn new(
        version: u32,
        build: u32,
        map_version: u16,
        format_version: u16,
        prefab: u32,
    ) -> VersionInfo {
        Self {
            editor_version: version,
            editor_build: build,
            map_version,
            format_version,
            prefab,
        }
    }
}

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

/// A [`InternalParser`] implementation for [`VersionInfo`].
/// Every key-value pair needs to be in order, like in the example bellow.
///
/// usage: `let version_info = VersionInfo::parser().parse();`.
///
/// The format that is being parsed here is:
/// versioninfo
/// {
/// "editorversion" "400"
/// "editorbuild" "6157"
/// "mapversion" "16"
/// "formatversion" "100"
/// "prefab" "0"
/// }
impl<'src> InternalParser<'src> for VersionInfo {
    fn parser<I>() -> impl ChumskyParser<'src, I, Self, TokenError<'src>>
    where
        I: TokenSource<'src>,
    {
        open_block("versioninfo")
            .ignored()
            .then(key_value_numeric::<u32, I>("editorversion"))
            .then(key_value_numeric::<u32, I>("editorbuild"))
            .then(key_value_numeric::<u16, I>("mapversion"))
            .then(key_value_numeric::<u16, I>("formatversion"))
            .then(key_value_numeric::<u32, I>("prefab"))
            .map(|(((((_, vi), eb), mv), fv), pf)| VersionInfo::new(vi, eb, mv, fv, pf))
            .then_ignore(close_block())
            .boxed()
    }
}

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

    use super::*;
    use chumsky::Parser;

    #[test]
    fn test_version_info_parser() {
        // Valid input
        let input = lex(r#"versioninfo
                    {
                        "editorversion" "400"
                        "editorbuild" "6157"
                        "mapversion" "16"
                        "formatversion" "100"
                        "prefab" "0"
                    }"#);

        let result = VersionInfo::parser().parse(input);
        assert!(
            !result.has_errors(),
            "Parser failed with error: {:?}",
            result.errors().collect::<Vec<_>>()
        );

        let version_info = result.unwrap();
        assert_eq!(version_info.editor_version, 400);
        assert_eq!(version_info.editor_build, 6157);
        assert_eq!(version_info.map_version, 16);
        assert_eq!(version_info.format_version, 100);
        assert_eq!(version_info.prefab, 0);

        // Test with different whitespace patterns
        let compact_input = lex(
            r#"versioninfo{"editorversion""500""editorbuild""7000""mapversion""20""formatversion""110""prefab""1"}"#,
        );
        let compact_result = VersionInfo::parser().parse(compact_input);
        assert!(
            !compact_result.has_errors(),
            "Compact parser failed with error: {:?}",
            compact_result.errors().collect::<Vec<_>>()
        );

        // Test with invalid input - missing field
        let missing_field = lex(r#"versioninfo
                                    {
                                        "editorversion" "400"
                                        "editorbuild" "6157"
                                        "mapversion" "16"
                                        "prefab" "0"
                                    }"#); // Missing formatversion

        let missing_result = VersionInfo::parser().parse(missing_field);
        assert!(
            missing_result.has_errors(),
            "Parser should fail on missing field"
        );

        // Test with invalid input - invalid number format
        let invalid_format = lex(r#"versioninfo
                                    {
                                        "editorversion" "400"
                                        "editorbuild" "invalid"
                                        "mapversion" "16"
                                        "formatversion" "100"
                                        "prefab" "0"
                                    }"#);

        let invalid_result = VersionInfo::parser().parse(invalid_format);
        assert!(
            invalid_result.has_errors(),
            "Parser should fail on invalid number format"
        );
    }
}