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
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

//! Module related to email template CLI.
//!
//! This module provides subcommands, arguments and a command matcher
//! related to email templating.

use anyhow::Result;
use clap::{Arg, ArgAction, ArgMatches, Command};

use crate::email;

const ARG_BODY: &str = "body";
const ARG_HEADERS: &str = "headers";
const ARG_TPL: &str = "template";
const CMD_FORWARD: &str = "forward";
const CMD_REPLY: &str = "reply";
const CMD_SAVE: &str = "save";
const CMD_SEND: &str = "send";
const CMD_WRITE: &str = "write";

pub const CMD_TPL: &str = "template";

pub type RawTpl = String;
pub type Headers<'a> = Option<Vec<&'a str>>;
pub type Body<'a> = Option<&'a str>;

/// Represents the template commands.
#[derive(Debug, PartialEq, Eq)]
pub enum Cmd<'a> {
    Forward(email::args::Id<'a>, Headers<'a>, Body<'a>),
    Write(Headers<'a>, Body<'a>),
    Reply(email::args::Id<'a>, email::args::All, Headers<'a>, Body<'a>),
    Save(RawTpl),
    Send(RawTpl),
}

/// Represents the template command matcher.
pub fn matches<'a>(m: &'a ArgMatches) -> Result<Option<Cmd<'a>>> {
    let cmd = if let Some(m) = m.subcommand_matches(CMD_FORWARD) {
        let id = email::args::parse_id_arg(m);
        let headers = parse_headers_arg(m);
        let body = parse_body_arg(m);
        Some(Cmd::Forward(id, headers, body))
    } else if let Some(m) = m.subcommand_matches(CMD_REPLY) {
        let id = email::args::parse_id_arg(m);
        let all = email::args::parse_reply_all_flag(m);
        let headers = parse_headers_arg(m);
        let body = parse_body_arg(m);
        Some(Cmd::Reply(id, all, headers, body))
    } else if let Some(m) = m.subcommand_matches(CMD_SAVE) {
        let raw_tpl = parse_raw_arg(m);
        Some(Cmd::Save(raw_tpl))
    } else if let Some(m) = m.subcommand_matches(CMD_SEND) {
        let raw_tpl = parse_raw_arg(m);
        Some(Cmd::Send(raw_tpl))
    } else if let Some(m) = m.subcommand_matches(CMD_WRITE) {
        let headers = parse_headers_arg(m);
        let body = parse_body_arg(m);
        Some(Cmd::Write(headers, body))
    } else {
        None
    };

    Ok(cmd)
}

/// Represents the template subcommands.
pub fn subcmds<'a>() -> Vec<Command> {
    vec![Command::new(CMD_TPL)
        .alias("tpl")
        .about("Handles email templates")
        .subcommand_required(true)
        .arg_required_else_help(true)
        .subcommand(
            Command::new(CMD_FORWARD)
                .alias("fwd")
                .about("Generates a template for forwarding an email")
                .arg(email::args::id_arg())
                .args(&args()),
        )
        .subcommand(
            Command::new(CMD_REPLY)
                .about("Generates a template for replying to an email")
                .arg(email::args::id_arg())
                .arg(email::args::reply_all_flag())
                .args(&args()),
        )
        .subcommand(
            Command::new(CMD_SAVE)
                .about("Compiles the template into a valid email then saves it")
                .arg(Arg::new(ARG_TPL).raw(true)),
        )
        .subcommand(
            Command::new(CMD_SEND)
                .about("Compiles the template into a valid email then sends it")
                .arg(Arg::new(ARG_TPL).raw(true)),
        )
        .subcommand(
            Command::new(CMD_WRITE)
                .aliases(["new", "n"])
                .about("Generates a template for writing a new email")
                .args(&args()),
        )]
}

/// Represents the template arguments.
pub fn args() -> Vec<Arg> {
    vec![
        Arg::new(ARG_HEADERS)
            .help("Overrides a specific header")
            .short('H')
            .long("header")
            .value_name("KEY:VAL")
            .action(ArgAction::Append),
        Arg::new(ARG_BODY)
            .help("Overrides the body")
            .short('B')
            .long("body")
            .value_name("STRING"),
    ]
}

/// Represents the template headers argument parser.
pub fn parse_headers_arg(m: &ArgMatches) -> Headers<'_> {
    m.get_many(ARG_HEADERS)
        .map(|h| h.map(String::as_str).collect::<Vec<_>>())
}

/// Represents the template body argument parser.
pub fn parse_body_arg(matches: &ArgMatches) -> Body<'_> {
    matches.get_one::<String>(ARG_BODY).map(String::as_str)
}

/// Represents the raw template argument parser.
pub fn parse_raw_arg(matches: &ArgMatches) -> RawTpl {
    matches
        .get_one::<String>(ARG_TPL)
        .cloned()
        .unwrap_or_default()
}