crabular 0.7.0

A high-performance ASCII table library for Rust
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

use crate::Alignment;

#[derive(Clone)]
pub struct Cell {
    content: String,
    alignment: Alignment,
    span: usize,
}

impl Cell {
    #[must_use]
    pub fn new(content: &str, alignment: Alignment) -> Self {
        Self {
            content: content.to_string(),
            alignment,
            span: 1,
        }
    }

    #[must_use]
    pub fn content(&self) -> &str {
        &self.content
    }

    #[must_use]
    pub fn alignment(&self) -> Alignment {
        self.alignment
    }

    #[must_use]
    pub fn span(&self) -> usize {
        self.span
    }

    pub fn set_span(&mut self, span: usize) {
        self.span = span.max(1);
    }

    pub fn set_alignment(&mut self, alignment: Alignment) {
        self.alignment = alignment;
    }
}

impl core::fmt::Display for Cell {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        write!(f, "{}", self.content)
    }
}

#[cfg(test)]
mod tests {
    use crate::{Alignment, Cell};

    #[test]
    fn creation() {
        let cases = [
            ("hello", Alignment::Left),
            ("world", Alignment::Center),
            ("test", Alignment::Right),
            ("", Alignment::Left),
        ];
        for (content, alignment) in cases {
            let cell = Cell::new(content, alignment);
            assert_eq!(cell.content(), content);
            assert_eq!(cell.alignment(), alignment);
            assert_eq!(cell.span(), 1);
        }
    }

    #[test]
    fn set_span() {
        let cases = [1, 2, 3, 5, 10];
        for span in cases {
            let mut cell = Cell::new("test", Alignment::Left);
            cell.set_span(span);
            assert_eq!(cell.span(), span);
        }
    }

    #[test]
    fn set_alignment() {
        let mut cell = Cell::new("test", Alignment::Left);

        cell.set_alignment(Alignment::Right);
        assert_eq!(cell.alignment(), Alignment::Right);

        cell.set_alignment(Alignment::Center);
        assert_eq!(cell.alignment(), Alignment::Center);
    }

    #[test]
    fn clone_trait() {
        let cell = Cell::new("test", Alignment::Center);
        let cloned = cell.clone();
        assert_eq!(cell.content(), cloned.content());
        assert_eq!(cell.alignment(), cloned.alignment());
        assert_eq!(cell.span(), cloned.span());
    }

    #[test]
    fn span_preserved_on_clone() {
        let mut cell = Cell::new("test", Alignment::Left);
        cell.set_span(3);
        let cloned = cell.clone();
        assert_eq!(cloned.span(), 3);
    }

    #[test]
    fn display_trait_content() {
        let cell = Cell::new("hello world", Alignment::Left);
        let displayed = format!("{cell}");
        assert_eq!(displayed, "hello world");
    }

    #[test]
    fn display_trait_empty() {
        let cell = Cell::new("", Alignment::Center);
        let displayed = format!("{cell}");
        assert_eq!(displayed, "");
    }

    #[test]
    fn display_trait_unicode() {
        let cell = Cell::new("日本語", Alignment::Right);
        let displayed = format!("{cell}");
        assert_eq!(displayed, "日本語");
    }
}