1#[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#[derive(Debug, PartialEq, Eq)]
28struct Table {
29 rows: Vec<Vec<String>>,
30 aligns: Vec<Align>,
31}
32
33fn 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
125pub 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
146pub 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 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 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
196pub 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
221pub 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
273pub 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}