ime 1.1.0

A fast, lightweight CLI for reading, writing, and wiping metadata from image files.
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

use lexopt::{Arg, Parser};

pub struct Args {
    pub file: String,
    pub key: Option<String>,
    pub output: Option<String>,
    pub strip: bool,
    pub set: std::collections::BTreeMap<String, String>,
    pub set_json: Option<String>,
    pub recursive: bool,
    pub directory: bool,
    pub tui: bool,
}

pub enum CliResult {
    Args(Args),
    Help,
    Version,
}

pub fn parse_args() -> Result<CliResult, lexopt::Error> {
    let mut parser = Parser::from_env();
    let mut file = None;
    let mut key = None;
    let mut output = None;
    let mut strip = false;
    let mut set = std::collections::BTreeMap::new();
    let mut set_json = None;
    let mut recursive = false;
    let mut directory = false;
    let mut tui = false;

    while let Some(arg) = parser.next()? {
        match arg {
            Arg::Short('t') | Arg::Long("tui") => {
                tui = true;
            }
            Arg::Short('s') | Arg::Long("strip") => {
                strip = true;
            }
            Arg::Short('r') | Arg::Long("recursive") => {
                recursive = true;
            }
            Arg::Short('d') | Arg::Long("dir") | Arg::Long("directory") => {
                directory = true;
            }
            Arg::Long("set") => {
                let val = parser.value()?.to_string_lossy().into_owned();
                if let Some((k, v)) = val.split_once('=') {
                    set.insert(k.to_string(), v.to_string());
                } else {
                    return Err(lexopt::Error::Custom(
                        "Invalid --set format, expected Key=Value or .path.to.key=Value".into(),
                    ));
                }
            }
            Arg::Long("set-json") => {
                set_json = Some(parser.value()?.to_string_lossy().into_owned());
            }
            Arg::Short('k') | Arg::Long("key") => {
                let raw = parser.value()?.to_string_lossy().into_owned();
                key = Some(raw.trim_start_matches('.').to_string());
            }
            Arg::Short('o') | Arg::Long("output") => {
                output = Some(parser.value()?.to_string_lossy().into_owned());
            }
            Arg::Short('v') | Arg::Long("version") => {
                return Ok(CliResult::Version);
            }
            Arg::Short('h') | Arg::Long("help") => {
                return Ok(CliResult::Help);
            }
            Arg::Value(val) if file.is_none() => {
                file = Some(val.to_string_lossy().into_owned());
            }
            _ => return Err(arg.unexpected()),
        }
    }

    match file {
        Some(f) => Ok(CliResult::Args(Args {
            file: f,
            key,
            output,
            strip,
            set,
            set_json,
            recursive,
            directory,
            tui,
        })),
        None => Err(lexopt::Error::MissingValue {
            option: Some("file".to_string()),
        }),
    }
}