ircv3_parse 4.0.0

Zero-copy parser for IRCv3 messages
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

use proptest::{
    char, collection,
    prelude::{any, Arbitrary, BoxedStrategy, Just, Strategy},
    prop_compose, prop_oneof,
};

#[derive(Debug, Clone, PartialEq)]
pub enum EscapeString {
    Normal(String),
    UnknownEscaped(String),
    Colon,
    Space,
    Slash,
    Return,
    NewLine,
}
impl EscapeString {
    pub fn escaped_string(&self) -> String {
        match self {
            Self::Normal(s) => s.to_string(),
            Self::UnknownEscaped(s) => s.to_string(),
            Self::Colon => ";".to_string(),
            Self::Space => " ".to_string(),
            Self::Slash => "\\".to_string(),
            Self::Return => "\r".to_string(),
            Self::NewLine => "\n".to_string(),
        }
    }
    pub fn unescaped_string(&self) -> String {
        match self {
            Self::Normal(s) => s.to_string(),
            Self::UnknownEscaped(s) => s.to_string(),
            Self::Colon => "\\:".to_string(),
            Self::Space => "\\s".to_string(),
            Self::Slash => "\\\\".to_string(),
            Self::Return => "\r".to_string(),
            Self::NewLine => "\n".to_string(),
        }
    }
}

impl Arbitrary for EscapeString {
    type Parameters = ();
    type Strategy = BoxedStrategy<Self>;
    fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
        prop_oneof![
            normal_strategy().prop_map(EscapeString::Normal),
            unknown_escape_strategy().prop_map(EscapeString::UnknownEscaped),
            Just(EscapeString::Colon),
            Just(EscapeString::Space),
            Just(EscapeString::Slash),
            Just(EscapeString::Return),
            Just(EscapeString::NewLine),
        ]
        .boxed()
    }
}

// input, expected
prop_compose! {
    pub fn escaped_strategy()(
        s in collection::vec(any::<EscapeString>(), 0..=20)
    ) -> (String, String) {
        let expected: String = s
            .iter()
            .map(|s| s.escaped_string())
            .collect();

        let unescaped_input: String = s
            .iter()
            .map(|s| s.unescaped_string())
            .collect();

        (unescaped_input, expected)
    }
}

prop_compose! {
    fn normal_strategy()(
        normal in collection::vec(
        // exclude space
            char::range('\x21', '\x7E')
                .prop_filter("exclude special chars", |&c|{
                    c != ';' && c != '\\' && c != '\r' && c != '\n'
                }),
            0..=100
        )
        .prop_map(|chars| chars.into_iter().collect::<String>())
    ) -> String { normal }
}

prop_compose! {
    fn unknown_escape_strategy()(
        name in prop_oneof![
            char::range('a', 'z')
                .prop_filter("exclude known escapes", |&c| {
                    c != 's' && c != 'r' && c != 'n'
                })
                .prop_map(|c| format!("\\{}", c)),

            char::range('0', '9')
                .prop_map(|c| format!("\\{}", c)),

            char::range('!', '/')
                .prop_filter("exclude known escapes", |&c| {
                    c != ':' && c != '\\'
                })
                .prop_map(|c| format!("\\{}", c)),
    ]) -> String { name }
}