neo-email 0.1.0

The modern way to build emails services with Rust
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

use std::str::from_utf8;

use super::headers::EmailHeaders;
use hashbrown::HashMap;

/// # Mail
/// 
/// This struct represents an email message.
/// 
/// ## Fields
/// 
/// * `headers` - A HashMap of EmailHeaders and its values.
/// * `body` - The body of the email.
#[derive(Debug, PartialEq, Eq)]
pub struct Mail<T> {
    /// # Headers
    /// 
    /// A HashMap of EmailHeaders and its values.
    /// 
    /// ## Example
    /// 
    /// `From -> "jean@nervio.us"`
    pub headers: HashMap<EmailHeaders, String>,
    /// # Body
    /// 
    /// The body of the email.
    pub body: T,
}

impl<T> Mail<T> {
    pub fn from_bytes(bytes: Vec<u8>) -> Result<Mail<T>, String>
    where
        T: From<Vec<u8>>,
    {
        let mut headers = HashMap::new();
        let mut body = Vec::new();
        let mut lines = bytes.split(|&b| b == b'\n').peekable();
        let mut header_complete = false;

        while let Some(line) = lines.next() {
            if line.is_empty() || line == b"\r" {
                header_complete = true;
                break;
            }
            
            if let Some(&b' ') | Some(&b'\t') = line.first() {
                if let Some(last_header) = headers.keys().last().cloned() {
                    let value: &mut String = headers.get_mut(&last_header).unwrap();
                    value.push_str(from_utf8(line).map_err(|_| "Invalid header value")?);
                    continue;
                }
            }

            let mut parts = line.splitn(2, |&b| b == b':');
            let key = parts.next().ok_or("Invalid header")?;
            let value = parts.next().ok_or("Invalid header value not exist")?;
            let value = from_utf8(value).map_err(|_| "Invalid header value")?.trim();
            headers.insert(EmailHeaders::from_bytes(key)?, value.to_owned());
        }

        if header_complete {
            for line in lines {
                body.extend_from_slice(line);
                body.push(b'\n');
            }
        } else {
            return Err("Invalid mail format".to_string());
        }

        Ok(Mail { headers, body: body.into() })
    }
}

pub trait MailTrait: Send + Sync + 'static {
    fn as_any(&self) -> &dyn std::any::Any;
}

impl<T: Send + Sync + 'static> MailTrait for Mail<T> {
    fn as_any(&self) -> &dyn std::any::Any {
        self
    }
}

impl<T: Clone + Send + Sync + 'static> Clone for Mail<T> {
    fn clone(&self) -> Self {
        Mail {
            headers: self.headers.clone(),
            body: self.body.clone(),
        }
    }
}