]> 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
Don't allocate columns to rare events
[tablify] / src / lib.rs
... / ...
CommitLineData
1use std::borrow::ToOwned;
2use std::collections::HashMap;
3use std::fmt::Write;
4use std::io::BufRead;
5use std::iter::Iterator;
6
7pub struct Config {
8 pub column_threshold: usize,
9}
10
11const HEADER: &str = r#"<!DOCTYPE html>
12<html>
13<head>
14 <meta charset="utf-8">
15 <meta name="viewport" content="width=device-width, initial-scale=1">
16 <style>
17 td { text-align: center; }
18 /* h/t https://wabain.github.io/2019/10/13/css-rotated-table-header.html */
19 th, td { white-space: nowrap; }
20 th { text-align: left; font-weight: normal; }
21 table { border-collapse: collapse }
22 tr.key > th { height: 10em; vertical-align: bottom; line-height: 1 }
23 tr.key > th > div { width: 1em; }
24 tr.key > th > div > div { width: 5em; transform-origin: bottom left; transform: translateX(1em) rotate(-65deg) }
25 td { border: thin solid gray; }
26 td.yes { border: thin solid gray; background-color: #ddd; }
27 /* h/t https://stackoverflow.com/questions/5687035/css-bolding-some-text-without-changing-its-containers-size/46452396#46452396 */
28 .highlight { text-shadow: -0.06ex 0 black, 0.06ex 0 black; }
29 </style>
30 <script>
31 function highlight(id) { const e = document.getElementById(id); if (e) { e.classList.add( "highlight"); } }
32 function clear_highlight(id) { const e = document.getElementById(id); if (e) { e.classList.remove("highlight"); } }
33 function h2(a, b) { highlight(a); highlight(b); }
34 function ch2(a, b) { clear_highlight(a); clear_highlight(b); }
35 </script>
36</head>
37<body>
38 <table>
39 <tbody>
40"#;
41const FOOTER: &str = " </tbody>
42 </table>
43</body>
44</html>";
45
46#[derive(PartialEq, Eq, Debug)]
47pub struct HTML(String);
48impl HTML {
49 fn escape(value: &str) -> HTML {
50 let mut escaped: String = String::new();
51 for c in value.chars() {
52 match c {
53 '>' => escaped.push_str("&gt;"),
54 '<' => escaped.push_str("&lt;"),
55 '\'' => escaped.push_str("&#39;"),
56 '"' => escaped.push_str("&quot;"),
57 '&' => escaped.push_str("&amp;"),
58 ok_c => escaped.push(ok_c),
59 }
60 }
61 HTML(escaped)
62 }
63}
64impl From<&str> for HTML {
65 fn from(value: &str) -> HTML {
66 HTML(String::from(value))
67 }
68}
69impl FromIterator<HTML> for HTML {
70 fn from_iter<T>(iter: T) -> HTML
71 where
72 T: IntoIterator<Item = HTML>,
73 {
74 HTML(iter.into_iter().map(|html| html.0).collect::<String>())
75 }
76}
77impl std::fmt::Display for HTML {
78 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
79 write!(f, "{}", self.0)
80 }
81}
82
83#[derive(Debug, PartialEq, Eq)]
84enum InputLine<'a> {
85 Blank,
86 RowHeader(&'a str),
87 Entry(&'a str, Option<&'a str>),
88}
89impl<'a> From<&'a str> for InputLine<'a> {
90 fn from(value: &'a str) -> InputLine<'a> {
91 let trimmed = value.trim_end();
92 if trimmed.is_empty() {
93 InputLine::Blank
94 } else if !trimmed.starts_with(' ') {
95 InputLine::RowHeader(value.trim())
96 } else {
97 match value.split_once(':') {
98 None => InputLine::Entry(value.trim(), None),
99 Some((col, instance)) => InputLine::Entry(col.trim(), Some(instance.trim())),
100 }
101 }
102 }
103}
104
105#[derive(Debug, PartialEq, Eq)]
106struct Row {
107 label: String,
108 entries: HashMap<String, Vec<Option<String>>>,
109}
110
111struct Reader<Input: Iterator<Item = Result<String, std::io::Error>>> {
112 input: std::iter::Enumerate<Input>,
113 row: Option<Row>,
114}
115impl<Input: Iterator<Item = Result<String, std::io::Error>>> Reader<Input> {
116 fn new(input: Input) -> Self {
117 Self {
118 input: input.enumerate(),
119 row: None,
120 }
121 }
122}
123impl<Input: Iterator<Item = Result<String, std::io::Error>>> Iterator for Reader<Input> {
124 type Item = Result<Row, std::io::Error>;
125 fn next(&mut self) -> Option<Self::Item> {
126 loop {
127 match self.input.next() {
128 None => return Ok(std::mem::take(&mut self.row)).transpose(),
129 Some((_, Err(e))) => return Some(Err(e)),
130 Some((n, Ok(line))) => match InputLine::from(line.as_ref()) {
131 InputLine::Blank if self.row.is_some() => {
132 return Ok(std::mem::take(&mut self.row)).transpose()
133 }
134 InputLine::Blank => {}
135 InputLine::Entry(col, instance) => match &mut self.row {
136 None => {
137 return Some(Err(std::io::Error::other(format!(
138 "{}: Entry with no header",
139 n + 1
140 ))))
141 }
142 Some(ref mut row) => {
143 row.entries
144 .entry(col.to_owned())
145 .and_modify(|is| is.push(instance.map(ToOwned::to_owned)))
146 .or_insert_with(|| vec![instance.map(ToOwned::to_owned)]);
147 }
148 },
149 InputLine::RowHeader(row) => {
150 let prev = std::mem::take(&mut self.row);
151 self.row = Some(Row {
152 label: row.to_owned(),
153 entries: HashMap::new(),
154 });
155 if prev.is_some() {
156 return Ok(prev).transpose();
157 }
158 }
159 },
160 }
161 }
162 }
163}
164
165fn read_rows(input: impl std::io::Read) -> impl Iterator<Item = Result<Row, std::io::Error>> {
166 Reader::new(std::io::BufReader::new(input).lines())
167}
168
169fn column_counts(rows: &[Row]) -> Vec<(usize, String)> {
170 let mut counts: Vec<_> = rows
171 .iter()
172 .flat_map(|r| r.entries.keys())
173 .fold(HashMap::new(), |mut cs, col| {
174 cs.entry(col.to_owned())
175 .and_modify(|n| *n += 1)
176 .or_insert(1);
177 cs
178 })
179 .into_iter()
180 .map(|(col, n)| (n, col))
181 .collect();
182 counts.sort_unstable_by(|(an, acol), (bn, bcol)| bn.cmp(an).then(acol.cmp(bcol)));
183 counts
184}
185fn column_order(config: &Config, rows: &[Row]) -> Vec<String> {
186 column_counts(rows)
187 .into_iter()
188 .filter_map(|(n, col)| (n >= config.column_threshold).then_some(col))
189 .collect()
190}
191
192fn render_one_instance(instance: &Option<String>) -> HTML {
193 match instance {
194 None => HTML::from("✓"),
195 Some(instance) => HTML::escape(instance.as_ref()),
196 }
197}
198
199fn render_instances(instances: &[Option<String>]) -> HTML {
200 let all_empty = instances.iter().all(Option::is_none);
201 if all_empty && instances.len() == 1 {
202 HTML::from("")
203 } else if all_empty {
204 HTML(format!("{}", instances.len()))
205 } else {
206 HTML(
207 instances
208 .iter()
209 .map(render_one_instance)
210 .map(|html| html.0) // Waiting for slice_concat_trait to stabilize
211 .collect::<Vec<_>>()
212 .join(" "),
213 )
214 }
215}
216
217fn render_cell(col: &str, row: &mut Row) -> HTML {
218 let row_label = HTML::escape(row.label.as_ref());
219 let col_label = HTML::escape(col);
220 let instances: Option<&Vec<Option<String>>> = row.entries.get(col);
221 let class = HTML::from(if instances.is_none() { "" } else { "yes" });
222 let contents = match instances {
223 None => HTML::from(""),
224 Some(is) => render_instances(is),
225 };
226 row.entries.remove(col);
227 HTML(format!(
228 r#"<td class="{class}" onmouseover="h2('{row_label}','{col_label}')" onmouseout="ch2('{row_label}','{col_label}')">{contents}</td>"#
229 ))
230}
231
232fn render_leftover(notcol: &str, instances: &[Option<String>]) -> HTML {
233 let label = HTML::escape(notcol);
234 let rest = render_instances(instances);
235 if rest == HTML::from("") {
236 HTML(format!("{label}"))
237 } else {
238 HTML(format!("{label}: {rest}"))
239 }
240}
241
242fn render_all_leftovers(row: &Row) -> HTML {
243 let mut order: Vec<_> = row.entries.keys().collect();
244 order.sort_unstable();
245 HTML(
246 order
247 .into_iter()
248 .map(|notcol| render_leftover(notcol, row.entries.get(notcol).expect("Key vanished?!")))
249 .map(|html| html.0) // Waiting for slice_concat_trait to stabilize
250 .collect::<Vec<_>>()
251 .join(", "),
252 )
253}
254
255fn render_row(columns: &[String], row: &mut Row) -> HTML {
256 let row_label = HTML::escape(row.label.as_ref());
257 let cells = columns
258 .iter()
259 .map(|col| render_cell(col, row))
260 .collect::<HTML>();
261 let leftovers = render_all_leftovers(row);
262 HTML(format!(
263 "<tr><th id=\"{row_label}\">{row_label}</th>{cells}<td onmouseover=\"highlight('{row_label}')\" onmouseout=\"clear_highlight('{row_label}')\">{leftovers}</td></tr>\n"
264 ))
265}
266
267fn render_column_headers(columns: &[String]) -> HTML {
268 HTML(
269 String::from(r#"<tr class="key"><th></th>"#)
270 + &columns.iter().fold(String::new(), |mut acc, col| {
271 let col_header = HTML::escape(col.as_ref());
272 write!(
273 &mut acc,
274 r#"<th id="{col_header}"><div><div>{col_header}</div></div></th>"#
275 )
276 .unwrap();
277 acc
278 })
279 + "</tr>\n",
280 )
281}
282
283/// # Errors
284///
285/// Will return `Err` if
286/// * there's an i/o error while reading `input`
287/// * the log has invalid syntax:
288/// * an indented line with no preceding non-indented line
289pub fn tablify(config: &Config, input: impl std::io::Read) -> Result<HTML, std::io::Error> {
290 let rows = read_rows(input).collect::<Result<Vec<_>, _>>()?;
291 let columns = column_order(config, &rows);
292 Ok(HTML(format!(
293 "{HEADER}{}{}{FOOTER}",
294 render_column_headers(&columns),
295 rows.into_iter()
296 .map(|mut r| render_row(&columns, &mut r))
297 .collect::<HTML>()
298 )))
299}
300
301#[cfg(test)]
302mod tests {
303 use super::*;
304
305 #[test]
306 fn test_parse_line() {
307 assert_eq!(InputLine::from(""), InputLine::Blank);
308 assert_eq!(InputLine::from(" "), InputLine::Blank);
309 assert_eq!(InputLine::from("foo"), InputLine::RowHeader("foo"));
310 assert_eq!(InputLine::from("foo "), InputLine::RowHeader("foo"));
311 assert_eq!(InputLine::from(" foo"), InputLine::Entry("foo", None));
312 assert_eq!(
313 InputLine::from(" foo:bar"),
314 InputLine::Entry("foo", Some("bar"))
315 );
316 assert_eq!(
317 InputLine::from(" foo: bar"),
318 InputLine::Entry("foo", Some("bar"))
319 );
320 assert_eq!(
321 InputLine::from(" foo: bar "),
322 InputLine::Entry("foo", Some("bar"))
323 );
324 assert_eq!(
325 InputLine::from(" foo: bar "),
326 InputLine::Entry("foo", Some("bar"))
327 );
328 assert_eq!(
329 InputLine::from(" foo : bar "),
330 InputLine::Entry("foo", Some("bar"))
331 );
332 }
333
334 #[test]
335 fn test_read_rows() {
336 assert_eq!(
337 read_rows(&b"foo"[..]).flatten().collect::<Vec<_>>(),
338 vec![Row {
339 label: "foo".to_owned(),
340 entries: HashMap::new(),
341 }]
342 );
343 assert_eq!(
344 read_rows(&b"bar"[..]).flatten().collect::<Vec<_>>(),
345 vec![Row {
346 label: "bar".to_owned(),
347 entries: HashMap::new(),
348 }]
349 );
350 assert_eq!(
351 read_rows(&b"foo\nbar\n"[..]).flatten().collect::<Vec<_>>(),
352 vec![
353 Row {
354 label: "foo".to_owned(),
355 entries: HashMap::new(),
356 },
357 Row {
358 label: "bar".to_owned(),
359 entries: HashMap::new(),
360 }
361 ]
362 );
363 assert_eq!(
364 read_rows(&b"foo\n bar\n"[..]).flatten().collect::<Vec<_>>(),
365 vec![Row {
366 label: "foo".to_owned(),
367 entries: HashMap::from([("bar".to_owned(), vec![None])]),
368 }]
369 );
370 assert_eq!(
371 read_rows(&b"foo\n bar\n baz\n"[..])
372 .flatten()
373 .collect::<Vec<_>>(),
374 vec![Row {
375 label: "foo".to_owned(),
376 entries: HashMap::from([
377 ("bar".to_owned(), vec![None]),
378 ("baz".to_owned(), vec![None])
379 ]),
380 }]
381 );
382 assert_eq!(
383 read_rows(&b"foo\n\nbar\n"[..])
384 .flatten()
385 .collect::<Vec<_>>(),
386 vec![
387 Row {
388 label: "foo".to_owned(),
389 entries: HashMap::new(),
390 },
391 Row {
392 label: "bar".to_owned(),
393 entries: HashMap::new(),
394 }
395 ]
396 );
397 assert_eq!(
398 read_rows(&b"foo\n \nbar\n"[..])
399 .flatten()
400 .collect::<Vec<_>>(),
401 vec![
402 Row {
403 label: "foo".to_owned(),
404 entries: HashMap::new(),
405 },
406 Row {
407 label: "bar".to_owned(),
408 entries: HashMap::new(),
409 }
410 ]
411 );
412 assert_eq!(
413 read_rows(&b"foo \n bar \n"[..])
414 .flatten()
415 .collect::<Vec<_>>(),
416 vec![Row {
417 label: "foo".to_owned(),
418 entries: HashMap::from([("bar".to_owned(), vec![None])]),
419 }]
420 );
421
422 let bad = read_rows(&b" foo"[..]).next().unwrap();
423 assert!(bad.is_err());
424 assert!(format!("{bad:?}").contains("1: Entry with no header"));
425
426 let bad2 = read_rows(&b"foo\n\n bar"[..]).nth(1).unwrap();
427 assert!(bad2.is_err());
428 assert!(format!("{bad2:?}").contains("3: Entry with no header"));
429 }
430
431 #[test]
432 fn test_column_counts() {
433 assert_eq!(
434 column_counts(
435 &read_rows(&b"foo\n bar\n baz\n"[..])
436 .collect::<Result<Vec<_>, _>>()
437 .unwrap()
438 ),
439 vec![(1, String::from("bar")), (1, String::from("baz"))]
440 );
441 assert_eq!(
442 column_counts(
443 &read_rows(&b"foo\n bar\n baz\nquux\n baz"[..])
444 .collect::<Result<Vec<_>, _>>()
445 .unwrap()
446 ),
447 vec![(2, String::from("baz")), (1, String::from("bar"))]
448 );
449 assert_eq!(
450 column_counts(
451 &read_rows(&b"foo\n bar\n bar\n baz\n bar\nquux\n baz"[..])
452 .collect::<Result<Vec<_>, _>>()
453 .unwrap()
454 ),
455 vec![(2, String::from("baz")), (1, String::from("bar"))]
456 );
457 assert_eq!(
458 column_counts(
459 &read_rows(&b"foo\n bar: 1\n bar: 2\n baz\n bar\nquux\n baz"[..])
460 .collect::<Result<Vec<_>, _>>()
461 .unwrap()
462 ),
463 vec![(2, String::from("baz")), (1, String::from("bar"))]
464 );
465 }
466
467 #[test]
468 fn test_render_cell() {
469 assert_eq!(
470 render_cell(
471 "foo",
472 &mut Row {
473 label: "nope".to_owned(),
474 entries: HashMap::new(),
475 }
476 ),
477 HTML::from(
478 r#"<td class="" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td>"#
479 )
480 );
481 assert_eq!(
482 render_cell(
483 "foo",
484 &mut Row {
485 label: "nope".to_owned(),
486 entries: HashMap::from([("bar".to_owned(), vec![None])]),
487 }
488 ),
489 HTML::from(
490 r#"<td class="" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td>"#
491 )
492 );
493 assert_eq!(
494 render_cell(
495 "foo",
496 &mut Row {
497 label: "nope".to_owned(),
498 entries: HashMap::from([("foo".to_owned(), vec![None])]),
499 }
500 ),
501 HTML::from(
502 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td>"#
503 )
504 );
505 assert_eq!(
506 render_cell(
507 "foo",
508 &mut Row {
509 label: "nope".to_owned(),
510 entries: HashMap::from([("foo".to_owned(), vec![None, None])]),
511 }
512 ),
513 HTML::from(
514 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">2</td>"#
515 )
516 );
517 assert_eq!(
518 render_cell(
519 "foo",
520 &mut Row {
521 label: "nope".to_owned(),
522 entries: HashMap::from([(
523 "foo".to_owned(),
524 vec![Some("5".to_owned()), Some("10".to_owned())]
525 )]),
526 }
527 ),
528 HTML::from(
529 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">5 10</td>"#
530 )
531 );
532 assert_eq!(
533 render_cell(
534 "foo",
535 &mut Row {
536 label: "nope".to_owned(),
537 entries: HashMap::from([("foo".to_owned(), vec![Some("5".to_owned()), None])]),
538 }
539 ),
540 HTML::from(
541 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">5 ✓</td>"#
542 )
543 );
544 assert_eq!(
545 render_cell(
546 "heart",
547 &mut Row {
548 label: "nope".to_owned(),
549 entries: HashMap::from([("heart".to_owned(), vec![Some("<3".to_owned())])]),
550 }
551 ),
552 HTML::from(
553 r#"<td class="yes" onmouseover="h2('nope','heart')" onmouseout="ch2('nope','heart')">&lt;3</td>"#
554 )
555 );
556 assert_eq!(
557 render_cell(
558 "foo",
559 &mut Row {
560 label: "bob's".to_owned(),
561 entries: HashMap::from([("foo".to_owned(), vec![None])]),
562 }
563 ),
564 HTML::from(
565 r#"<td class="yes" onmouseover="h2('bob&#39;s','foo')" onmouseout="ch2('bob&#39;s','foo')"></td>"#
566 )
567 );
568 let mut r = Row {
569 label: "nope".to_owned(),
570 entries: HashMap::from([
571 ("foo".to_owned(), vec![None]),
572 ("baz".to_owned(), vec![None]),
573 ]),
574 };
575 assert_eq!(r.entries.len(), 2);
576 render_cell("foo", &mut r);
577 assert_eq!(r.entries.len(), 1);
578 render_cell("bar", &mut r);
579 assert_eq!(r.entries.len(), 1);
580 render_cell("baz", &mut r);
581 assert_eq!(r.entries.len(), 0);
582 }
583
584 #[test]
585 fn test_render_leftovers() {
586 assert_eq!(
587 render_all_leftovers(&Row {
588 label: "nope".to_owned(),
589 entries: HashMap::from([("foo".to_owned(), vec![None])]),
590 }),
591 HTML::from("foo")
592 );
593 assert_eq!(
594 render_all_leftovers(&Row {
595 label: "nope".to_owned(),
596 entries: HashMap::from([
597 ("foo".to_owned(), vec![None]),
598 ("bar".to_owned(), vec![None])
599 ]),
600 }),
601 HTML::from("bar, foo")
602 );
603 assert_eq!(
604 render_all_leftovers(&Row {
605 label: "nope".to_owned(),
606 entries: HashMap::from([
607 ("foo".to_owned(), vec![None]),
608 ("bar".to_owned(), vec![None, None])
609 ]),
610 }),
611 HTML::from("bar: 2, foo")
612 );
613 }
614
615 #[test]
616 fn test_render_row() {
617 assert_eq!(
618 render_row(
619 &["foo".to_owned()],
620 &mut Row {
621 label: "nope".to_owned(),
622 entries: HashMap::from([("bar".to_owned(), vec![None])]),
623 }
624 ),
625 HTML::from(
626 r#"<tr><th id="nope">nope</th><td class="" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td><td onmouseover="highlight('nope')" onmouseout="clear_highlight('nope')">bar</td></tr>
627"#
628 )
629 );
630 }
631}
Summarize a text log as an HTML table