]>
Commit | Line | Data |
---|---|---|
1 | use std::collections::{HashMap, HashSet}; | |
2 | use std::fmt::Write; | |
3 | use std::io::BufRead; | |
4 | use std::iter::Iterator; | |
5 | ||
6 | const HEADER: &str = "<!DOCTYPE html> | |
7 | <html> | |
8 | <head> | |
9 | <meta charset=\"utf-8\"> | |
10 | <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"> | |
11 | <style> | |
12 | td { text-align: center; } | |
13 | /* h/t https://wabain.github.io/2019/10/13/css-rotated-table-header.html */ | |
14 | th, td { white-space: nowrap; } | |
15 | th { text-align: left; font-weight: normal; } | |
16 | table { border-collapse: collapse } | |
17 | tr.key > th { height: 10em; vertical-align: bottom; line-height: 1 } | |
18 | tr.key > th > div { width: 1em; } | |
19 | tr.key > th > div > div { width: 5em; transform-origin: bottom left; transform: translateX(1em) rotate(-65deg) } | |
20 | td { border: thin solid gray; } | |
21 | td.yes { border: thin solid gray; background-color: #ddd; } | |
22 | /* h/t https://stackoverflow.com/questions/5687035/css-bolding-some-text-without-changing-its-containers-size/46452396#46452396 */ | |
23 | .highlight { text-shadow: -0.06ex 0 black, 0.06ex 0 black; } | |
24 | </style> | |
25 | <script> | |
26 | function highlight(id) { const e = document.getElementById(id); if (e) { e.classList.add( \"highlight\"); } } | |
27 | function clear_highlight(id) { const e = document.getElementById(id); if (e) { e.classList.remove(\"highlight\"); } } | |
28 | function h2(a, b) { highlight(a); highlight(b); } | |
29 | function ch2(a, b) { clear_highlight(a); clear_highlight(b); } | |
30 | </script> | |
31 | </head> | |
32 | <body> | |
33 | <table> | |
34 | <tbody> | |
35 | "; | |
36 | const FOOTER: &str = " </tbody> | |
37 | </table> | |
38 | </body> | |
39 | </html>"; | |
40 | ||
41 | #[derive(Debug, PartialEq, Eq, Hash)] | |
42 | struct Entry { | |
43 | col: String, | |
44 | instance: Option<String>, | |
45 | } | |
46 | impl From<&str> for Entry { | |
47 | fn from(value: &str) -> Entry { | |
48 | match value.split_once(':') { | |
49 | None => Entry { | |
50 | col: String::from(value), | |
51 | instance: None, | |
52 | }, | |
53 | Some((col, instance)) => Entry { | |
54 | col: String::from(col.trim()), | |
55 | instance: Some(String::from(instance.trim())), | |
56 | }, | |
57 | } | |
58 | } | |
59 | } | |
60 | ||
61 | #[derive(Debug, PartialEq, Eq)] | |
62 | struct RowInput { | |
63 | label: String, | |
64 | entries: Vec<Entry>, | |
65 | } | |
66 | ||
67 | struct Reader<Input: Iterator<Item = Result<String, std::io::Error>>> { | |
68 | input: std::iter::Enumerate<Input>, | |
69 | row: Option<RowInput>, | |
70 | } | |
71 | impl<Input: Iterator<Item = Result<String, std::io::Error>>> Reader<Input> { | |
72 | fn new(input: Input) -> Self { | |
73 | Self { | |
74 | input: input.enumerate(), | |
75 | row: None, | |
76 | } | |
77 | } | |
78 | } | |
79 | impl<Input: Iterator<Item = Result<String, std::io::Error>>> Iterator for Reader<Input> { | |
80 | type Item = Result<RowInput, std::io::Error>; | |
81 | fn next(&mut self) -> Option<Self::Item> { | |
82 | loop { | |
83 | match self | |
84 | .input | |
85 | .next() | |
86 | .map(|(n, r)| (n, r.map(|line| String::from(line.trim_end())))) | |
87 | { | |
88 | None => return Ok(std::mem::take(&mut self.row)).transpose(), | |
89 | Some((_, Err(e))) => return Some(Err(e)), | |
90 | Some((_, Ok(line))) if line.is_empty() && self.row.is_some() => { | |
91 | return Ok(std::mem::take(&mut self.row)).transpose() | |
92 | } | |
93 | Some((_, Ok(line))) if line.is_empty() => {} | |
94 | Some((n, Ok(line))) if line.starts_with(' ') => match &mut self.row { | |
95 | None => { | |
96 | return Some(Err(std::io::Error::other(format!( | |
97 | "{}: Entry with no header", | |
98 | n + 1 | |
99 | )))) | |
100 | } | |
101 | Some(ref mut row) => row.entries.push(Entry::from(line.trim())), | |
102 | }, | |
103 | Some((_, Ok(line))) => { | |
104 | let prev = std::mem::take(&mut self.row); | |
105 | self.row = Some(RowInput { | |
106 | label: line, | |
107 | entries: vec![], | |
108 | }); | |
109 | if prev.is_some() { | |
110 | return Ok(prev).transpose(); | |
111 | } | |
112 | } | |
113 | } | |
114 | } | |
115 | } | |
116 | } | |
117 | ||
118 | fn read_rows(input: impl std::io::Read) -> impl Iterator<Item = Result<RowInput, std::io::Error>> { | |
119 | Reader::new(std::io::BufReader::new(input).lines()) | |
120 | } | |
121 | ||
122 | fn column_counts(rows: &[RowInput]) -> Vec<(usize, String)> { | |
123 | let mut counts: Vec<_> = rows | |
124 | .iter() | |
125 | .flat_map(|r| { | |
126 | r.entries | |
127 | .iter() | |
128 | .map(|e| &e.col) | |
129 | .collect::<HashSet<_>>() | |
130 | .into_iter() | |
131 | }) | |
132 | .fold(HashMap::new(), |mut cs, col| { | |
133 | cs.entry(String::from(col)) | |
134 | .and_modify(|n| *n += 1) | |
135 | .or_insert(1); | |
136 | cs | |
137 | }) | |
138 | .into_iter() | |
139 | .map(|(col, n)| (n, col)) | |
140 | .collect(); | |
141 | counts.sort_unstable_by(|(an, acol), (bn, bcol)| bn.cmp(an).then(acol.cmp(bcol))); | |
142 | counts | |
143 | } | |
144 | fn column_order(rows: &[RowInput]) -> Vec<String> { | |
145 | column_counts(rows) | |
146 | .into_iter() | |
147 | .map(|(_, col)| col) | |
148 | .collect() | |
149 | } | |
150 | ||
151 | fn render_instance(entry: &Entry) -> String { | |
152 | match &entry.instance { | |
153 | None => String::from("✓"), | |
154 | Some(instance) => String::from(instance), | |
155 | } | |
156 | } | |
157 | ||
158 | fn render_cell(col: &str, row: &RowInput) -> String { | |
159 | // TODO: Escape HTML special characters | |
160 | let row_label = &row.label; | |
161 | let entries: Vec<&Entry> = row.entries.iter().filter(|e| e.col == col).collect(); | |
162 | let class = if entries.is_empty() { "" } else { "yes" }; | |
163 | let all_empty = entries.iter().all(|e| e.instance.is_none()); | |
164 | let contents = if entries.is_empty() || (all_empty && entries.len() == 1) { | |
165 | String::new() | |
166 | } else if all_empty { | |
167 | format!("{}", entries.len()) | |
168 | } else { | |
169 | entries | |
170 | .iter() | |
171 | .map(|i| render_instance(i)) | |
172 | .collect::<Vec<_>>() | |
173 | .join(" ") | |
174 | }; | |
175 | format!("<td class=\"{class}\" onmouseover=\"h2('{row_label}','{col}')\" onmouseout=\"ch2('{row_label}','{col}')\">{contents}</td>") | |
176 | } | |
177 | ||
178 | fn render_row(columns: &[String], row: &RowInput) -> String { | |
179 | // This is O(n^2) & doesn't need to be | |
180 | // TODO: Escape HTML special characters | |
181 | let row_label = &row.label; | |
182 | format!( | |
183 | "<tr><th id=\"{row_label}\">{row_label}</th>{}</tr>\n", | |
184 | &columns | |
185 | .iter() | |
186 | .map(|col| render_cell(col, row)) | |
187 | .collect::<String>() | |
188 | ) | |
189 | } | |
190 | ||
191 | fn render_column_headers(columns: &[String]) -> String { | |
192 | // TODO: Escape HTML special characters | |
193 | String::from("<tr class=\"key\"><th></th>") | |
194 | + &columns.iter().fold(String::new(), |mut acc, c| { | |
195 | write!(&mut acc, "<th id=\"{c}\"><div><div>{c}</div></div></th>").unwrap(); | |
196 | acc | |
197 | }) | |
198 | + "</tr>\n" | |
199 | } | |
200 | ||
201 | /// # Errors | |
202 | /// | |
203 | /// Will return `Err` if | |
204 | /// * there's an i/o error while reading `input` | |
205 | /// * the log has invalid syntax: | |
206 | /// * an indented line with no preceding non-indented line | |
207 | pub fn tablify(input: impl std::io::Read) -> Result<String, std::io::Error> { | |
208 | let rows = read_rows(input).collect::<Result<Vec<_>, _>>()?; | |
209 | let columns = column_order(&rows); | |
210 | Ok(String::from(HEADER) | |
211 | + &render_column_headers(&columns) | |
212 | + &rows | |
213 | .into_iter() | |
214 | .map(|r| render_row(&columns, &r)) | |
215 | .collect::<String>() | |
216 | + FOOTER) | |
217 | } | |
218 | ||
219 | #[cfg(test)] | |
220 | mod tests { | |
221 | use super::*; | |
222 | ||
223 | #[test] | |
224 | fn test_parse_entry() { | |
225 | assert_eq!( | |
226 | Entry::from("foo"), | |
227 | Entry { | |
228 | col: String::from("foo"), | |
229 | instance: None | |
230 | } | |
231 | ); | |
232 | assert_eq!( | |
233 | Entry::from("foo:bar"), | |
234 | Entry { | |
235 | col: String::from("foo"), | |
236 | instance: Some(String::from("bar")) | |
237 | } | |
238 | ); | |
239 | assert_eq!( | |
240 | Entry::from("foo: bar"), | |
241 | Entry { | |
242 | col: String::from("foo"), | |
243 | instance: Some(String::from("bar")) | |
244 | } | |
245 | ); | |
246 | } | |
247 | ||
248 | #[test] | |
249 | fn test_read_rows() { | |
250 | assert_eq!( | |
251 | read_rows(&b"foo"[..]).flatten().collect::<Vec<_>>(), | |
252 | vec![RowInput { | |
253 | label: String::from("foo"), | |
254 | entries: vec![] | |
255 | }] | |
256 | ); | |
257 | assert_eq!( | |
258 | read_rows(&b"bar"[..]).flatten().collect::<Vec<_>>(), | |
259 | vec![RowInput { | |
260 | label: String::from("bar"), | |
261 | entries: vec![] | |
262 | }] | |
263 | ); | |
264 | assert_eq!( | |
265 | read_rows(&b"foo\nbar\n"[..]).flatten().collect::<Vec<_>>(), | |
266 | vec![ | |
267 | RowInput { | |
268 | label: String::from("foo"), | |
269 | entries: vec![] | |
270 | }, | |
271 | RowInput { | |
272 | label: String::from("bar"), | |
273 | entries: vec![] | |
274 | } | |
275 | ] | |
276 | ); | |
277 | assert_eq!( | |
278 | read_rows(&b"foo\n bar\n"[..]).flatten().collect::<Vec<_>>(), | |
279 | vec![RowInput { | |
280 | label: String::from("foo"), | |
281 | entries: vec![Entry::from("bar")] | |
282 | }] | |
283 | ); | |
284 | assert_eq!( | |
285 | read_rows(&b"foo\n bar\n baz\n"[..]) | |
286 | .flatten() | |
287 | .collect::<Vec<_>>(), | |
288 | vec![RowInput { | |
289 | label: String::from("foo"), | |
290 | entries: vec![Entry::from("bar"), Entry::from("baz")] | |
291 | }] | |
292 | ); | |
293 | assert_eq!( | |
294 | read_rows(&b"foo\n\nbar\n"[..]) | |
295 | .flatten() | |
296 | .collect::<Vec<_>>(), | |
297 | vec![ | |
298 | RowInput { | |
299 | label: String::from("foo"), | |
300 | entries: vec![] | |
301 | }, | |
302 | RowInput { | |
303 | label: String::from("bar"), | |
304 | entries: vec![] | |
305 | } | |
306 | ] | |
307 | ); | |
308 | assert_eq!( | |
309 | read_rows(&b"foo\n \nbar\n"[..]) | |
310 | .flatten() | |
311 | .collect::<Vec<_>>(), | |
312 | vec![ | |
313 | RowInput { | |
314 | label: String::from("foo"), | |
315 | entries: vec![] | |
316 | }, | |
317 | RowInput { | |
318 | label: String::from("bar"), | |
319 | entries: vec![] | |
320 | } | |
321 | ] | |
322 | ); | |
323 | assert_eq!( | |
324 | read_rows(&b"foo \n bar \n"[..]) | |
325 | .flatten() | |
326 | .collect::<Vec<_>>(), | |
327 | vec![RowInput { | |
328 | label: String::from("foo"), | |
329 | entries: vec![Entry::from("bar")] | |
330 | }] | |
331 | ); | |
332 | ||
333 | let bad = read_rows(&b" foo"[..]).next().unwrap(); | |
334 | assert!(bad.is_err()); | |
335 | assert!(format!("{bad:?}").contains("1: Entry with no header")); | |
336 | ||
337 | let bad2 = read_rows(&b"foo\n\n bar"[..]).nth(1).unwrap(); | |
338 | assert!(bad2.is_err()); | |
339 | assert!(format!("{bad2:?}").contains("3: Entry with no header")); | |
340 | } | |
341 | ||
342 | #[test] | |
343 | fn test_column_counts() { | |
344 | assert_eq!( | |
345 | column_counts( | |
346 | &read_rows(&b"foo\n bar\n baz\n"[..]) | |
347 | .collect::<Result<Vec<_>, _>>() | |
348 | .unwrap() | |
349 | ), | |
350 | vec![(1, String::from("bar")), (1, String::from("baz"))] | |
351 | ); | |
352 | assert_eq!( | |
353 | column_counts( | |
354 | &read_rows(&b"foo\n bar\n baz\nquux\n baz"[..]) | |
355 | .collect::<Result<Vec<_>, _>>() | |
356 | .unwrap() | |
357 | ), | |
358 | vec![(2, String::from("baz")), (1, String::from("bar"))] | |
359 | ); | |
360 | assert_eq!( | |
361 | column_counts( | |
362 | &read_rows(&b"foo\n bar\n bar\n baz\n bar\nquux\n baz"[..]) | |
363 | .collect::<Result<Vec<_>, _>>() | |
364 | .unwrap() | |
365 | ), | |
366 | vec![(2, String::from("baz")), (1, String::from("bar"))] | |
367 | ); | |
368 | assert_eq!( | |
369 | column_counts( | |
370 | &read_rows(&b"foo\n bar: 1\n bar: 2\n baz\n bar\nquux\n baz"[..]) | |
371 | .collect::<Result<Vec<_>, _>>() | |
372 | .unwrap() | |
373 | ), | |
374 | vec![(2, String::from("baz")), (1, String::from("bar"))] | |
375 | ); | |
376 | } | |
377 | ||
378 | #[test] | |
379 | fn test_render_cell() { | |
380 | assert_eq!( | |
381 | render_cell( | |
382 | "foo", | |
383 | &RowInput { | |
384 | label: String::from("nope"), | |
385 | entries: vec![] | |
386 | } | |
387 | ), | |
388 | String::from("<td class=\"\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\"></td>") | |
389 | ); | |
390 | assert_eq!( | |
391 | render_cell( | |
392 | "foo", | |
393 | &RowInput { | |
394 | label: String::from("nope"), | |
395 | entries: vec![Entry::from("bar")] | |
396 | } | |
397 | ), | |
398 | String::from("<td class=\"\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\"></td>") | |
399 | ); | |
400 | assert_eq!( | |
401 | render_cell( | |
402 | "foo", | |
403 | &RowInput { | |
404 | label: String::from("nope"), | |
405 | entries: vec![Entry::from("foo")] | |
406 | } | |
407 | ), | |
408 | String::from("<td class=\"yes\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\"></td>") | |
409 | ); | |
410 | assert_eq!( | |
411 | render_cell( | |
412 | "foo", | |
413 | &RowInput { | |
414 | label: String::from("nope"), | |
415 | entries: vec![Entry::from("foo"), Entry::from("foo")] | |
416 | } | |
417 | ), | |
418 | String::from("<td class=\"yes\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\">2</td>") | |
419 | ); | |
420 | assert_eq!( | |
421 | render_cell( | |
422 | "foo", | |
423 | &RowInput { | |
424 | label: String::from("nope"), | |
425 | entries: vec![Entry::from("foo: 5"), Entry::from("foo: 10")] | |
426 | } | |
427 | ), | |
428 | String::from("<td class=\"yes\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\">5 10</td>") | |
429 | ); | |
430 | assert_eq!( | |
431 | render_cell( | |
432 | "foo", | |
433 | &RowInput { | |
434 | label: String::from("nope"), | |
435 | entries: vec![Entry::from("foo: 5"), Entry::from("foo")] | |
436 | } | |
437 | ), | |
438 | String::from("<td class=\"yes\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\">5 ✓</td>") | |
439 | ); | |
440 | } | |
441 | } |