scriba 0.4.0

CLI text rendering, prompts, and terminal output utilities
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use serde_json::Value;
use tabled::{builder::Builder, settings::Style};

use crate::{error::Result, Format, TableLayout};

use super::Table;

pub fn render_table(format: Format, table: &Table) -> Result<String> {
    match format {
        Format::Plain | Format::Text => render_text_table(table),
        Format::Markdown => render_markdown_table(table),
        Format::Json => render_json_table(table),
        Format::Jsonl => render_jsonl_table(table),
    }
}

pub fn render_table_value(format: Format, table: &Table) -> Result<Value> {
    match format {
        Format::Json => Ok(table_to_json_value(table)),
        _ => Ok(Value::String(render_table(format, table)?)),
    }
}

pub fn render_text_table(table: &Table) -> Result<String> {
    match table.layout {
        TableLayout::Full => render_text_table_full(table),
        TableLayout::Compact => render_text_table_compact(table),
        TableLayout::Stacked => render_text_table_stacked(table),
    }
}

pub fn render_text_table_full(table: &Table) -> Result<String> {
    let table = table.materialized();

    let mut builder = Builder::default();
    builder.push_record(table.headers.iter().map(|s| s.as_str()));

    for row in &table.rows {
        builder.push_record(row.iter().map(|s| s.as_str()));
    }

    let mut built = builder.build();
    built.with(Style::rounded());

    Ok(built.to_string())
}

pub fn render_text_table_compact(table: &Table) -> Result<String> {
    let table = table.materialized();

    if table.rows.is_empty() {
        // Just headers
        return Ok(table.headers.join("  "));
    }

    let mut lines = vec![table.headers.join("  ")];

    for row in &table.rows {
        lines.push(row.join("  "));
    }

    Ok(lines.join("\n"))
}

pub fn render_text_table_stacked(table: &Table) -> Result<String> {
    let table = table.materialized();

    if table.rows.is_empty() {
        return Ok(String::new());
    }

    let mut lines = Vec::new();

    for (row_idx, row) in table.rows.iter().enumerate() {
        if row_idx > 0 {
            lines.push("---".to_string());
        }

        for (col_idx, cell) in row.iter().enumerate() {
            if col_idx < table.headers.len() {
                lines.push(format!("{}: {}", table.headers[col_idx], cell));
            }
        }
    }

    Ok(lines.join("\n"))
}

pub fn render_markdown_table(table: &Table) -> Result<String> {
    let table = table.materialized();

    let header = format!("| {} |", table.headers.join(" | "));
    let separator = format!(
        "|{}|",
        table
            .headers
            .iter()
            .map(|_| " --- ")
            .collect::<Vec<_>>()
            .join("|")
    );

    let body = table
        .rows
        .iter()
        .map(|row| format!("| {} |", row.join(" | ")))
        .collect::<Vec<_>>()
        .join("\n");

    if body.is_empty() {
        Ok(format!("{header}\n{separator}"))
    } else {
        Ok(format!("{header}\n{separator}\n{body}"))
    }
}

pub fn render_json_table(table: &Table) -> Result<String> {
    Ok(serde_json::to_string_pretty(&table_to_json_value(table))?)
}

pub fn render_jsonl_table(table: &Table) -> Result<String> {
    let table = table.materialized();

    let lines = rows_to_records(&table)
        .into_iter()
        .map(|row| serde_json::to_string(&row))
        .collect::<std::result::Result<Vec<_>, _>>()?;

    Ok(lines.join("\n"))
}

pub fn table_to_json_value(table: &Table) -> Value {
    serde_json::to_value(table.materialized()).unwrap_or(Value::Null)
}

fn rows_to_records(table: &Table) -> Vec<serde_json::Map<String, Value>> {
    let table = table.materialized();

    table
        .rows
        .iter()
        .map(|row| {
            table
                .headers
                .iter()
                .zip(row.iter())
                .map(|(k, v)| (k.clone(), Value::String(v.clone())))
                .collect::<serde_json::Map<String, Value>>()
        })
        .collect()
}