table-format 0.0.5

Formats tables for printing to terminals and logs.
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use colored::Color;

#[derive(Debug)]
pub struct Border {
    pub top_left: char,
    pub top: char,
    pub top_right: char,
    pub top_split: char,
    pub bottom_left: char,
    pub bottom: char,
    pub bottom_right: char,
    pub bottom_split: char,
    pub left: char,
    pub left_split: char,
    pub right: char,
    pub right_split: char,
    pub vertical_split: char,
    pub vertical_split_intersect_left: char,
    pub vertical_split_intersect_right: char,
    pub vertical_split_intersect_both: char,
    pub horizontal_split: char,
    pub horizontal_split_intersect_top: char,
    pub horizontal_split_intersect_bottom: char,
    pub horizontal_split_intersect_both: char,
    pub color: Color
}

impl Border {
    #[must_use]
    pub fn default() -> Border {
        Border {
            top_left: '+',
            top: '-',
            top_right: '+',
            top_split: '+',
            bottom_left: '+',
            bottom: '-',
            bottom_right: '+',
            bottom_split: '+',
            left: '|',
            left_split: '+',
            right: '|',
            right_split: '+',
            vertical_split: '|',
            vertical_split_intersect_left: '+',
            vertical_split_intersect_right: '+',
            vertical_split_intersect_both: '+',
            horizontal_split: '-',
            horizontal_split_intersect_top: '+',
            horizontal_split_intersect_bottom: '+',
            horizontal_split_intersect_both: '+',
            color: Color::Cyan
        }
    }

    /// Formats the top border
    #[must_use]
    pub fn format_top(
        self: &Border,
        widths: &[usize]
    ) -> String {
        let mut result: String = String::from(self.top_left);
        for ix in 0..widths.len() {
            result.push_str(
              &(0..widths[ix])
                  .map(|_| self.top)
                  .collect::<String>()
            );
            if ix < widths.len() - 1 {
               result.push_str(String::from(self.top_split).as_str());
            }
        }
        result.push_str(String::from(self.top_right).as_str());
        result
    }

    /// Formats the bottom border
    #[must_use]
    pub fn format_bottom(
        self: &Border,
        widths: &[usize]
    ) -> String {
        let mut result: String = String::from(self.bottom_left);
        for ix in 0..widths.len() {
            result.push_str(
                &(0..widths[ix])
                    .map(|_| self.bottom)
                    .collect::<String>()
            );
            if ix < widths.len() - 1 {
                result.push_str(String::from(self.bottom_split).as_str());
            }
        }
        result.push_str(String::from(self.bottom_right).as_str());
        result
    }

    /// Formats the left border.
    #[must_use]
    pub fn format_left(
        self: &Border
    ) -> String {
        format!("{}", self.left)
    }

    /// Formats the right border.
    #[must_use]
    pub fn format_right(
        self: &Border
    ) -> String {
        format!("{}", self.right)
    }

    /// Formats a horizontal split.
    #[must_use]
    pub fn format_horizontal_split(
        self: &Border,
        widths: &[usize]
    ) -> String {
        let mut result: String = String::from(self.left_split);
        for ix in 0..widths.len() {
            result.push_str(
                &(0..widths[ix])
                    .map(|_| self.horizontal_split)
                    .collect::<String>()
            );
            if ix < widths.len() - 1 {
                result.push_str(
                    String::from(self.horizontal_split_intersect_both).as_str()
                );
            }
        }
        result.push_str(String::from(self.right_split).as_str());
        result
    }

    /// Formats a vertical split.
    #[must_use]
    pub fn format_vertical_split(
        self: &Border
    ) -> String {
        format!("{}", self.vertical_split)
    }
}