grr-cli 0.3.0

Google tools from the terminal, at maximum performance: zero-config Gmail, Calendar, Drive, Contacts, Chat and Forms over HTTP/3
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Output formatting for CLI commands

use clap::ValueEnum;
use comfy_table::{Attribute, Cell, Color, ContentArrangement, Table};
use serde::Serialize;
use serde_json::Value;
use std::io::{self, Write};

#[derive(Debug, Clone, ValueEnum, Default)]
pub enum OutputFormat {
    #[default]
    Json,
    #[value(name = "jsonl")]
    JsonLines,
    Table,
    Pretty,
}

pub fn print_output<T: Serialize>(value: &T, format: OutputFormat) -> io::Result<()> {
    let stdout = io::stdout();
    let mut handle = stdout.lock();

    match format {
        OutputFormat::Json => {
            let json = serde_json::to_string(value)?;
            writeln!(handle, "{}", json)?;
        }
        OutputFormat::JsonLines => {
            let json_value = serde_json::to_value(value)?;
            if let Some(arr) = json_value.as_array() {
                for item in arr {
                    let json = serde_json::to_string(item)?;
                    writeln!(handle, "{}", json)?;
                }
            } else {
                let json = serde_json::to_string(value)?;
                writeln!(handle, "{}", json)?;
            }
        }
        OutputFormat::Pretty => {
            let json = serde_json::to_string_pretty(value)?;
            writeln!(handle, "{}", json)?;
        }
        OutputFormat::Table => {
            print_table(value, &mut handle)?;
        }
    }
    Ok(())
}

fn print_table<T: Serialize>(value: &T, handle: &mut dyn Write) -> io::Result<()> {
    let json_value = serde_json::to_value(value)?;
    match json_value {
        Value::Array(arr) => {
            if arr.is_empty() {
                return Ok(());
            }

            if let Some(first) = arr.first() {
                if let Value::Object(_) = first {
                    print_object_array_as_table(&arr, handle)?;
                } else {
                    print_simple_array_as_table(&arr, handle)?;
                }
            }
        }
        Value::Object(obj) => {
            print_object_as_table(&obj, handle)?;
        }
        _ => {
            let json = serde_json::to_string_pretty(&json_value)?;
            writeln!(handle, "{}", json)?;
        }
    }
    Ok(())
}

fn print_object_array_as_table(arr: &[Value], handle: &mut dyn Write) -> io::Result<()> {
    if arr.is_empty() {
        return Ok(());
    }

    let mut table = Table::new();
    table.set_content_arrangement(ContentArrangement::Dynamic);
    table.set_header(vec!["Field", "Value"]);

    for item in arr {
        if let Value::Object(obj) = item {
            for (key, val) in obj {
                let cell_val = match val {
                    Value::String(s) => s.clone(),
                    Value::Number(n) => n.to_string(),
                    Value::Bool(b) => b.to_string(),
                    Value::Null => "null".to_string(),
                    _ => serde_json::to_string(val).unwrap_or_default(),
                };
                table.add_row(vec![
                    Cell::new(key).add_attribute(Attribute::Bold),
                    Cell::new(cell_val),
                ]);
            }
            table.add_row(vec![Cell::new("---"), Cell::new("---")]);
        }
    }

    writeln!(handle, "{}", table)
}

fn print_simple_array_as_table(arr: &[Value], handle: &mut dyn Write) -> io::Result<()> {
    let mut table = Table::new();
    table.set_header(vec!["Index", "Value"]);

    for (idx, item) in arr.iter().enumerate() {
        let val = match item {
            Value::String(s) => s.clone(),
            Value::Number(n) => n.to_string(),
            Value::Bool(b) => b.to_string(),
            Value::Null => "null".to_string(),
            _ => serde_json::to_string(item).unwrap_or_default(),
        };
        table.add_row(vec![idx.to_string(), val]);
    }

    writeln!(handle, "{}", table)
}

fn print_object_as_table(
    obj: &serde_json::Map<String, Value>,
    handle: &mut dyn Write,
) -> io::Result<()> {
    let mut table = Table::new();
    table.set_content_arrangement(ContentArrangement::Dynamic);
    table.set_header(vec!["Field", "Value"]);

    for (key, val) in obj {
        let cell_val = match val {
            Value::String(s) => s.clone(),
            Value::Number(n) => n.to_string(),
            Value::Bool(b) => b.to_string(),
            Value::Null => "null".to_string(),
            Value::Array(arr) => format!("[{} items]", arr.len()),
            Value::Object(obj) => format!("{{{} fields}}", obj.len()),
        };
        table.add_row(vec![
            Cell::new(key)
                .add_attribute(Attribute::Bold)
                .fg(Color::Cyan),
            Cell::new(cell_val),
        ]);
    }

    writeln!(handle, "{}", table)
}