syslog_parse 1.0.2

parse syslog，check syslog format
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

use nom::{
    branch::alt,
    bytes::complete::{escaped, tag, take_till1, take_until, take_while1},
    character::complete::{anychar, space0},
    combinator::map,
    multi::{many1, separated_list0},
    sequence::{delimited, separated_pair, terminated, tuple},
    IResult,
};

fn value0(input: &str) -> IResult<&str, String> {
    match map(tag(r#""""#), |_| "".to_string())(input) {
        Ok((res, v)) => Ok((res, v)),
        Err(e) => Err(e),
    }
}

fn value1(input: &str) -> IResult<&str, String> {
    match delimited(
        tag("\""),
        escaped(take_while1(|c: char| c != '\\' && c != '"'), '\\', anychar),
        tag("\""),
    )(input)
    {
        Ok((res, v)) => Ok((res, format!("\"{}\"", v))),
        Err(e) => Err(e),
    }
}

/// Parse the param value - a string delimited by '"' - '\' escapes \ and "
fn param_value(input: &str) -> IResult<&str, String> {
    match alt((value0, value1))(input) {
        Ok((res, v)) => Ok((res, v)),
        Err(e) => Err(e),
    }
}

/// Parse a param name="value"
fn param(input: &str) -> IResult<&str, String> {
    match separated_pair(
        take_till1(|c: char| c == ']' || c == '='),
        terminated(tag("="), space0),
        param_value,
    )(input)
    {
        Ok((res, (k, v))) => Ok((res, format!("{}={}", k, v))),
        Err(e) => Err(e),
    }
}

/// Parse a single structured data record.
/// [exampleSDID@32473 iut="3" eventSource="Application" eventID="1011"]
fn structured_datum_strict(input: &str) -> IResult<&str, String> {
    match delimited(
        tag("["),
        map(
            tuple((
                take_till1(|c: char| c.is_whitespace() || c == ']' || c == '='),
                space0,
                separated_list0(tag(" "), param),
            )),
            |(id, space, params)| format!("{}{}{}", id, space, params.join(" ")),
        ),
        tag("]"),
    )(input)
    {
        Ok((res, v)) => Ok((res, format!("[{}]", v))),
        Err(e) => Err(e),
    }
}

fn inner_permissive(input: &str) -> IResult<&str, String> {
    match delimited(tag("["), map(take_until("]"), |v: &str| v), tag("]"))(input) {
        Ok((res, v)) => Ok((res, format!("[{}]", v))),
        Err(e) => Err(e),
    }
}

// /// Parse a single structured data record allowing anything between brackets.
fn structured_datum_permissive(input: &str) -> IResult<&str, String> {
    alt((
        structured_datum_strict,
        // If the element fails to parse, just parse it and return None.
        inner_permissive,
    ))(input)
}
//
// /// Parse a single structured data record.
fn structured_datum(allow_failure: bool) -> impl FnMut(&str) -> IResult<&str, String> {
    if allow_failure {
        structured_datum_permissive
    } else {
        structured_datum_strict
    }
}

/// Parse multiple structured data elements.
pub(crate) fn structured_data_optional(
    allow_failure: bool,
) -> impl FnMut(&str) -> IResult<&str, String> {
    move |input| {
        alt((
            map(tag("-"), |_| "-".to_string()),
            map(many1(structured_datum(allow_failure)), |items| {
                items.join("")
            }),
        ))(input)
    }
}

/// Parse multiple structured data elements.
pub(crate) fn structured_data(input: &str) -> IResult<&str, String> {
    structured_data_optional(true)(input)
}

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

    #[test]
    fn test_structured_data() {
        let data = r#"[exampleSDID@32473 iut="3" eventSource="Application" eventID="1011"]"#;
        let value = structured_data(data).unwrap();
        assert_eq!(data, value.1);

        let data = r#"[exampleSDID@32473 iut="3" eventSource="Application" eventID="1011"][examplePriority@32473 class="high"]"#;
        let value = structured_data(data).unwrap();
        assert_eq!(data, value.1);
    }
}