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
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

//! This module contains primitives to create a spread row.
//! Ultimately it is a cell with a span set to a number of columns on the [`Table`].
//!
//! You can use a [`Span`] to set a custom span.
//!
//! # Example
//!
//! ```
//! use tabled::{Table, settings::Panel};
//!
//! let data = [[1, 2, 3], [4, 5, 6]];
//!
//! let table = Table::new(data)
//!     .with(Panel::vertical(1, "S\np\nl\ni\nt"))
//!     .with(Panel::header("Numbers"))
//!     .to_string();
//!
//! println!("{}", table);
//!
//! assert_eq!(
//!     table,
//!     concat!(
//!         "+---+---+---+---+\n",
//!         "| Numbers       |\n",
//!         "+---+---+---+---+\n",
//!         "| 0 | S | 1 | 2 |\n",
//!         "+---+ p +---+---+\n",
//!         "| 1 | l | 2 | 3 |\n",
//!         "+---+ i +---+---+\n",
//!         "| 4 | t | 5 | 6 |\n",
//!         "+---+---+---+---+",
//!     )
//! )
//! ```
//!
//! [`Table`]: crate::Table
//! [`Span`]: crate::settings::span::Span

mod footer;
mod header;
mod horizontal_panel;
mod vertical_panel;

pub use footer::Footer;
pub use header::Header;
pub use horizontal_panel::HorizontalPanel;
pub use vertical_panel::VerticalPanel;

/// Panel allows to add a Row which has 1 continues Cell to a [`Table`].
///
/// See `examples/panel.rs`.
///
/// [`Table`]: crate::Table
#[derive(Debug)]
pub struct Panel;

impl Panel {
    /// Creates an empty vertical row at given index.
    ///
    /// ```
    /// use tabled::{settings::Panel, Table};
    ///
    /// let data = [[1, 2, 3], [4, 5, 6]];
    ///
    /// let table = Table::new(data)
    ///     .with(Panel::vertical(1, "Tabled Releases"))
    ///     .to_string();
    ///
    /// println!("{}", table);
    ///
    /// assert_eq!(
    ///     table,
    ///     concat!(
    ///         "+---+-----------------+---+---+\n",
    ///         "| 0 | Tabled Releases | 1 | 2 |\n",
    ///         "+---+                 +---+---+\n",
    ///         "| 1 |                 | 2 | 3 |\n",
    ///         "+---+                 +---+---+\n",
    ///         "| 4 |                 | 5 | 6 |\n",
    ///         "+---+-----------------+---+---+",
    ///     )
    /// )
    /// ```
    pub fn vertical<S: AsRef<str>>(column: usize, text: S) -> VerticalPanel<S> {
        VerticalPanel::new(column, text)
    }

    /// Creates an empty horizontal row at given index.
    ///
    /// ```
    /// use tabled::{Table, settings::Panel};
    ///
    /// let data = [[1, 2, 3], [4, 5, 6]];
    ///
    /// let table = Table::new(data)
    ///     .with(Panel::vertical(1, ""))
    ///     .to_string();
    ///
    /// println!("{}", table);
    ///
    /// assert_eq!(
    ///     table,
    ///     concat!(
    ///         "+---+--+---+---+\n",
    ///         "| 0 |  | 1 | 2 |\n",
    ///         "+---+  +---+---+\n",
    ///         "| 1 |  | 2 | 3 |\n",
    ///         "+---+  +---+---+\n",
    ///         "| 4 |  | 5 | 6 |\n",
    ///         "+---+--+---+---+",
    ///     )
    /// )
    /// ```
    pub fn horizontal<S: AsRef<str>>(row: usize, text: S) -> HorizontalPanel<S> {
        HorizontalPanel::new(row, text)
    }

    /// Creates an horizontal row at first row.
    pub fn header<S: AsRef<str>>(text: S) -> Header<S> {
        Header::new(text)
    }

    /// Creates an horizontal row at last row.
    pub fn footer<S: AsRef<str>>(text: S) -> Footer<S> {
        Footer::new(text)
    }
}