vmf_vmt 0.1.0

Valve Map Format and Valve Material parsing/building library.
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

use nom::{
    branch::alt, bytes::complete::is_not, character::complete::{multispace0, none_of, one_of}, combinator::recognize, error::ParseError, multi::{many0, many1}, sequence::{delimited, separated_pair}, IResult
};

#[derive(PartialEq,Debug)]
pub enum Valve {
    Class {
        class_name: String,
        data: Vec<Valve>,
    },
    PropertyValue(String, String),
}

pub type VmfVmt = Vec<Valve>;

pub fn build_vmf_vmt(data: VmfVmt) -> String {
    data.into_iter().map(|class| build_valve(0,class)).collect::<Vec<String>>().concat()
}

pub fn build_valve(indent: usize, data: Valve) -> String {
    match data {
        Valve::Class { class_name, data } => {
            let mut out = String::new();
            for _ in 0..indent {out.push('\t')};
            out.push_str(&class_name);
            out.push_str("\n");
            for _ in 0..indent {out.push('\t')};
            out.push_str("{\n");
            for subvalue in data {
                out.push_str(&build_valve(indent+1,subvalue));
            }
            for _ in 0..indent {out.push('\t')};
            out.push_str("}\n");
            out
        },
        Valve::PropertyValue(property, value) => {
            let mut out = String::new();
            for _ in 0..indent {out.push('\t')};
            out.push_str("\"");
            out.push_str(&property);
            out.push_str("\" \"");
            out.push_str(&value);
            out.push_str("\"\n");
            out
        },
    }
}

pub fn parse_vmf_vmt(input: &str) -> IResult<&str,VmfVmt> {
    many1(ws(parse_class))(input)
}

fn parse_valve(input: &str) -> IResult<&str, Valve> {
    alt((parse_class, parse_property_value))(input)
}

fn parse_class(input: &str) -> IResult<&str, Valve> {
    let (input, class_name) = parse_unquoted(input)?;
    let (input, data) = delimited(
        ws(one_of("{")),
        many0(ws(parse_valve)),
        ws(one_of("}")),
    )(input)?;
    Ok((input, Valve::Class { class_name, data }))
}

fn parse_property_value(input: &str) -> IResult<&str, Valve> {
    let (input, (property, value)) =
        separated_pair(parse_string, multispace0, parse_string)(input)?;
    Ok((input, Valve::PropertyValue(property, value)))
}

fn parse_string(input: &str) -> IResult<&str, String> {
    alt((parse_unquoted, parse_quoted))(input)
}

fn parse_unquoted(input: &str) -> IResult<&str, String> {
    let (input, string) = is_not(" \t\r\n\"{{}}")(input)?;
    Ok((input, string.to_string()))
}

fn parse_quoted(input: &str) -> IResult<&str, String> {
    let (input, string) = delimited(
        recognize(one_of("\"")),
        recognize(many0(none_of("\""))),
        recognize(one_of("\"")),
    )(input)?;
    Ok((input, string.to_string()))
}

fn ws<'a, F: 'a, O, E: ParseError<&'a str>>(
    inner: F,
) -> impl FnMut(&'a str) -> IResult<&'a str, O, E>
where
    F: Fn(&'a str) -> IResult<&'a str, O, E>,
{
    delimited(multispace0, inner, multispace0)
}