himalaya 0.7.0

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

use anyhow::{anyhow, Error, Result};
use atty::Stream;
use serde::Serialize;
use std::{fmt, str::FromStr};
use termcolor::ColorChoice;

/// Represents the available output formats.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum OutputFmt {
    Plain,
    Json,
}

impl Default for OutputFmt {
    fn default() -> Self {
        Self::Plain
    }
}

impl FromStr for OutputFmt {
    type Err = Error;

    fn from_str(fmt: &str) -> Result<Self, Self::Err> {
        match fmt {
            fmt if fmt.eq_ignore_ascii_case("json") => Ok(Self::Json),
            fmt if fmt.eq_ignore_ascii_case("plain") => Ok(Self::Plain),
            unknown => Err(anyhow!("cannot parse output format {}", unknown)),
        }
    }
}

impl fmt::Display for OutputFmt {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let fmt = match *self {
            OutputFmt::Json => "JSON",
            OutputFmt::Plain => "Plain",
        };
        write!(f, "{}", fmt)
    }
}

/// Defines a struct-wrapper to provide a JSON output.
#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
pub struct OutputJson<T: Serialize> {
    response: T,
}

impl<T: Serialize> OutputJson<T> {
    pub fn new(response: T) -> Self {
        Self { response }
    }
}

/// Represent the available color configs.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ColorFmt {
    Never,
    Always,
    Ansi,
    Auto,
}

impl Default for ColorFmt {
    fn default() -> Self {
        Self::Auto
    }
}

impl FromStr for ColorFmt {
    type Err = Error;

    fn from_str(fmt: &str) -> Result<Self, Self::Err> {
        match fmt {
            fmt if fmt.eq_ignore_ascii_case("never") => Ok(Self::Never),
            fmt if fmt.eq_ignore_ascii_case("always") => Ok(Self::Always),
            fmt if fmt.eq_ignore_ascii_case("ansi") => Ok(Self::Ansi),
            fmt if fmt.eq_ignore_ascii_case("auto") => Ok(Self::Auto),
            unknown => Err(anyhow!("cannot parse color format {}", unknown)),
        }
    }
}

impl From<ColorFmt> for ColorChoice {
    fn from(fmt: ColorFmt) -> Self {
        match fmt {
            ColorFmt::Never => Self::Never,
            ColorFmt::Always => Self::Always,
            ColorFmt::Ansi => Self::AlwaysAnsi,
            ColorFmt::Auto => {
                if atty::is(Stream::Stdout) {
                    // Otherwise let's `termcolor` decide by
                    // inspecting the environment. From the [doc]:
                    //
                    // * If `NO_COLOR` is set to any value, then
                    // colors will be suppressed.
                    //
                    // * If `TERM` is set to dumb, then colors will be
                    // suppressed.
                    //
                    // * In non-Windows environments, if `TERM` is not
                    // set, then colors will be suppressed.
                    //
                    // [doc]: https://github.com/BurntSushi/termcolor#automatic-color-selection
                    Self::Auto
                } else {
                    // Colors should be deactivated if the terminal is
                    // not a tty.
                    Self::Never
                }
            }
        }
    }
}