standout 7.2.0

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

use clap::Command;
use console::Style;
use proptest::prelude::*;
use serde_json::{json, Value};
use serde_yaml;
use standout::cli::{App, Output};
use standout::{OutputMode, Theme};

// Strategy for generating arbitrary OutputMode values
// Per design guidelines: all 8 output modes must be covered
fn output_mode_strategy() -> impl Strategy<Value = OutputMode> {
    prop_oneof![
        Just(OutputMode::Auto),
        Just(OutputMode::Term),
        Just(OutputMode::Text),
        Just(OutputMode::TermDebug),
        Just(OutputMode::Json),
        Just(OutputMode::Yaml),
        Just(OutputMode::Xml),
        Just(OutputMode::Csv),
    ]
}

// Strategy for generating arbitrary Themes
// Tests: no theme, empty theme, and populated theme with styles
fn theme_strategy() -> impl Strategy<Value = Option<Theme>> {
    prop_oneof![
        Just(None),
        Just(Some(Theme::new())),
        Just(Some(
            Theme::new()
                .add("title", Style::new().bold())
                .add("highlight", Style::new().cyan())
                .add("error", Style::new().red().bold())
        )),
    ]
}

// Strategy for generating template variations
// Tests different rendering paths that work with any JSON input
fn template_strategy() -> impl Strategy<Value = &'static str> {
    prop_oneof![
        // Simple dump - basic MiniJinja path
        Just("{{ . }}"),
        // With style tags - exercises BBParser
        Just("[title]{{ . }}[/title]"),
        // Nested style tags
        Just("[highlight]Output: [title]{{ . }}[/title][/highlight]"),
    ]
}

// Strategy for generating arbitrary JSON data
fn json_data_strategy() -> impl Strategy<Value = Value> {
    let leaf = prop_oneof![
        Just(Value::Null),
        any::<bool>().prop_map(Value::Bool),
        any::<f64>().prop_map(|f| json!(f)),
        "[a-zA-Z0-9]*".prop_map(Value::String),
    ];
    leaf.prop_recursive(
        4,  // 4 levels deep
        64, // Max size 64 nodes
        10, // Items per collection
        |inner| {
            prop_oneof![
                prop::collection::vec(inner.clone(), 0..10).prop_map(Value::Array),
                prop::collection::hash_map("[a-zA-Z0-9]*", inner, 0..10)
                    .prop_map(|m| { Value::Object(m.into_iter().collect()) })
            ]
        },
    )
}

/// Helper to validate structured output
fn validate_structured_output(output: &str, mode: OutputMode) {
    match mode {
        OutputMode::Json => {
            let parsed: Result<Value, _> = serde_json::from_str(output);
            assert!(
                parsed.is_ok(),
                "JSON output should be parseable: {}",
                output
            );
        }
        OutputMode::Yaml => {
            let parsed: Result<Value, _> = serde_yaml::from_str(output);
            assert!(
                parsed.is_ok(),
                "YAML output should be parseable: {}",
                output
            );
        }
        OutputMode::Xml => {
            // XML output must be non-empty and contain a root element
            assert!(!output.is_empty(), "XML output should not be empty");
            assert!(
                output.contains('<') && output.contains('>'),
                "XML output should contain tags: {}",
                output
            );
        }
        OutputMode::Csv => {
            // CSV output must be non-empty
            assert!(!output.is_empty(), "CSV output should not be empty");
        }
        _ => {}
    }
}

proptest! {
    /// Property test for rendering invariants across all output modes
    #[test]
    fn test_rendering_invariants(
        mode in output_mode_strategy(),
        theme in theme_strategy(),
        template in template_strategy(),
        data in json_data_strategy()
    ) {
        let builder = App::builder()
            .command(
                "test",
                move |_m, _ctx| Ok(Output::Render(data.clone())),
                template,
            ).unwrap();

        let builder = if let Some(t) = theme {
            builder.theme(t)
        } else {
            builder
        };

        let app = builder.build().expect("Failed to build app");

        let cmd = Command::new("app").subcommand(Command::new("test"));
        let matches = cmd.try_get_matches_from(["app", "test"]).unwrap();

        let result = app.dispatch(matches, mode);

        // Invariants
        assert!(result.is_handled());
        if let Some(output) = result.output() {
            validate_structured_output(output, mode);
        }
    }
}