tabled 0.20.0

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

use tabled::{assert::assert_table, settings::style::Style, tables::CompactTable};

fn main() {
    let data = [
        ["Debian", "1.1.1.1", "true"],
        ["Arch", "127.1.1.1", "true"],
        ["Manjaro", "Arch", "true"],
    ];

    let table = CompactTable::from(data).with(Style::modern());
    let mut buf = [0; 1024 * 10];
    let mut w = Writer::new(&mut buf);

    table.fmt(&mut w).unwrap();

    assert_table!(w.as_str(),
        "┌─────────┬───────────┬──────┐"
        "│ Debian  │ 1.1.1.1   │ true │"
        "│─────────┼───────────┼──────│"
        "│ Arch    │ 127.1.1.1 │ true │"
        "│─────────┼───────────┼──────│"
        "│ Manjaro │ Arch      │ true │"
        "└─────────┴───────────┴──────┘"
    );
}

struct Writer<'a> {
    buf: &'a mut [u8],
    cursor: usize,
}

impl<'a> Writer<'a> {
    fn new(buf: &'a mut [u8]) -> Self {
        Self { buf, cursor: 0 }
    }

    fn as_str(&self) -> &str {
        core::str::from_utf8(&self.buf[0..self.cursor]).unwrap()
    }
}

impl core::fmt::Write for Writer<'_> {
    fn write_str(&mut self, s: &str) -> core::fmt::Result {
        let cap = self.buf.len();

        for (i, &b) in self.buf[self.cursor..cap]
            .iter_mut()
            .zip(s.as_bytes().iter())
        {
            *i = b;
        }

        self.cursor = usize::min(cap, self.cursor + s.len());

        Ok(())
    }
}