Skip to main content

cellix_doc/
table.rs

1//! Editing a Markdown table as a table. Every change rewrites it with its columns lined up,
2//! so the source stays as readable as the page.
3
4/// What can be done to a table, from the cell the caret is in.
5#[derive(Clone, Copy, Debug, PartialEq, Eq)]
6pub enum Edit {
7    RowAbove,
8    RowBelow,
9    ColumnLeft,
10    ColumnRight,
11    DeleteRow,
12    DeleteColumn,
13    Align(Align),
14    Delete,
15}
16
17#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
18pub enum Align {
19    #[default]
20    Default,
21    Left,
22    Centre,
23    Right,
24}
25
26/// The rows, the alignment of each column, without the rule between header and body.
27#[derive(Debug, PartialEq, Eq)]
28struct Table {
29    rows: Vec<Vec<String>>,
30    aligns: Vec<Align>,
31}
32
33/// Splits a row at its pipes, leaving `\|` and pipes in code alone.
34fn cells(line: &str) -> Vec<String> {
35    let text = line.trim();
36    let text = text.strip_prefix('|').unwrap_or(text);
37    let text = text.strip_suffix('|').unwrap_or(text);
38    let mut out = vec![String::new()];
39    let (mut escaped, mut code) = (false, false);
40    for c in text.chars() {
41        if c == '|' && !escaped && !code {
42            out.push(String::new());
43        } else if let Some(cell) = out.last_mut() {
44            cell.push(c);
45        }
46        code ^= c == '`';
47        escaped = c == '\\' && !escaped;
48    }
49    out.iter().map(|c| c.trim().to_string()).collect()
50}
51
52fn align_of(cell: &str) -> Align {
53    match (cell.starts_with(':'), cell.ends_with(':')) {
54        (true, true) => Align::Centre,
55        (true, false) => Align::Left,
56        (false, true) => Align::Right,
57        _ => Align::Default,
58    }
59}
60
61fn parse(text: &str) -> Option<Table> {
62    let lines: Vec<&str> = text.lines().collect();
63    let rule = lines.get(1)?;
64    let aligns: Vec<Align> = cells(rule).iter().map(|c| align_of(c)).collect();
65    let mut rows: Vec<Vec<String>> = lines
66        .iter()
67        .enumerate()
68        .filter(|(index, _)| *index != 1)
69        .map(|(_, line)| cells(line))
70        .collect();
71    let columns = rows
72        .iter()
73        .map(Vec::len)
74        .chain([aligns.len()])
75        .max()
76        .unwrap_or(1);
77    for row in &mut rows {
78        row.resize(columns, String::new());
79    }
80    let mut aligns = aligns;
81    aligns.resize(columns, Align::Default);
82    Some(Table { rows, aligns })
83}
84
85fn print(table: &Table) -> String {
86    let columns = table.aligns.len();
87    let widths: Vec<usize> = (0..columns)
88        .map(|c| {
89            let longest = table.rows.iter().map(|r| r[c].chars().count());
90            longest.max().unwrap_or(0).max(3)
91        })
92        .collect();
93    let line = |row: &[String]| {
94        let shown: Vec<String> = row
95            .iter()
96            .zip(&widths)
97            .map(|(cell, width)| format!("{cell:<width$}"))
98            .collect();
99        format!("| {} |", shown.join(" | "))
100    };
101    let rule: Vec<String> = table
102        .aligns
103        .iter()
104        .zip(&widths)
105        .map(|(align, width)| {
106            let dashes = width.saturating_sub(match align {
107                Align::Centre => 2,
108                Align::Default => 0,
109                _ => 1,
110            });
111            let dashes = "-".repeat(dashes);
112            match align {
113                Align::Default => dashes,
114                Align::Left => format!(":{dashes}"),
115                Align::Right => format!("{dashes}:"),
116                Align::Centre => format!(":{dashes}:"),
117            }
118        })
119        .collect();
120    let mut out = vec![line(&table.rows[0]), format!("| {} |", rule.join(" | "))];
121    out.extend(table.rows[1..].iter().map(|row| line(row)));
122    out.join("\n")
123}
124
125/// Where a cell's text starts in printed table text, in chars.
126pub fn cell_offset(text: &str, row: usize, column: usize) -> usize {
127    let line = if row == 0 { 0 } else { row + 1 };
128    let mut at = 0;
129    for (index, source) in text.split('\n').enumerate() {
130        if index == line {
131            let mut pipes = 0;
132            for (i, c) in source.chars().enumerate() {
133                if c == '|' {
134                    pipes += 1;
135                    if pipes == column + 1 {
136                        return at + i + 2;
137                    }
138                }
139            }
140        }
141        at += source.chars().count() + 1;
142    }
143    0
144}
145
146/// Applies an edit to a table's text, from the cell at `(row, column)`, counting the header
147/// as row zero and leaving out the rule. Returns the new text, and the cell to land in.
148/// Deleting the table, or its only row or column, returns None for the text.
149pub fn apply(text: &str, row: usize, column: usize, edit: Edit) -> Option<(String, usize, usize)> {
150    let mut table = parse(text)?;
151    let columns = table.aligns.len();
152    let blank = || vec![String::new(); columns];
153    let (mut row, mut column) = (row.min(table.rows.len() - 1), column.min(columns - 1));
154    match edit {
155        // A table always has its header, so a row above that goes under it.
156        Edit::RowAbove if row == 0 => {
157            table.rows.insert(1, blank());
158            row = 1;
159        }
160        Edit::RowAbove => table.rows.insert(row, blank()),
161        Edit::RowBelow => {
162            table.rows.insert(row + 1, blank());
163            row += 1;
164        }
165        Edit::ColumnLeft | Edit::ColumnRight => {
166            let at = column + usize::from(edit == Edit::ColumnRight);
167            for cells in &mut table.rows {
168                cells.insert(at, String::new());
169            }
170            table.aligns.insert(at, Align::Default);
171            column = at;
172        }
173        Edit::DeleteRow if table.rows.len() == 1 => return None,
174        Edit::DeleteRow if row == 0 => {
175            // The first body row becomes the header.
176            table.rows.remove(0);
177        }
178        Edit::DeleteRow => {
179            table.rows.remove(row);
180            row = row.min(table.rows.len() - 1);
181        }
182        Edit::DeleteColumn if columns == 1 => return None,
183        Edit::DeleteColumn => {
184            for cells in &mut table.rows {
185                cells.remove(column);
186            }
187            table.aligns.remove(column);
188            column = column.min(columns - 2);
189        }
190        Edit::Align(align) => table.aligns[column] = align,
191        Edit::Delete => return None,
192    }
193    Some((print(&table), row, column))
194}
195
196/// Which field a row of data is at, given the text before the caret.
197pub fn field_of(before: &str, separator: char) -> usize {
198    let mut quoted = false;
199    let mut field = 0;
200    for c in before.chars() {
201        quoted ^= c == '"';
202        field += usize::from(c == separator && !quoted);
203    }
204    field
205}
206
207fn field_split(line: &str, separator: char) -> Vec<String> {
208    let mut out = vec![String::new()];
209    let mut quoted = false;
210    for c in line.chars() {
211        quoted ^= c == '"';
212        if c == separator && !quoted {
213            out.push(String::new());
214        } else if let Some(field) = out.last_mut() {
215            field.push(c);
216        }
217    }
218    out
219}
220
221/// Changes rows of data, and says where the caret goes, in chars. None leaves it as it was:
222/// data keeps at least one row and column, and has no alignment to change.
223pub fn edit_rows(
224    text: &str,
225    separator: char,
226    row: usize,
227    column: usize,
228    edit: Edit,
229) -> Option<(String, usize)> {
230    let mut rows: Vec<Vec<String>> = text
231        .lines()
232        .map(|line| field_split(line, separator))
233        .collect();
234    let columns = rows.iter().map(Vec::len).max()?;
235    for cells in &mut rows {
236        cells.resize(columns, String::new());
237    }
238    let (mut row, mut column) = (row.min(rows.len() - 1), column.min(columns - 1));
239    match edit {
240        Edit::RowAbove => rows.insert(row, vec![String::new(); columns]),
241        Edit::RowBelow => {
242            row += 1;
243            rows.insert(row, vec![String::new(); columns]);
244        }
245        Edit::ColumnLeft | Edit::ColumnRight => {
246            column += usize::from(edit == Edit::ColumnRight);
247            for cells in &mut rows {
248                cells.insert(column, String::new());
249            }
250        }
251        Edit::DeleteRow if rows.len() > 1 => {
252            rows.remove(row);
253            row = row.min(rows.len() - 1);
254        }
255        Edit::DeleteColumn if columns > 1 => {
256            for cells in &mut rows {
257                cells.remove(column);
258            }
259            column = column.min(columns - 2);
260        }
261        _ => return None,
262    }
263    let glue = separator.to_string();
264    let lines: Vec<String> = rows.iter().map(|cells| cells.join(&glue)).collect();
265    let before: usize = lines[..row].iter().map(|l| l.chars().count() + 1).sum();
266    let inside: usize = rows[row][..column]
267        .iter()
268        .map(|cell| cell.chars().count() + 1)
269        .sum();
270    Some((lines.join("\n"), before + inside))
271}
272
273/// A new, empty table with a header row.
274pub fn new_table(rows: usize, columns: usize) -> String {
275    let rows = rows.max(2);
276    let columns = columns.max(1);
277    let table = Table {
278        rows: (0..rows)
279            .map(|row| {
280                (0..columns)
281                    .map(|c| {
282                        if row == 0 {
283                            format!("Column {}", c + 1)
284                        } else {
285                            String::new()
286                        }
287                    })
288                    .collect()
289            })
290            .collect(),
291        aligns: vec![Align::Default; columns],
292    };
293    print(&table)
294}
295
296#[cfg(test)]
297mod tests {
298    use super::*;
299
300    const TABLE: &str = "| A | B |\n|---|---|\n| 1 | 2 |\n| 3 | 4 |";
301
302    fn rows(text: &str) -> Vec<Vec<String>> {
303        parse(text).unwrap().rows
304    }
305
306    #[test]
307    fn rows_go_in_above_and_below() {
308        let (text, row, _) = apply(TABLE, 1, 0, Edit::RowBelow).unwrap();
309        assert_eq!(rows(&text).len(), 4);
310        assert_eq!(rows(&text)[2], ["", ""]);
311        assert_eq!(row, 2);
312        let (text, row, _) = apply(TABLE, 2, 0, Edit::RowAbove).unwrap();
313        assert_eq!(rows(&text)[2], ["", ""]);
314        assert_eq!(rows(&text)[3], ["3", "4"]);
315        assert_eq!(row, 2);
316    }
317
318    #[test]
319    fn a_row_above_the_header_goes_under_it() {
320        let (text, row, _) = apply(TABLE, 0, 0, Edit::RowAbove).unwrap();
321        assert_eq!(rows(&text)[0], ["A", "B"]);
322        assert_eq!(rows(&text)[1], ["", ""]);
323        assert_eq!(row, 1);
324    }
325
326    #[test]
327    fn columns_go_in_either_side() {
328        let (text, _, column) = apply(TABLE, 1, 0, Edit::ColumnRight).unwrap();
329        assert_eq!(rows(&text)[1], ["1", "", "2"]);
330        assert_eq!(column, 1);
331        let (text, _, column) = apply(TABLE, 1, 1, Edit::ColumnLeft).unwrap();
332        assert_eq!(rows(&text)[0], ["A", "", "B"]);
333        assert_eq!(column, 1);
334    }
335
336    #[test]
337    fn rows_and_columns_come_out() {
338        let (text, ..) = apply(TABLE, 1, 0, Edit::DeleteRow).unwrap();
339        assert_eq!(rows(&text), [["A", "B"], ["3", "4"]]);
340        let (text, ..) = apply(TABLE, 1, 0, Edit::DeleteColumn).unwrap();
341        assert_eq!(rows(&text), [["B"], ["2"], ["4"]]);
342        let (text, ..) = apply(TABLE, 0, 0, Edit::DeleteRow).unwrap();
343        assert_eq!(
344            rows(&text)[0],
345            ["1", "2"],
346            "the next row becomes the header"
347        );
348    }
349
350    #[test]
351    fn the_last_of_anything_takes_the_table_with_it() {
352        assert_eq!(apply("| A |\n|---|", 0, 0, Edit::DeleteColumn), None);
353        assert_eq!(apply("| A |\n|---|", 0, 0, Edit::DeleteRow), None);
354        assert_eq!(apply(TABLE, 1, 1, Edit::Delete), None);
355    }
356
357    #[test]
358    fn alignment_is_written_in_the_rule() {
359        let (text, ..) = apply(TABLE, 1, 1, Edit::Align(Align::Right)).unwrap();
360        assert!(text.lines().nth(1).unwrap().contains("--:"), "{text}");
361        let (again, ..) = apply(&text, 1, 0, Edit::Align(Align::Centre)).unwrap();
362        assert!(again.lines().nth(1).unwrap().contains(":-:"), "{again}");
363        let parsed = parse(&again).unwrap();
364        assert_eq!(parsed.aligns, [Align::Centre, Align::Right]);
365    }
366
367    #[test]
368    fn pipes_in_code_and_escapes_are_text() {
369        let table = "| a |\n|---|\n| `x|y` |\n| p\\|q |";
370        assert_eq!(rows(table)[1], ["`x|y`"]);
371        assert_eq!(rows(table)[2], ["p\\|q"]);
372    }
373
374    #[test]
375    fn the_caret_can_find_a_cell_again() {
376        let (text, row, column) = apply(TABLE, 2, 0, Edit::ColumnRight).unwrap();
377        let at = cell_offset(&text, row, column);
378        let chars: Vec<char> = text.chars().collect();
379        assert_eq!(chars[at - 2], '|');
380        assert_eq!(chars[at - 1], ' ');
381        let first = cell_offset(&text, 0, 0);
382        assert_eq!(chars[first], 'A');
383    }
384
385    #[test]
386    fn rows_of_data_grow_and_shrink() {
387        let text = "a,b\n1,2";
388        let (grown, at) = edit_rows(text, ',', 1, 0, Edit::RowBelow).unwrap();
389        assert_eq!(grown, "a,b\n1,2\n,");
390        assert_eq!(at, 8);
391        let (wider, at) = edit_rows(text, ',', 1, 0, Edit::ColumnRight).unwrap();
392        assert_eq!(wider, "a,,b\n1,,2");
393        assert_eq!(at, 7);
394        let (less, _) = edit_rows(text, ',', 1, 1, Edit::DeleteColumn).unwrap();
395        assert_eq!(less, "a\n1");
396        assert_eq!(edit_rows("a,b", ',', 0, 0, Edit::DeleteRow), None);
397        assert_eq!(edit_rows(text, ',', 0, 0, Edit::Align(Align::Left)), None);
398    }
399
400    #[test]
401    fn a_quoted_comma_is_not_a_new_field() {
402        assert_eq!(field_of("\"a,b\",c", ','), 1);
403        let (wider, _) = edit_rows("\"a,b\",c", ',', 0, 1, Edit::DeleteColumn).unwrap();
404        assert_eq!(wider, "\"a,b\"");
405    }
406
407    #[test]
408    fn a_new_table_has_a_header_and_its_size() {
409        let text = new_table(3, 4);
410        assert_eq!(rows(&text).len(), 3);
411        assert_eq!(rows(&text)[0][3], "Column 4");
412        assert_eq!(text.lines().count(), 4);
413    }
414}