]> git.scottworley.com Git - tablify/blame_incremental - src/lib.rs
projects / tablify / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Center text in each cell
[tablify] / src / lib.rs
... / ...
CommitLineData
1use std::collections::{HashMap, HashSet};
2use std::fmt::Write;
3use std::io::BufRead;
4use std::iter::Iterator;
5
6const 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";
36const FOOTER: &str = " </tbody>
37 </table>
38</body>
39</html>";
40
41#[derive(Debug, PartialEq, Eq, Hash)]
42struct Entry {
43 col: String,
44 instance: Option<String>,
45}
46impl 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)]
62struct RowInput {
63 label: String,
64 entries: Vec<Entry>,
65}
66
67struct Reader<Input: Iterator<Item = Result<String, std::io::Error>>> {
68 input: std::iter::Enumerate<Input>,
69 row: Option<RowInput>,
70}
71impl<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}
79impl<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
118fn 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
122fn 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}
144fn column_order(rows: &[RowInput]) -> Vec<String> {
145 column_counts(rows)
146 .into_iter()
147 .map(|(_, col)| col)
148 .collect()
149}
150
151fn render_instance(entry: &Entry) -> String {
152 match &entry.instance {
153 None => String::from("✓ "),
154 Some(instance) => String::from(instance) + " ",
155 }
156}
157
158fn 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::<String>()
173 };
174 format!("<td class=\"{class}\" onmouseover=\"h2('{row_label}','{col}')\" onmouseout=\"ch2('{row_label}','{col}')\">{}</td>", contents.trim())
175}
176
177fn render_row(columns: &[String], row: &RowInput) -> String {
178 // This is O(n^2) & doesn't need to be
179 // TODO: Escape HTML special characters
180 let row_label = &row.label;
181 format!(
182 "<tr><th id=\"{row_label}\">{row_label}</th>{}</tr>\n",
183 &columns
184 .iter()
185 .map(|col| render_cell(col, row))
186 .collect::<String>()
187 )
188}
189
190fn render_column_headers(columns: &[String]) -> String {
191 // TODO: Escape HTML special characters
192 String::from("<tr class=\"key\"><th></th>")
193 + &columns.iter().fold(String::new(), |mut acc, c| {
194 write!(&mut acc, "<th id=\"{c}\"><div><div>{c}</div></div></th>").unwrap();
195 acc
196 })
197 + "</tr>\n"
198}
199
200/// # Errors
201///
202/// Will return `Err` if
203/// * there's an i/o error while reading `input`
204/// * the log has invalid syntax:
205/// * an indented line with no preceding non-indented line
206pub fn tablify(input: impl std::io::Read) -> Result<String, std::io::Error> {
207 let rows = read_rows(input).collect::<Result<Vec<_>, _>>()?;
208 let columns = column_order(&rows);
209 Ok(String::from(HEADER)
210 + &render_column_headers(&columns)
211 + &rows
212 .into_iter()
213 .map(|r| render_row(&columns, &r))
214 .collect::<String>()
215 + FOOTER)
216}
217
218#[cfg(test)]
219mod tests {
220 use super::*;
221
222 #[test]
223 fn test_parse_entry() {
224 assert_eq!(
225 Entry::from("foo"),
226 Entry {
227 col: String::from("foo"),
228 instance: None
229 }
230 );
231 assert_eq!(
232 Entry::from("foo:bar"),
233 Entry {
234 col: String::from("foo"),
235 instance: Some(String::from("bar"))
236 }
237 );
238 assert_eq!(
239 Entry::from("foo: bar"),
240 Entry {
241 col: String::from("foo"),
242 instance: Some(String::from("bar"))
243 }
244 );
245 }
246
247 #[test]
248 fn test_read_rows() {
249 assert_eq!(
250 read_rows(&b"foo"[..]).flatten().collect::<Vec<_>>(),
251 vec![RowInput {
252 label: String::from("foo"),
253 entries: vec![]
254 }]
255 );
256 assert_eq!(
257 read_rows(&b"bar"[..]).flatten().collect::<Vec<_>>(),
258 vec![RowInput {
259 label: String::from("bar"),
260 entries: vec![]
261 }]
262 );
263 assert_eq!(
264 read_rows(&b"foo\nbar\n"[..]).flatten().collect::<Vec<_>>(),
265 vec![
266 RowInput {
267 label: String::from("foo"),
268 entries: vec![]
269 },
270 RowInput {
271 label: String::from("bar"),
272 entries: vec![]
273 }
274 ]
275 );
276 assert_eq!(
277 read_rows(&b"foo\n bar\n"[..]).flatten().collect::<Vec<_>>(),
278 vec![RowInput {
279 label: String::from("foo"),
280 entries: vec![Entry::from("bar")]
281 }]
282 );
283 assert_eq!(
284 read_rows(&b"foo\n bar\n baz\n"[..])
285 .flatten()
286 .collect::<Vec<_>>(),
287 vec![RowInput {
288 label: String::from("foo"),
289 entries: vec![Entry::from("bar"), Entry::from("baz")]
290 }]
291 );
292 assert_eq!(
293 read_rows(&b"foo\n\nbar\n"[..])
294 .flatten()
295 .collect::<Vec<_>>(),
296 vec![
297 RowInput {
298 label: String::from("foo"),
299 entries: vec![]
300 },
301 RowInput {
302 label: String::from("bar"),
303 entries: vec![]
304 }
305 ]
306 );
307 assert_eq!(
308 read_rows(&b"foo\n \nbar\n"[..])
309 .flatten()
310 .collect::<Vec<_>>(),
311 vec![
312 RowInput {
313 label: String::from("foo"),
314 entries: vec![]
315 },
316 RowInput {
317 label: String::from("bar"),
318 entries: vec![]
319 }
320 ]
321 );
322 assert_eq!(
323 read_rows(&b"foo \n bar \n"[..])
324 .flatten()
325 .collect::<Vec<_>>(),
326 vec![RowInput {
327 label: String::from("foo"),
328 entries: vec![Entry::from("bar")]
329 }]
330 );
331
332 let bad = read_rows(&b" foo"[..]).next().unwrap();
333 assert!(bad.is_err());
334 assert!(format!("{bad:?}").contains("1: Entry with no header"));
335
336 let bad2 = read_rows(&b"foo\n\n bar"[..]).nth(1).unwrap();
337 assert!(bad2.is_err());
338 assert!(format!("{bad2:?}").contains("3: Entry with no header"));
339 }
340
341 #[test]
342 fn test_column_counts() {
343 assert_eq!(
344 column_counts(
345 &read_rows(&b"foo\n bar\n baz\n"[..])
346 .collect::<Result<Vec<_>, _>>()
347 .unwrap()
348 ),
349 vec![(1, String::from("bar")), (1, String::from("baz"))]
350 );
351 assert_eq!(
352 column_counts(
353 &read_rows(&b"foo\n bar\n baz\nquux\n baz"[..])
354 .collect::<Result<Vec<_>, _>>()
355 .unwrap()
356 ),
357 vec![(2, String::from("baz")), (1, String::from("bar"))]
358 );
359 assert_eq!(
360 column_counts(
361 &read_rows(&b"foo\n bar\n bar\n baz\n bar\nquux\n baz"[..])
362 .collect::<Result<Vec<_>, _>>()
363 .unwrap()
364 ),
365 vec![(2, String::from("baz")), (1, String::from("bar"))]
366 );
367 assert_eq!(
368 column_counts(
369 &read_rows(&b"foo\n bar: 1\n bar: 2\n baz\n bar\nquux\n baz"[..])
370 .collect::<Result<Vec<_>, _>>()
371 .unwrap()
372 ),
373 vec![(2, String::from("baz")), (1, String::from("bar"))]
374 );
375 }
376
377 #[test]
378 fn test_render_cell() {
379 assert_eq!(
380 render_cell(
381 "foo",
382 &RowInput {
383 label: String::from("nope"),
384 entries: vec![]
385 }
386 ),
387 String::from("<td class=\"\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\"></td>")
388 );
389 assert_eq!(
390 render_cell(
391 "foo",
392 &RowInput {
393 label: String::from("nope"),
394 entries: vec![Entry::from("bar")]
395 }
396 ),
397 String::from("<td class=\"\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\"></td>")
398 );
399 assert_eq!(
400 render_cell(
401 "foo",
402 &RowInput {
403 label: String::from("nope"),
404 entries: vec![Entry::from("foo")]
405 }
406 ),
407 String::from("<td class=\"yes\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\"></td>")
408 );
409 assert_eq!(
410 render_cell(
411 "foo",
412 &RowInput {
413 label: String::from("nope"),
414 entries: vec![Entry::from("foo"), Entry::from("foo")]
415 }
416 ),
417 String::from("<td class=\"yes\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\">2</td>")
418 );
419 assert_eq!(
420 render_cell(
421 "foo",
422 &RowInput {
423 label: String::from("nope"),
424 entries: vec![Entry::from("foo: 5"), Entry::from("foo: 10")]
425 }
426 ),
427 String::from("<td class=\"yes\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\">5 10</td>")
428 );
429 assert_eq!(
430 render_cell(
431 "foo",
432 &RowInput {
433 label: String::from("nope"),
434 entries: vec![Entry::from("foo: 5"), Entry::from("foo")]
435 }
436 ),
437 String::from("<td class=\"yes\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\">5 ✓</td>")
438 );
439 }
440}
Summarize a text log as an HTML table