standout 12.0.0

Styled CLI template rendering with automatic terminal detection
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

//! `preserve_order` makes JSON, YAML and CSV emit a handler's declared field order
//! (docs/topics/output-modes.md, "Key ordering"), asserted on a derived struct through `App`.

use clap::Command;
use serde::Serialize;
use standout::cli::FnHandler;
use standout::cli::{App, Output};
use standout::EmbeddedTemplates;
use standout::{
    AmbiguousWidth, ColorMode, IconMode, InputSources, Representation, TargetProperties,
};

const TEMPLATES: &[(&str, &str)] = &[("info", "unused")];

// Not alphabetical, so a sort would show.
#[derive(Serialize)]
struct Instance {
    name: &'static str,
    zone: &'static str,
    machine_type: &'static str,
    status: &'static str,
}

fn dispatch(mode: Representation) -> String {
    let app = App::builder()
        .templates(EmbeddedTemplates::new(TEMPLATES, ""))
        .command_with(
            "info",
            FnHandler::new(|_m, _ctx| {
                Ok(Output::Render(serde_json::to_value(Instance {
                    name: "web-1",
                    zone: "us-east1-b",
                    machine_type: "n2-standard-2",
                    status: "RUNNING",
                })?))
            }),
            |cfg| cfg,
        )
        .unwrap()
        .build()
        .unwrap();

    let cmd = Command::new("app").subcommand(Command::new("info"));
    let flag = match mode {
        Representation::Json => "--output=json",
        Representation::Yaml => "--output=yaml",
        Representation::Csv => "--output=csv",
        _ => unreachable!("test only dispatches structured modes"),
    };
    let target = TargetProperties {
        width: None,
        stdout_is_terminal: false,
        stderr_is_terminal: false,
        stdout_color_capability: false,
        stderr_color_capability: false,
        color_scheme: ColorMode::Dark,
        icon_mode: IconMode::Classic,
        ambiguous_width: AmbiguousWidth::Narrow,
    };
    let result = app.run_with(
        cmd,
        ["app", "info", flag],
        target,
        InputSources::from_process(),
    );
    result.output().unwrap().to_string()
}

fn assert_ascending(output: &str, needles: &[&str]) {
    let positions: Vec<usize> = needles
        .iter()
        .map(|n| {
            output
                .find(n)
                .unwrap_or_else(|| panic!("missing {n:?} in {output}"))
        })
        .collect();
    assert!(
        positions.windows(2).all(|w| w[0] < w[1]),
        "expected {needles:?} in ascending order, got {output}"
    );
}

#[test]
fn json_struct_fields_keep_declaration_order() {
    let json = dispatch(Representation::Json);
    assert_ascending(
        &json,
        &["\"name\"", "\"zone\"", "\"machine_type\"", "\"status\""],
    );
}

#[test]
fn yaml_struct_fields_keep_declaration_order() {
    let yaml = dispatch(Representation::Yaml);
    assert_ascending(&yaml, &["name:", "zone:", "machine_type:", "status:"]);
}

#[test]
fn csv_struct_fields_keep_declaration_order() {
    let csv = dispatch(Representation::Csv);
    assert_eq!(
        csv,
        "name,zone,machine_type,status\nweb-1,us-east1-b,n2-standard-2,RUNNING\n"
    );
}