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