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

/*
 * TODO: add support for:
 * "SOURCE" / "KIND" / "FN" / "N" / "NICKNAME"
 * "PHOTO" / "BDAY" / "ANNIVERSARY" / "GENDER" / "ADR" / "TEL"
 * "EMAIL" / "IMPP" / "LANG" / "TZ" / "GEO" / "TITLE" / "ROLE"
 * "LOGO" / "ORG" / "MEMBER" / "RELATED" / "CATEGORIES"
 * "NOTE" / "PRODID" / "REV" / "SOUND" / "UID" / "CLIENTPIDMAP"
 * "URL" / "KEY" / "FBURL" / "CALADRURI" / "CALURI" / "XML"
 * iana-token / x-name
*/

use std::fmt;

/// The `FN` field of a `VCard` is a required field
/// # Example
/// ```
/// use muttmates::fields::FN;
///
/// let field = FN::new("FN:Foo Bar");
/// assert_eq!(field.name, "Foo Bar" );
/// ```
#[derive(Debug, PartialEq)]
pub struct FN<'a> {
    pub name: &'a str,
}

impl<'a> FN<'a> {
    pub fn new(raw: &'a str) -> FN<'a> {
        let splits: Vec<&str> = raw.split(':').collect();
        FN { name: splits[1] }
    }
}

impl<'a> fmt::Display for FN<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}

/// An Enum for various EMail types
/// TODO: please elaborate...
#[derive(Debug, PartialEq)]
pub enum EMailType {
    Home,
    Work,
    Other,
}

/// The `EMAIL` field
/// # Example
/// ```
/// use muttmates::fields::{EMail, EMailType};
///
/// let email = EMail::new("EMAIL;TYPE=WORK:john@doe.example");
/// assert_eq!(email.addr, "john@doe.example");
/// assert_eq!(email.r#type, EMailType::Work);
/// ```
#[derive(Debug, PartialEq)]
pub struct EMail<'a> {
    pub addr: &'a str,
    pub r#type: EMailType,
    pub pref: bool,
}

impl<'a> EMail<'a> {
    pub fn new(raw: &'a str) -> EMail {
        let splits: Vec<&str> = raw.split(":").collect();
        let (prefix, addr) = match splits.as_slice() {
            [prefix, addr] => (prefix, addr),
            _ => unreachable!(),
        };

        let mut r#type = EMailType::Other;
        let lower = prefix.to_lowercase();

        if lower.find("type").is_some() {
            if lower.contains("work") {
                r#type = EMailType::Work;
            } else if lower.contains("home") {
                r#type = EMailType::Home;
            }
        }
        let pref = false;

        EMail { addr, r#type, pref }
    }

    fn parse(&self) -> String {
        self.addr.to_string()
    }
}

impl<'a> fmt::Display for EMail<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.parse())
    }
}