mail_headers/header_components/
received_token.rs

1use soft_ascii_string::SoftAsciiChar;
2
3use internals::error::EncodingError;
4use internals::encoder::{EncodingWriter, EncodableInHeader};
5
6use super::word::{ Word, do_encode_word };
7use super::{ Email, Domain };
8
9
10#[derive(Debug, Clone, Hash, Eq, PartialEq)]
11pub enum ReceivedToken {
12    Word( Word ),
13    Address( Email ),
14    Domain( Domain )
15}
16
17impl EncodableInHeader for  ReceivedToken {
18
19    fn encode(&self, handle: &mut EncodingWriter) -> Result<(), EncodingError> {
20        use self::ReceivedToken::*;
21        match *self {
22            Word( ref word ) => {
23                do_encode_word( word, handle, None )?;
24            },
25            Address( ref addr ) => {
26                // we do not need to use <..> , but I think it's better and it is definitely
27                // not wrong
28                handle.write_char( SoftAsciiChar::from_unchecked('<') )?;
29                addr.encode( handle )?;
30                handle.write_char( SoftAsciiChar::from_unchecked('>') )?;
31            },
32            Domain( ref domain ) => {
33                domain.encode( handle )?;
34            }
35        }
36        Ok( () )
37    }
38
39    fn boxed_clone(&self) -> Box<EncodableInHeader> {
40        Box::new(self.clone())
41    }
42}
43
44#[cfg(test)]
45mod test {
46    use ::HeaderTryFrom;
47    use internals::MailType;
48    use internals::encoder::EncodingBuffer;
49    use super::*;
50
51    ec_test!{ a_domain, {
52        Domain::try_from( "random.mailnot" )?
53    } => ascii => [
54        MarkFWS,
55        Text "random.mailnot",
56        MarkFWS
57    ]}
58
59    ec_test!{ a_address, {
60        let email = Email::try_from( "modnar@random.mailnot")?;
61        ReceivedToken::Address( email )
62    } => ascii => [
63        Text "<",
64        MarkFWS,
65        Text "modnar",
66        MarkFWS,
67        Text "@",
68        MarkFWS,
69        Text "random.mailnot",
70        MarkFWS,
71        Text ">"
72    ]}
73
74    ec_test!{ a_word, {
75        let word = Word::try_from( "simple" )?;
76        ReceivedToken::Word( word )
77    } => ascii => [
78        Text "simple"
79    ]}
80
81    ec_test!{ a_quoted_word, {
82        let word = Word::try_from( "sim ple" )?;
83        ReceivedToken::Word( word )
84    } => ascii => [
85        Text r#""sim ple""#
86    ]}
87
88
89    #[test]
90    fn no_encoded_word() {
91        let mut encoder = EncodingBuffer::new( MailType::Ascii );
92        let mut handle = encoder.writer();
93        let input = ReceivedToken::Word( Word::try_from( "↓right" ).unwrap() );
94        assert_err!(input.encode( &mut handle ));
95        handle.undo_header();
96    }
97}