notcoal 0.4.0

Not charcoal filters, but notmuch ones. Filter library for the notmuch email system
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

use clap::Parser;
use notcoal::*;
use notmuch::{ConfigKey, Database, DatabaseMode};
use std::path::{Path, PathBuf};
use std::process;

#[derive(Parser, Debug)]
#[command(name = "notcoal", about = "notmuch filters, not made from coal.")]
struct Opt {
    #[arg(short, long = "config")]
    /// Configuration file [default: same as notmuch]
    config: Option<PathBuf>,
    #[arg(short, long = "filters")]
    /// Rule file [default: $notmuchdb/.notmuch/hooks/notcoal-rules.json]
    filters: Option<PathBuf>,
    #[arg(short, long = "tag", default_value = "new")]
    /// Tag to query
    tag: String,
    #[arg(long = "leave-tag")]
    /// Leave the "query tag" in place instead of removing once all filters ran
    leave: bool,
    #[arg(long = "sync-flags")]
    /// Force maildir flag syncing  (overrides setting found in config)
    flags: Option<bool>,
    #[arg(long = "dry-run")]
    dry: bool,
}

pub fn get_maildir_sync_db(db: &Database) -> bool {
    match db.config_bool(ConfigKey::MaildirFlags) {
        Ok(bool) => bool,
        Err(err) => {
            eprintln!("Could not open notmuch database, aborting!");
            eprintln!("Error: {err}");
            process::exit(1);
        }
    }
}

pub fn get_filters(path: &Option<PathBuf>, db: &Database) -> Vec<Filter> {
    let mut p: PathBuf;
    let filter_path = match path {
        Some(p) => p,
        None => {
            p = match db.config(ConfigKey::HookDir) {
                Some(path) => PathBuf::from(path),
                None => {
                    eprintln!("Could not determine notmuch hooks directory, aborting!");
                    process::exit(1);
                }
            };
            p.push("notcoal-rules.json");
            &p
        }
    };

    match filters_from_file(filter_path) {
        Ok(f) => f,
        Err(e) => {
            // using {} here results in stack overflow when getting a JSONError…
            eprintln!("Couldn't load filters: {:?}", e);
            process::exit(1);
        }
    }
}

fn main() {
    let opt = Opt::parse();

    let db = match Database::open_with_config::<&Path, _>(
        None,
        if opt.dry {
            DatabaseMode::ReadOnly
        } else {
            DatabaseMode::ReadWrite
        },
        opt.config,
        None,
    ) {
        Ok(db) => db,
        Err(err) => {
            eprintln!("Could not open notmuch database, aborting!");
            eprintln!("Error: {err}");
            eprintln!("Do you have notmuch configured?");
            process::exit(1);
        }
    };

    let options = FilterOptions {
        sync_tags: match &opt.flags {
            Some(b) => *b,
            None => get_maildir_sync_db(&db),
        },
        leave_tag: opt.leave,
    };
    let filters = get_filters(&opt.filters, &db);

    if opt.dry {
        match filter_dry(&db, &opt.tag, &filters) {
            Ok((amount, infos)) => {
                println!("There are {amount} matches:");
                for info in infos {
                    println!("{info}");
                }
            }
            Err(e) => {
                eprintln!("Oops: {e}");
                process::exit(1);
            }
        }
        process::exit(0);
    }

    match filter(&db, &opt.tag, &options, &filters) {
        Ok(m) => {
            if m > 0 {
                println!("Yay you successfully applied {m} filters");
            } else {
                println!("No message filtering necessary!");
            }
        }
        Err(e) => {
            eprintln!("Oops: {e}");
            process::exit(1);
        }
    };
}