himalaya 0.5.7

Command-line interface for email management
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use anyhow::{anyhow, Error, Result};
use std::{
    convert::{TryFrom, TryInto},
    fmt,
    ops::Deref,
};

/// Represents the imap flag variants.
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize)]
pub enum ImapFlag {
    Seen,
    Answered,
    Flagged,
    Deleted,
    Draft,
    Recent,
    MayCreate,
    Custom(String),
}

impl From<&str> for ImapFlag {
    fn from(flag_str: &str) -> Self {
        match flag_str {
            "seen" => ImapFlag::Seen,
            "answered" => ImapFlag::Answered,
            "flagged" => ImapFlag::Flagged,
            "deleted" => ImapFlag::Deleted,
            "draft" => ImapFlag::Draft,
            "recent" => ImapFlag::Recent,
            "maycreate" | "may-create" => ImapFlag::MayCreate,
            flag_str => ImapFlag::Custom(flag_str.into()),
        }
    }
}

impl TryFrom<&imap::types::Flag<'_>> for ImapFlag {
    type Error = Error;

    fn try_from(flag: &imap::types::Flag<'_>) -> Result<Self, Self::Error> {
        Ok(match flag {
            imap::types::Flag::Seen => ImapFlag::Seen,
            imap::types::Flag::Answered => ImapFlag::Answered,
            imap::types::Flag::Flagged => ImapFlag::Flagged,
            imap::types::Flag::Deleted => ImapFlag::Deleted,
            imap::types::Flag::Draft => ImapFlag::Draft,
            imap::types::Flag::Recent => ImapFlag::Recent,
            imap::types::Flag::MayCreate => ImapFlag::MayCreate,
            imap::types::Flag::Custom(custom) => ImapFlag::Custom(custom.to_string()),
            _ => return Err(anyhow!("cannot parse imap flag")),
        })
    }
}

/// Represents the imap flags.
#[derive(Debug, Default, Clone, PartialEq, Eq, serde::Serialize)]
pub struct ImapFlags(pub Vec<ImapFlag>);

impl ImapFlags {
    /// Builds a symbols string
    pub fn to_symbols_string(&self) -> String {
        let mut flags = String::new();
        flags.push_str(if self.contains(&ImapFlag::Seen) {
            " "
        } else {
            "✷"
        });
        flags.push_str(if self.contains(&ImapFlag::Answered) {
            "↵"
        } else {
            " "
        });
        flags.push_str(if self.contains(&ImapFlag::Flagged) {
            "⚑"
        } else {
            " "
        });
        flags
    }
}

impl Deref for ImapFlags {
    type Target = Vec<ImapFlag>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl fmt::Display for ImapFlags {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut glue = "";

        for flag in &self.0 {
            write!(f, "{}", glue)?;
            match flag {
                ImapFlag::Seen => write!(f, "\\Seen")?,
                ImapFlag::Answered => write!(f, "\\Answered")?,
                ImapFlag::Flagged => write!(f, "\\Flagged")?,
                ImapFlag::Deleted => write!(f, "\\Deleted")?,
                ImapFlag::Draft => write!(f, "\\Draft")?,
                ImapFlag::Recent => write!(f, "\\Recent")?,
                ImapFlag::MayCreate => write!(f, "\\MayCreate")?,
                ImapFlag::Custom(custom) => write!(f, "{}", custom)?,
            }
            glue = " ";
        }

        Ok(())
    }
}

impl<'a> Into<Vec<imap::types::Flag<'a>>> for ImapFlags {
    fn into(self) -> Vec<imap::types::Flag<'a>> {
        self.0
            .into_iter()
            .map(|flag| match flag {
                ImapFlag::Seen => imap::types::Flag::Seen,
                ImapFlag::Answered => imap::types::Flag::Answered,
                ImapFlag::Flagged => imap::types::Flag::Flagged,
                ImapFlag::Deleted => imap::types::Flag::Deleted,
                ImapFlag::Draft => imap::types::Flag::Draft,
                ImapFlag::Recent => imap::types::Flag::Recent,
                ImapFlag::MayCreate => imap::types::Flag::MayCreate,
                ImapFlag::Custom(custom) => imap::types::Flag::Custom(custom.into()),
            })
            .collect()
    }
}

impl From<&str> for ImapFlags {
    fn from(flags_str: &str) -> Self {
        ImapFlags(
            flags_str
                .split_whitespace()
                .map(|flag_str| flag_str.trim().into())
                .collect(),
        )
    }
}

impl TryFrom<&[imap::types::Flag<'_>]> for ImapFlags {
    type Error = Error;

    fn try_from(flags: &[imap::types::Flag<'_>]) -> Result<Self, Self::Error> {
        let mut f = vec![];
        for flag in flags {
            f.push(flag.try_into()?);
        }
        Ok(Self(f))
    }
}