nxthdr 0.4.0

Command line interface for the nxthdr platform
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

use std::cell::Cell;

#[derive(Clone, Copy, PartialEq, clap::ValueEnum)]
pub enum OutputFormat {
    #[value(name = "text")]
    Text,
    #[value(name = "json")]
    Json,
}

thread_local! {
    static FORMAT: Cell<OutputFormat> = const { Cell::new(OutputFormat::Text) };
}

pub fn set_format(fmt: OutputFormat) {
    FORMAT.with(|f| f.set(fmt));
}

pub fn is_json() -> bool {
    FORMAT.with(|f| f.get()) == OutputFormat::Json
}

fn fmt() -> OutputFormat {
    FORMAT.with(|f| f.get())
}

/// Print a section heading with a separator (text mode only).
pub fn section(title: &str) {
    if fmt() == OutputFormat::Text {
        println!("{}", title);
        println!("{}", "─".repeat(title.len()));
    }
}

/// Print a plain informational message (text mode only).
pub fn info(msg: &str) {
    if fmt() == OutputFormat::Text {
        println!("{}", msg);
    }
}

/// Print a success confirmation line (text mode only).
pub fn success(msg: &str) {
    if fmt() == OutputFormat::Text {
        println!("✓ {}", msg);
    }
}

/// Print a warning message (text mode only).
pub fn warn(msg: &str) {
    if fmt() == OutputFormat::Text {
        println!("\n⚠ {}", msg);
    }
}

/// Print a suggested next command (text mode only).
pub fn hint(cmd: &str) {
    if fmt() == OutputFormat::Text {
        println!("\n→ {}", cmd);
    }
}

/// Print aligned key-value pairs.
/// JSON mode: outputs a JSON object.
pub fn kv(pairs: &[(&str, &str)]) {
    if pairs.is_empty() {
        return;
    }
    match fmt() {
        OutputFormat::Text => {
            let width = pairs.iter().map(|(k, _)| k.len()).max().unwrap_or(0);
            for (k, v) in pairs {
                println!("{:<width$}  {}", k, v, width = width);
            }
        }
        OutputFormat::Json => {
            let obj: serde_json::Map<String, serde_json::Value> = pairs
                .iter()
                .map(|(k, v)| (k.to_string(), serde_json::Value::String(v.to_string())))
                .collect();
            println!(
                "{}",
                serde_json::to_string_pretty(&serde_json::Value::Object(obj)).unwrap()
            );
        }
    }
}

/// Print an auto-sized table (headers + separator + rows).
/// Returns the number of lines written so a future watch mode can erase them.
/// JSON mode: outputs a JSON array of objects keyed by header names.
pub fn table(headers: &[&str], rows: &[Vec<String>]) -> usize {
    match fmt() {
        OutputFormat::Text => {
            let mut widths: Vec<usize> = headers.iter().map(|h| h.len()).collect();
            for row in rows {
                for (i, cell) in row.iter().enumerate() {
                    if let Some(w) = widths.get_mut(i) {
                        *w = (*w).max(cell.len());
                    }
                }
            }
            let fmt_row = |cells: &[&str]| -> String {
                cells
                    .iter()
                    .enumerate()
                    .map(|(i, c)| format!("{:<w$}", c, w = widths.get(i).copied().unwrap_or(0)))
                    .collect::<Vec<_>>()
                    .join("  ")
            };
            let sep_len = widths.iter().sum::<usize>() + 2 * headers.len().saturating_sub(1);
            println!("{}", fmt_row(headers));
            println!("{}", "─".repeat(sep_len));
            for row in rows {
                let cells: Vec<&str> = row.iter().map(|s| s.as_str()).collect();
                println!("{}", fmt_row(&cells));
            }
            2 + rows.len()
        }
        OutputFormat::Json => {
            let arr: Vec<serde_json::Value> = rows
                .iter()
                .map(|row| {
                    let obj: serde_json::Map<String, serde_json::Value> = headers
                        .iter()
                        .zip(row.iter())
                        .map(|(h, v)| (h.to_string(), serde_json::Value::String(v.clone())))
                        .collect();
                    serde_json::Value::Object(obj)
                })
                .collect();
            println!(
                "{}",
                serde_json::to_string_pretty(&serde_json::Value::Array(arr)).unwrap()
            );
            0
        }
    }
}