tabled 0.9.0

An easy to use library for pretty print tables of Rust `struct`s and `enum`s.
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

//! The example can be run by this command
//! `cargo run --example nested_table`
//!
//! The table is a take on the one from https://github.com/p-ranav/tabulate#nested-tables/

use std::iter::FromIterator;

use tabled::{
    builder::Builder,
    object::{Rows, Segment},
    style::HorizontalLine,
    Alignment, Modify, Padding, Style, Table, Width,
};

fn main() {
    let animal = create_class(
        "Animal",
        &[("age", "Int", ""), ("gender", "String", "")],
        &["isMammal", "mate"],
    );

    let duck = create_class(
        "Duck",
        &[("beakColor", "String", "yellow")],
        &["swim", "quack"],
    );

    let mut table = Builder::from_iter([
        [animal.to_string()],
        [String::from("▲")],
        [String::from("|")],
        [String::from("|")],
        [duck.to_string()],
    ])
    .build();
    table.with(Style::ascii().off_horizontal()).with(
        Modify::new(Segment::all())
            .with(Padding::new(5, 5, 0, 0))
            .with(Alignment::center()),
    );

    println!("{}", table);
}

fn create_class(name: &str, fields: &[(&str, &str, &str)], methods: &[&str]) -> Table {
    let mut table_fields = Builder::from_iter(fields.iter().map(|(field, t, d)| {
        if d.is_empty() {
            [format!("+{}: {}", field, t)]
        } else {
            [format!("+{}: {} = {:?}", field, t, d)]
        }
    }))
    .build();
    table_fields.with(Style::ascii().off_horizontal().off_vertical());

    let mut table_methods =
        Builder::from_iter(methods.iter().map(|method| [format!("+{}()", method)])).build();
    table_methods.with(Style::ascii().off_horizontal().off_vertical());

    let (table_fields, table_methods) = make_equal_width(table_fields, table_methods);

    let mut builder = Builder::default();
    builder
        .add_record([table_fields.to_string()])
        .add_record([table_methods.to_string()])
        .set_columns([name.to_string()]);

    let mut table = builder.build();
    table
        .with(
            Style::ascii()
                .horizontals([HorizontalLine::new(1, Style::ascii().get_horizontal())])
                .off_horizontal()
                .off_vertical(),
        )
        .with(Modify::new(Segment::all()).with(Alignment::left()))
        .with(Modify::new(Rows::first()).with(Alignment::center()));

    table
}

fn make_equal_width(mut table1: Table, mut table2: Table) -> (Table, Table) {
    // We want to make a fields table and methods table to have the same width.
    // To not set it to constant, we check a width of each of them and correct the other.
    //
    // it's safe to do .len() because we use ascii theme and no colors.

    let table1_width = table1.to_string().lines().next().unwrap().len();
    let table2_width = table2.to_string().lines().next().unwrap().len();
    match table1_width.cmp(&table2_width) {
        std::cmp::Ordering::Less => {
            table1.with(Width::increase(table2_width));
        }
        std::cmp::Ordering::Greater => {
            table2.with(Width::increase(table1_width));
        }
        std::cmp::Ordering::Equal => (),
    }

    (table1, table2)
}