email-parser 0.5.0

The fastest and lightest email parsing Rust library. Supports MIME.
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

use crate::prelude::*;
use std::borrow::Cow;

pub fn quoted_pair(input: &[u8]) -> Result<(&[u8], Cow<str>), Error> {
    let (input, ()) = tag(input, b"\\")?;

    if let Some(character) = input.get(0) {
        if is_vchar(*character) || is_wsp(*character) {
            // index are already checked
            unsafe {
                Ok((
                    input.get_unchecked(1..),
                    from_slice(input.get_unchecked(..1)),
                ))
            }
        } else {
            Err(Error::Unknown(
                "The quoted-pair character is no a vchar or a wsp.",
            ))
        }
    } else {
        Err(Error::Unknown("The quoted-pair has no second character."))
    }
}

pub fn quoted_string(input: &[u8]) -> Result<(&[u8], Cow<str>), Error> {
    let input = if let Ok((input, _cfws)) = cfws(input) {
        input
    } else {
        input
    };

    let mut input = if input.starts_with(b"\"") {
        &input[1..]
    } else {
        return Err(Error::Unknown("Quoted string must begin with a dquote"));
    };
    let mut output = empty_string();

    loop {
        let mut additionnal_output = empty_string();

        let new_input = if let Ok((new_input, fws)) = fws(input) {
            add_string(&mut additionnal_output, fws);
            new_input
        } else {
            input
        };

        let new_input = if let Ok((new_input, str)) = take_while1(new_input, is_qtext) {
            add_str(&mut additionnal_output, str);
            new_input
        } else if let Ok((new_input, str)) = quoted_pair(new_input) {
            add_string(&mut additionnal_output, str);
            new_input
        } else {
            break;
        };

        add_string(&mut output, additionnal_output);
        input = new_input;
    }

    let input = if let Ok((input, fws)) = fws(input) {
        add_string(&mut output, fws);
        input
    } else {
        input
    };

    let input = if input.starts_with(b"\"") {
        &input[1..]
    } else {
        return Err(Error::Unknown("Quoted string must end with a dquote"));
    };

    let input = if let Ok((input, _cfws)) = cfws(input) {
        input
    } else {
        input
    };

    Ok((input, output))
}

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

    #[test]
    fn test_quoted_pair() {
        assert!(quoted_pair(b"\\rtest").is_ok());
        assert!(quoted_pair(b"\\ test").is_ok());

        assert_eq!(quoted_pair(b"\\rtest").unwrap().1, "r");
        assert_eq!(quoted_pair(b"\\ test").unwrap().1, " ");

        assert!(quoted_pair(b"\\").is_err());
        assert!(quoted_pair(b"\\\0").is_err());
        assert!(quoted_pair(b"test").is_err());
    }

    #[test]
    fn test_quoted_string() {
        assert_eq!(
            quoted_string(b" \"This\\ is\\ a\\ test\"").unwrap().1,
            "This is a test"
        );
        assert_eq!(
            quoted_string(b"\r\n  \"This\\ is\\ a\\ test\"  ")
                .unwrap()
                .1,
            "This is a test"
        );

        assert!(matches!(
            quoted_string(b"\r\n  \"This\\ is\\ a\\ test\"  ")
                .unwrap()
                .1,
            Cow::Owned(_)
        ));
        assert!(matches!(
            quoted_string(b"\r\n  \"hey\"  ").unwrap().1,
            Cow::Borrowed(_)
        ));
    }
}