text-grid 0.4.1

A library to create formatted plain-text tables.
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

use std::{borrow::Borrow, io::Write};

use csv::{StringRecord, Writer};

use crate::{CellsFormatter, CellsSchema, CellsWrite, RawCell};

pub fn write_csv<T>(
    csv_writer: &mut Writer<impl Write>,
    source: impl IntoIterator<Item = impl Borrow<T>>,
    schema: impl CellsSchema<Source = T>,
    separator: &str,
) -> csv::Result<()> {
    let source = source.into_iter();
    let mut w = CsvHeaderWriter::new(separator);
    schema.fmt(&mut CellsFormatter::new(&mut w, None));
    csv_writer.write_record(&w.record)?;

    let mut w = CsvBodyWriter::new();
    for item in source {
        schema.fmt(&mut CellsFormatter::new(&mut w, Some(item.borrow())));
        csv_writer.write_record(&w.record)?;
        w.record.clear();
    }
    Ok(())
}

struct CsvHeaderWriter<'a> {
    pub record: StringRecord,
    value: String,
    lens: Vec<usize>,
    has_content: bool,
    separator: &'a str,
}
impl<'a> CsvHeaderWriter<'a> {
    fn new(separator: &'a str) -> Self {
        Self {
            record: StringRecord::new(),
            value: String::new(),
            lens: Vec::new(),
            has_content: false,
            separator,
        }
    }
}

impl<'a> CellsWrite for CsvHeaderWriter<'a> {
    fn content(&mut self, _cell: Option<&dyn RawCell>, _stretch: bool) {
        self.has_content = true;
    }

    fn content_start(&mut self, _cell: &dyn RawCell) {}
    fn content_end(&mut self, _cell: &dyn RawCell) {}

    fn column_start(&mut self, header: &dyn RawCell) {
        self.lens.push(self.value.len());
        if !self.value.is_empty() {
            self.value.push_str(self.separator);
        }
        header.fmt(&mut self.value);
    }

    fn column_end(&mut self, _header: &dyn RawCell) {
        if self.has_content {
            self.record.push_field(&self.value);
            self.has_content = false;
        }
        self.value.truncate(self.lens.pop().unwrap());
    }
}

struct CsvBodyWriter {
    pub record: StringRecord,
    value: String,
    is_merged: bool,
    has_content: bool,
}

impl CsvBodyWriter {
    fn new() -> Self {
        Self {
            record: StringRecord::new(),
            value: String::new(),
            is_merged: false,
            has_content: false,
        }
    }
}

impl CellsWrite for CsvBodyWriter {
    fn content(&mut self, cell: Option<&dyn RawCell>, _stretch: bool) {
        if let Some(cell) = cell {
            cell.fmt(&mut self.value);
        }
        self.has_content = true;
    }

    fn content_start(&mut self, cell: &dyn RawCell) {
        self.is_merged = true;
        cell.fmt(&mut self.value);
    }

    fn content_end(&mut self, _cell: &dyn RawCell) {
        self.is_merged = false;
    }

    fn column_start(&mut self, _header: &dyn RawCell) {}

    fn column_end(&mut self, _header: &dyn RawCell) {
        if self.has_content {
            self.record.push_field(&self.value);
            self.value.clear();
            self.has_content = false;
        }
    }
}