Crate tabled[−][src]

Expand description

An easy to use library for pretty print tables of Rust structs and enums.

Get started

The common and probably the best way to begin is to annotate your type with #[derive(Tabled)]. You can also implement it on your own as well.

    use tabled::{Tabled, Table};

    #[derive(Tabled)]
    struct Language {
        name: &'static str,
        designed_by: &'static str,
        invented_year: usize,
    }

    let languages = vec![
        Language{
            name: "C",
            designed_by: "Dennis Ritchie",
            invented_year: 1972
        },
        Language{
            name: "Rust",
            designed_by: "Graydon Hoare",
            invented_year: 2010
        },
        Language{
            name: "Go",
            designed_by: "Rob Pike",
            invented_year: 2009
        },
    ];

    let table = Table::new(languages).to_string();

    let expected = "+------+----------------+---------------+\n\
                    | name |  designed_by   | invented_year |\n\
                    +------+----------------+---------------+\n\
                    |  C   | Dennis Ritchie |     1972      |\n\
                    +------+----------------+---------------+\n\
                    | Rust | Graydon Hoare  |     2010      |\n\
                    +------+----------------+---------------+\n\
                    |  Go  |    Rob Pike    |     2009      |\n\
                    +------+----------------+---------------+\n";

    assert_eq!(table, expected);

We must to know what we print in the field accordingly each field should implement std::fmt::Display The example below is not compiled

    #[derive(Tabled)]
    struct SomeType {
        field1: SomeOtherType,
    }

    struct SomeOtherType;

Most of the default types implements the trait out of the box.

    use tabled::{Tabled, Table};
    let some_numbers = [1, 2, 3];
    let table = Table::new(&some_numbers);

You also can combine structures by means of tuples.

    use tabled::{Tabled, Table, Style};

    #[derive(Tabled)]
    enum Domain {
        Security,
        Embeded,
        Frontend,
        Unknown,
    }

    #[derive(Tabled)]
    struct Developer(#[header("name")] &'static str);
     
    let data = vec![
        (Developer("Terri Kshlerin"), Domain::Embeded),
        (Developer("Catalina Dicki"), Domain::Security),
        (Developer("Jennie Schmeler"), Domain::Frontend),
        (Developer("Maxim Zhiburt"), Domain::Unknown),
    ];
     
    let table = Table::new(data).with(Style::psql()).to_string();

    assert_eq!(
        table,
        concat!(
            "      name       | Security | Embeded | Frontend | Unknown \n",
            "-----------------+----------+---------+----------+---------\n",
            " Terri Kshlerin  |          |    +    |          |         \n",
            " Catalina Dicki  |    +     |         |          |         \n",
            " Jennie Schmeler |          |         |    +     |         \n",
            "  Maxim Zhiburt  |          |         |          |    +    \n"
        )
    );