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
128
129
130
131
132
133
134

use std::fmt;

/// Commands, without the tag part.
#[derive(Clone)]
pub enum Command {
    Capability,
    Starttls,
    Login {
        username: String,
        password: String,
    },
    Select {
        mailbox: String,
    },
    List {
        reference: String,
        mailbox: String,
    },
    Search {
        criteria: SearchCriteria,
    },
    Fetch {
        // TODO: do sequence-set
        uids: Vec<u32>,
        items: FetchItems,
    },
    UidSearch {
        criteria: SearchCriteria,
    },
    UidFetch {
        // TODO: do sequence-set
        uids: Vec<u32>,
        items: FetchItems,
    },

    #[cfg(feature = "rfc2177-idle")]
    #[cfg_attr(docsrs, doc(cfg(feature = "rfc2177-idle")))]
    Idle,

    #[cfg(feature = "rfc2177-idle")]
    #[cfg_attr(docsrs, doc(cfg(feature = "rfc2177-idle")))]
    Done,
}

impl fmt::Debug for Command {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use Command::*;
        match self {
            Login { .. } => write!(f, "LOGIN"),
            _ => <Self as fmt::Display>::fmt(self, f),
        }
    }
}

impl fmt::Display for Command {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use Command::*;
        match self {
            Capability => write!(f, "CAPABILITY"),
            Starttls => write!(f, "STARTTLS"),
            Login { username, password } => write!(f, "LOGIN {:?} {:?}", username, password),
            Select { mailbox } => write!(f, "SELECT {}", mailbox),
            Search { criteria } => write!(f, "SEARCH {}", criteria),
            UidSearch { criteria } => write!(f, "UID SEARCH {}", criteria),
            List { reference, mailbox } => write!(f, "LIST {:?} {:?}", reference, mailbox),
            Fetch { uids, items } => write!(
                f,
                "FETCH {} {}",
                uids.iter()
                    .map(|s| s.to_string())
                    .collect::<Vec<_>>()
                    .join(","),
                items
            ),
            UidFetch { uids, items } => write!(
                f,
                "UID FETCH {} {}",
                uids.iter()
                    .map(|s| s.to_string())
                    .collect::<Vec<_>>()
                    .join(","),
                items
            ),

            #[cfg(feature = "rfc2177-idle")]
            Idle => write!(f, "IDLE"),
            #[cfg(feature = "rfc2177-idle")]
            Done => write!(f, "DONE"),
        }
    }
}

#[derive(Clone, Debug)]
pub enum SearchCriteria {
    All,
}

impl fmt::Display for SearchCriteria {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use SearchCriteria::*;
        match self {
            All => write!(f, "ALL"),
        }
    }
}

#[derive(Clone, Debug)]
pub enum FetchItems {
    All,
    Fast,
    Full,
    BodyPeek,
    Items(Vec<FetchAttr>),

    /// item set that panorama uses, TODO: remove when FetchItems has a builder
    PanoramaAll,
}

#[derive(Clone, Debug)]
pub enum FetchAttr {}

impl fmt::Display for FetchItems {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use FetchItems::*;
        match self {
            All => write!(f, "ALL"),
            Fast => write!(f, "FAST"),
            Full => write!(f, "FULL"),
            BodyPeek => write!(f, "(BODY.PEEK[])"),
            PanoramaAll => write!(f, "(FLAGS INTERNALDATE RFC822.SIZE ENVELOPE BODY.PEEK[])"),
            Items(attrs) => write!(f, ""),
        }
    }
}