gilt 0.13.0

Fast, beautiful terminal formatting for Rust — styles, tables, trees, syntax highlighting, progress bars, markdown.
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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254

//! Group container demonstration
//!
//! Run: cargo run --example group_demo

use gilt::group::Group;
use gilt::panel::Panel;
use gilt::prelude::*;
use gilt::rule::Rule;
use gilt::table::Table;
use gilt::text::Text;

/// Convenience macro for creating a Group from a list of text items.
///
/// Similar to `vec![]` but wraps items in a Group.
macro_rules! group {
    ($($item:expr),* $(,)?) => {
        Group::new(vec![$($item),*])
    };
}

/// Convenience macro for creating a fit Group from a list of text items.
macro_rules! group_fit {
    ($($item:expr),* $(,)?) => {
        Group::fit(vec![$($item),*])
    };
}

fn main() {
    let mut console = Console::builder()
        .width(80)
        .force_terminal(true)
        .no_color(false)
        .build();

    console.rule(Some("Group Demo"));

    // ------------------------------------------------------------------------
    // 1. Basic Group Usage
    // ------------------------------------------------------------------------

    console.print(&Rule::with_title("1. Basic Group Usage"));

    // Creating a group with multiple Text items using Group::new()
    let items = vec![
        Text::from_markup("[bold blue]First item[/bold blue] in the group").unwrap(),
        Text::from_markup("[bold green]Second item[/bold green] in the group").unwrap(),
        Text::from_markup("[bold magenta]Third item[/bold magenta] in the group").unwrap(),
    ];
    let group = Group::new(items);
    console.print(&group);

    // Using the group![] macro for cleaner syntax
    console.print(&Rule::with_title("Using group![] macro"));
    let macro_group = group![
        Text::from_markup("Item created with [bold]group![][/bold] macro").unwrap(),
        Text::from_markup("[dim]Another item via macro[/dim]").unwrap(),
        Text::from_markup("[italic]Third macro item[/italic]").unwrap(),
    ];
    console.print(&macro_group);

    // ------------------------------------------------------------------------
    // 2. Fit Modes
    // ------------------------------------------------------------------------

    console.print(&Rule::with_title("2. Fit Modes"));

    // Fit mode true (content-sized) - uses Group::fit()
    console.print(&Rule::with_title("Fit mode: true (content-sized)"));
    let fit_group = Group::fit(vec![
        Text::from_markup("[on blue]Short[/on blue]").unwrap(),
        Text::from_markup("[on green]Medium length text[/on green]").unwrap(),
        Text::from_markup("[on red]Another short[/on red]").unwrap(),
    ]);
    console.print(&fit_group);
    console.print_text("  ^ This group is sized to its widest content");

    // Using group_fit![] macro
    console.print(&Rule::with_title("Using group_fit![] macro"));
    let fit_macro_group = group_fit![
        Text::from_markup("[on cyan]Macro fit[/on cyan]").unwrap(),
        Text::from_markup("[on yellow]Content sized[/on yellow]").unwrap(),
    ];
    console.print(&fit_macro_group);

    // Fit mode false (fills available width) - uses Group::new()
    console.print(&Rule::with_title("Fit mode: false (fills width)"));
    let fill_group = Group::new(vec![
        Text::from_markup(
            "[on bright_black]This group fills the available width[/on bright_black]",
        )
        .unwrap(),
        Text::from_markup("Notice how the content expands to fill the terminal").unwrap(),
    ]);
    console.print(&fill_group);

    // ------------------------------------------------------------------------
    // 3. Combining Different Renderables (via Text conversion)
    // ------------------------------------------------------------------------

    console.print(&Rule::with_title("3. Combining Different Renderables"));

    // Text and Panel combination
    console.print(&Rule::with_title("Text with Panel (rendered to text)"));

    let panel = Panel::new(Text::from_markup("[bold]Panel content[/bold] inside a group").unwrap())
        .with_title(Text::new("Inner Panel", Style::parse("cyan").unwrap()));

    // Render panel to text for inclusion in group
    let panel_text = render_to_text(&console, &panel);

    let mixed_group = Group::new(vec![
        Text::from_markup("[bold]Header text[/bold] above the panel:").unwrap(),
        panel_text,
        Text::from_markup("[dim]Footer text below the panel[/dim]").unwrap(),
    ]);
    console.print(&mixed_group);

    // Table and Rule combination
    console.print(&Rule::with_title("Table and Rule (rendered to text)"));

    let mut table = Table::grid(&["Key", "Value"]);
    table.add_row(&["Name", "Group Demo"]);
    table.add_row(&["Version", "1.0.0"]);
    table.add_row(&["Language", "Rust"]);

    let table_text = render_to_text(&console, &table);
    let rule_text = render_to_text(&console, &Rule::new());

    let table_group = Group::new(vec![
        Text::from_markup("[bold]Configuration:[/bold]").unwrap(),
        table_text,
        rule_text,
        Text::from_markup("[green]✓[/green] Setup complete").unwrap(),
    ]);
    console.print(&table_group);

    // Mixed content - various types combined
    console.print(&Rule::with_title("Mixed Content Group"));

    let info_panel = Panel::fit(
        Text::from_markup("[bold]Info[/bold]\nThis demonstrates mixed content").unwrap(),
    )
    .with_border_style(Style::parse("blue").unwrap());
    let info_text = render_to_text(&console, &info_panel);

    let mixed_content = Group::fit(vec![
        Text::from_markup("[bold underline]Summary[/bold underline]").unwrap(),
        info_text,
        Text::from_markup("[dim]───────────────[/dim]").unwrap(),
        Text::from_markup("Status: [green]Active[/green] | Load: [yellow]Moderate[/yellow]")
            .unwrap(),
    ]);
    console.print(&mixed_content);

    // ------------------------------------------------------------------------
    // 4. Nesting Groups Within Other Widgets
    // ------------------------------------------------------------------------

    console.print(&Rule::with_title("4. Nesting Groups Within Other Widgets"));

    // Group inside a Panel
    console.print(&Rule::with_title("Group inside a Panel"));

    let inner_group = Group::fit(vec![
        Text::from_markup("[bold]Line 1[/bold] of inner group").unwrap(),
        Text::from_markup("[bold]Line 2[/bold] of inner group").unwrap(),
        Text::from_markup("[dim]Line 3 (dimmed)[/dim]").unwrap(),
    ]);
    let inner_group_text = render_to_text(&console, &inner_group);

    let panel_with_group = Panel::new(inner_group_text)
        .with_title(Text::new(
            "Panel Containing Group",
            Style::parse("bold magenta").unwrap(),
        ))
        .with_border_style(Style::parse("green").unwrap());
    console.print(&panel_with_group);

    // Multiple groups in a Columns-like layout (using a container panel)
    console.print(&Rule::with_title("Multiple Groups in Layout"));

    let group_a = Group::fit(vec![
        Text::from_markup("[on blue][white] Group A [/white][/on blue]").unwrap(),
        Text::new("Item A1", Style::null()),
        Text::new("Item A2", Style::null()),
    ]);

    let group_b = Group::fit(vec![
        Text::from_markup("[on red][white] Group B [/white][/on red]").unwrap(),
        Text::new("Item B1", Style::null()),
        Text::new("Item B2", Style::null()),
    ]);

    // Combine groups vertically in a container
    let combined = Group::new(vec![
        render_to_text(&console, &group_a),
        Text::new("", Style::null()), // spacing
        render_to_text(&console, &group_b),
    ]);

    let outer_panel = Panel::new(render_to_text(&console, &combined)).with_title(Text::new(
        "Container with Nested Groups",
        Style::parse("bold cyan").unwrap(),
    ));
    console.print(&outer_panel);

    // Nested groups (group within a group)
    console.print(&Rule::with_title("Nested Groups"));

    let inner_nested = Group::fit(vec![
        Text::from_markup("[yellow]  → Inner nested item 1[/yellow]").unwrap(),
        Text::from_markup("[yellow]  → Inner nested item 2[/yellow]").unwrap(),
    ]);

    let outer_nested = Group::new(vec![
        Text::from_markup("[bold]Outer group start[/bold]").unwrap(),
        render_to_text(&console, &inner_nested),
        Text::from_markup("[bold]Outer group end[/bold]").unwrap(),
    ]);
    console.print(&outer_nested);

    // ------------------------------------------------------------------------
    // 5. Practical Use Case: Status Display
    // ------------------------------------------------------------------------

    console.print(&Rule::with_title("5. Practical Example: Status Display"));

    let status_group = Group::fit(vec![
        Text::from_markup("[bold underline]System Status[/bold underline]").unwrap(),
        Text::from_markup("[green]●[/green] Database: Connected").unwrap(),
        Text::from_markup("[green]●[/green] Cache: Operational").unwrap(),
        Text::from_markup("[yellow]●[/yellow] Queue: 12 pending").unwrap(),
        Text::from_markup("[red]●[/red] Backup: Overdue").unwrap(),
        Text::from_markup("[dim]─────────────────[/dim]").unwrap(),
        Text::from_markup("Last update: [italic]Just now[/italic]").unwrap(),
    ]);

    let status_panel = Panel::new(render_to_text(&console, &status_group))
        .with_title(Text::new("Dashboard", Style::parse("bold white").unwrap()))
        .with_border_style(Style::parse("bright_black").unwrap());
    console.print(&status_panel);

    console.rule(Some("End of Demo"));
}

/// Render a Renderable to a Text object by capturing console output.
fn render_to_text(console: &Console, renderable: &dyn Renderable) -> Text {
    let segments = console.render(renderable, None);
    let mut text = Text::empty();
    for seg in &segments {
        text.append_str(&seg.text, seg.style().cloned());
    }
    text
}