asfml 0.1.1

CLI for reading Apache Pony Mail archives
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

use comfy_table::{Cell, Table, presets::UTF8_FULL};
use serde::Serialize;

use asfml_core::{Email, EmailSummary, Error, Result, ThreadResponse};

#[derive(Debug, Clone, Copy, Eq, PartialEq, clap::ValueEnum)]
pub enum TableFormat {
    Table,
    Json,
}

#[derive(Debug, Clone, Copy, Eq, PartialEq, clap::ValueEnum)]
pub enum ReadFormat {
    Text,
    Json,
}

pub fn print_summaries(emails: &[EmailSummary], format: TableFormat) -> Result<()> {
    match format {
        TableFormat::Json => print_json(emails),
        TableFormat::Table => {
            let mut table = Table::new();
            table.load_preset(UTF8_FULL);
            table.set_header(["DATE", "MID", "SUBJECT"]);
            for email in emails {
                table.add_row([
                    Cell::new(email.formatted_date()),
                    Cell::new(email.mid()),
                    Cell::new(&email.subject),
                ]);
            }
            println!("{table}");
            Ok(())
        }
    }
}

pub fn print_email(email: &Email, format: ReadFormat) -> Result<()> {
    match format {
        ReadFormat::Json => print_json(email),
        ReadFormat::Text => {
            println!("Subject: {}", email.subject);
            println!("From: {}", email.from);
            println!("Date: {}", email.formatted_date());
            if let Some(list) = &email.list_name {
                println!("List: {list}");
            }
            println!("MID: {}", email.mid());
            if let Some(message_id) = &email.message_id {
                println!("Message-ID: {message_id}");
            }
            if let Some(in_reply_to) = email.in_reply_to_key() {
                println!("In-Reply-To: {in_reply_to}");
            }
            println!();
            print!("{}", email.body);
            if !email.body.ends_with('\n') {
                println!();
            }
            Ok(())
        }
    }
}

pub fn print_thread(thread: &ThreadResponse, format: ReadFormat) -> Result<()> {
    match format {
        ReadFormat::Json => print_json(thread),
        ReadFormat::Text => {
            let emails = if thread.emails.is_empty() {
                vec![&thread.thread]
            } else {
                thread.emails.iter().collect::<Vec<_>>()
            };
            println!("Thread: {}", thread.thread.subject);
            println!("Messages: {}", emails.len());
            println!();
            for (idx, email) in emails.iter().enumerate() {
                println!(
                    "[{}/{}] {}  {}",
                    idx + 1,
                    emails.len(),
                    email.formatted_date(),
                    email.from
                );
                println!("Subject: {}", email.subject);
                println!("MID: {}", email.mid());
                println!();
                print!("{}", email.body);
                if !email.body.ends_with('\n') {
                    println!();
                }
                if idx + 1 != emails.len() {
                    println!();
                }
            }
            Ok(())
        }
    }
}

pub fn print_error(error: &Error) {
    match error {
        Error::NoSession => {
            eprintln!("No session found.");
            eprintln!("Run `asfml auth set` and paste your lists.apache.org ponymail cookie.");
        }
        Error::InvalidSession => {
            eprintln!("Session expired or invalid.");
            eprintln!("Run `asfml auth set` with a fresh cookie from lists.apache.org.");
        }
        Error::NoListAccess(list) => {
            eprintln!("Logged in, but {list} is not visible to this session.");
        }
        Error::ParentNotFound { in_reply_to } => {
            eprintln!("Parent not found in archive.");
            if !in_reply_to.is_empty() {
                eprintln!("In-Reply-To: {in_reply_to}");
            }
        }
        Error::ApiShapeChanged { endpoint, .. } => {
            eprintln!("Pony Mail API response changed while reading {endpoint}.");
            eprintln!("Run with `--debug` to save the raw response.");
        }
        _ => eprintln!("{error}"),
    }
}

fn print_json<T: Serialize + ?Sized>(value: &T) -> Result<()> {
    println!("{}", serde_json::to_string_pretty(value)?);
    Ok(())
}