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

//! This module contains a [`Span`] settings, it helps to
//! make a cell take more space then it generally takes.
//!
//! # Example
//!
//! ```rust,no_run
//! # use tabled::{Table, settings::{Style, Span, Modify, object::Columns}};
//! # let data: Vec<&'static str> = Vec::new();
//! let mut table = Table::new(&data);
//! table.modify(Columns::one(0), Span::column(2));
//! ```

mod column;
mod row;

pub use column::ColumnSpan;
pub use row::RowSpan;

/// Span represent a horizontal/column span setting for any cell on a [`Table`].
///
/// ```
/// use tabled::{settings::{Span, Modify}, Table};
/// use tabled::assert::assert_table;
///
/// let data = [[1, 2, 3], [4, 5, 6]];
///
/// let mut table = Table::new(data);
/// table.modify((0, 0), Span::row(2));
/// table.modify((0, 1), Span::column(2));
/// table.modify((2, 0), Span::column(1000));
///
/// assert_table!(
///     table,
///     "+---+---+---+"
///     "| 0 | 1     |"
///     "+   +---+---+"
///     "|   | 2 | 3 |"
///     "+---+---+---+"
///     "| 4         |"
///     "+---+---+---+"
/// );
/// ```
///
/// [`Table`]: crate::Table
#[derive(Debug)]
pub struct Span;

impl Span {
    /// New constructs a horizontal/column [`Span`].
    ///
    /// Value can be:
    ///     * == 0 - which means spread the cell on the whole line
    ///     * == 1 - which is a default span so can be used for removal of spans
    ///     * > 1 - which means to spread a cell by given number of columns right
    ///     * < 0 - which means to spread a cell by given number of columns left
    ///
    /// # Example
    ///
    /// ```
    /// use tabled::{settings::{Span, Modify}, Table};
    ///
    /// let data = [[1, 2, 3], [4, 5, 6]];
    ///
    /// let table = Table::new(data)
    ///     .modify((0, 0), Span::column(100))
    ///     .modify((1, 1), Span::column(2))
    ///     .modify((2, 1), Span::column(-1))
    ///     .to_string();
    ///
    /// assert_eq!(
    ///     table,
    ///     concat!(
    ///         "+---++---+\n",
    ///         "| 0      |\n",
    ///         "+---++---+\n",
    ///         "| 1 | 2  |\n",
    ///         "+---++---+\n",
    ///         "| 5  | 6 |\n",
    ///         "+---++---+",
    ///     )
    /// )
    /// ```
    pub fn column(size: isize) -> ColumnSpan {
        ColumnSpan::new(size)
    }

    /// New constructs a vertical/row [`Span`].
    ///
    /// Value can be:
    ///     * == 0 - which means spread the cell on the whole line
    ///     * == 1 - which is a default span so can be used for removal of spans
    ///     * > 1 - which means to spread a cell by given number of rows bottom
    ///     * < 0 - which means to spread a cell by given number of rows top
    ///
    /// # Example
    ///
    /// ```
    /// use tabled::{settings::{Span, Modify}, Table};
    ///
    /// let data = [[1, 2, 3], [4, 5, 6]];
    ///
    /// let table = Table::new(data)
    ///     .modify((0, 0), Span::row(100))
    ///     .modify((1, 1), Span::row(2))
    ///     .modify((2, 2), Span::row(-1))
    ///     .to_string();
    ///
    /// assert_eq!(
    ///     table,
    ///     concat!(
    ///         "+---+---+---+\n",
    ///         "| 0 | 1 | 2 |\n",
    ///         "+   +---+---+\n",
    ///         "+   + 2 + 6 +\n",
    ///         "+---+---+---+",
    ///     )
    /// )
    /// ```
    pub fn row(size: isize) -> RowSpan {
        RowSpan::new(size)
    }
}