numbat 1.23.0

A statically typed programming language for scientific computations with first class support for physical dimensions and units.
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use compact_str::{CompactString, ToCompactString};
use unicode_width::UnicodeWidthStr;

use crate::markup as m;
use crate::markup::{FormatType, FormattedString, Markup, OutputType};

/// Do not show tables wider than this for readabilty reasons
const MAX_WIDTH: usize = 160;

pub struct ColumnFormatter {
    terminal_width: usize,
    padding: usize,
}

impl ColumnFormatter {
    pub fn new(terminal_width: usize) -> Self {
        Self {
            terminal_width: terminal_width.min(MAX_WIDTH),
            padding: 2,
        }
    }

    pub fn format<S: AsRef<str>>(
        &self,
        entries: impl IntoIterator<Item = S>,
        format: FormatType,
    ) -> Markup {
        let mut result = m::empty();

        let entries: Vec<_> = entries
            .into_iter()
            .map(|s| s.as_ref().to_compact_string())
            .collect();

        if let Some(max_entry_width) = entries.iter().map(|s| s.width()).max() {
            let column_width = max_entry_width + self.padding;
            let min_num_columns = self.terminal_width / column_width;

            if min_num_columns < 1 {
                for entry in entries {
                    result +=
                        Markup::from(FormattedString(OutputType::Normal, format, entry.into()))
                            + m::whitespace(CompactString::const_new(" ").repeat(self.padding));
                }
                return result;
            }

            for num_columns in min_num_columns..=self.terminal_width {
                let num_rows = entries.len().div_ceil(num_columns);

                let mut table: Vec<Vec<Option<&str>>> = vec![vec![None; num_columns]; num_rows];
                for (idx, entry) in entries.iter().enumerate() {
                    let row = idx % num_rows;
                    let col = idx / num_rows;

                    table[row][col] = Some(entry);
                }

                let column_widths: Vec<usize> = (0..num_columns)
                    .map(|c| {
                        (0..num_rows)
                            .map(|r| table[r][c].map(|e| e.width()).unwrap_or(0))
                            .max()
                            .unwrap_or(0)
                            + self.padding
                    })
                    .collect();

                if column_widths.iter().sum::<usize>() > self.terminal_width {
                    // Return result from previous iteration
                    return result;
                }
                result = m::empty();

                for row in table {
                    for (col, entry) in row.iter().enumerate() {
                        if let Some(entry) = entry {
                            let width = entry.width();
                            let whitespace_length = column_widths[col] - width;

                            result += Markup::from(FormattedString(
                                OutputType::Normal,
                                format,
                                entry.to_compact_string().into(),
                            ));
                            result += m::whitespace(
                                CompactString::const_new(" ").repeat(whitespace_length),
                            );
                        } else {
                            break;
                        }
                    }
                    result += m::nl();
                }
            }
            result
        } else {
            result
        }
    }
}

#[cfg(test)]
fn format(width: usize, entries: &[&str]) -> CompactString {
    use crate::markup::{Formatter, PlainTextFormatter};

    let formatter = ColumnFormatter::new(width);
    PlainTextFormatter {}.format(&formatter.format(entries, FormatType::Text), false)
}

#[test]
fn test_column_formatter() {
    use insta::assert_snapshot;

    {
        let elements = &["one", "two", "three", "four", "five", "six", "seven"];

        assert_snapshot!(format(80, elements), @r###"
        one  two  three  four  five  six  seven  
        "###);

        assert_snapshot!(format(42, elements), @r###"
        one  two  three  four  five  six  seven  
        "###);

        assert_snapshot!(format(21, elements), @r###"
        one    four  seven  
        two    five  
        three  six   
        "###);

        assert_snapshot!(format(20, elements), @r###"
        one    four  seven  
        two    five  
        three  six   
        "###);

        assert_snapshot!(format(10, elements), @r###"
        one    
        two    
        three  
        four   
        five   
        six    
        seven  
        "###);

        assert_snapshot!(format(4, elements), @"one  two  three  four  five  six  seven  ");
    }

    assert_snapshot!(format(80, &["one"]), @"one");

    assert_snapshot!(format(80, &[]), @"");

    assert_snapshot!(format(12, &["aaaa", "bbbb", "cccc", "dddd"]), @r###"
    aaaa  cccc  
    bbbb  dddd  
    "###);
}