]> 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
Verify double-line-skip behavior without spacer rows
[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\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 \nbar\n"[..])
430 .flatten()
431 .collect::<Vec<_>>(),
432 vec![
433 Rowlike::Row(Row {
434 label: "foo".to_owned(),
435 entries: HashMap::new(),
436 }),
437 Rowlike::Row(Row {
438 label: "bar".to_owned(),
439 entries: HashMap::new(),
440 })
441 ]
442 );
443 assert_eq!(
444 read_rows(&b"foo \n bar \n"[..])
445 .flatten()
446 .collect::<Vec<_>>(),
447 vec![Rowlike::Row(Row {
448 label: "foo".to_owned(),
449 entries: HashMap::from([("bar".to_owned(), vec![None])]),
450 })]
451 );
452
453 let bad = read_rows(&b" foo"[..]).next().unwrap();
454 assert!(bad.is_err());
455 assert!(format!("{bad:?}").contains("1: Entry with no header"));
456
457 let bad2 = read_rows(&b"foo\n\n bar"[..]).nth(1).unwrap();
458 assert!(bad2.is_err());
459 assert!(format!("{bad2:?}").contains("3: Entry with no header"));
460 }
461
462 #[test]
463 fn test_column_counts() {
464 assert_eq!(
465 column_counts(
466 &read_rows(&b"foo\n bar\n baz\n"[..])
467 .collect::<Result<Vec<_>, _>>()
468 .unwrap()
469 ),
470 vec![(1, String::from("bar")), (1, String::from("baz"))]
471 );
472 assert_eq!(
473 column_counts(
474 &read_rows(&b"foo\n bar\n baz\nquux\n baz"[..])
475 .collect::<Result<Vec<_>, _>>()
476 .unwrap()
477 ),
478 vec![(2, String::from("baz")), (1, String::from("bar"))]
479 );
480 assert_eq!(
481 column_counts(
482 &read_rows(&b"foo\n bar\n bar\n baz\n bar\nquux\n baz"[..])
483 .collect::<Result<Vec<_>, _>>()
484 .unwrap()
485 ),
486 vec![(2, String::from("baz")), (1, String::from("bar"))]
487 );
488 assert_eq!(
489 column_counts(
490 &read_rows(&b"foo\n bar: 1\n bar: 2\n baz\n bar\nquux\n baz"[..])
491 .collect::<Result<Vec<_>, _>>()
492 .unwrap()
493 ),
494 vec![(2, String::from("baz")), (1, String::from("bar"))]
495 );
496 }
497
498 #[test]
499 fn test_render_cell() {
500 assert_eq!(
501 render_cell(
502 "foo",
503 &mut Row {
504 label: "nope".to_owned(),
505 entries: HashMap::new(),
506 }
507 ),
508 HTML::from(
509 r#"<td class="" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td>"#
510 )
511 );
512 assert_eq!(
513 render_cell(
514 "foo",
515 &mut Row {
516 label: "nope".to_owned(),
517 entries: HashMap::from([("bar".to_owned(), vec![None])]),
518 }
519 ),
520 HTML::from(
521 r#"<td class="" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td>"#
522 )
523 );
524 assert_eq!(
525 render_cell(
526 "foo",
527 &mut Row {
528 label: "nope".to_owned(),
529 entries: HashMap::from([("foo".to_owned(), vec![None])]),
530 }
531 ),
532 HTML::from(
533 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td>"#
534 )
535 );
536 assert_eq!(
537 render_cell(
538 "foo",
539 &mut Row {
540 label: "nope".to_owned(),
541 entries: HashMap::from([("foo".to_owned(), vec![None, None])]),
542 }
543 ),
544 HTML::from(
545 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">2</td>"#
546 )
547 );
548 assert_eq!(
549 render_cell(
550 "foo",
551 &mut Row {
552 label: "nope".to_owned(),
553 entries: HashMap::from([(
554 "foo".to_owned(),
555 vec![Some("5".to_owned()), Some("10".to_owned())]
556 )]),
557 }
558 ),
559 HTML::from(
560 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">5 10</td>"#
561 )
562 );
563 assert_eq!(
564 render_cell(
565 "foo",
566 &mut Row {
567 label: "nope".to_owned(),
568 entries: HashMap::from([("foo".to_owned(), vec![Some("5".to_owned()), None])]),
569 }
570 ),
571 HTML::from(
572 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">5 ✓</td>"#
573 )
574 );
575 assert_eq!(
576 render_cell(
577 "heart",
578 &mut Row {
579 label: "nope".to_owned(),
580 entries: HashMap::from([("heart".to_owned(), vec![Some("<3".to_owned())])]),
581 }
582 ),
583 HTML::from(
584 r#"<td class="yes" onmouseover="h2('nope','heart')" onmouseout="ch2('nope','heart')">&lt;3</td>"#
585 )
586 );
587 assert_eq!(
588 render_cell(
589 "foo",
590 &mut Row {
591 label: "bob's".to_owned(),
592 entries: HashMap::from([("foo".to_owned(), vec![None])]),
593 }
594 ),
595 HTML::from(
596 r#"<td class="yes" onmouseover="h2('bob&#39;s','foo')" onmouseout="ch2('bob&#39;s','foo')"></td>"#
597 )
598 );
599 let mut r = Row {
600 label: "nope".to_owned(),
601 entries: HashMap::from([
602 ("foo".to_owned(), vec![None]),
603 ("baz".to_owned(), vec![None]),
604 ]),
605 };
606 assert_eq!(r.entries.len(), 2);
607 render_cell("foo", &mut r);
608 assert_eq!(r.entries.len(), 1);
609 render_cell("bar", &mut r);
610 assert_eq!(r.entries.len(), 1);
611 render_cell("baz", &mut r);
612 assert_eq!(r.entries.len(), 0);
613 }
614
615 #[test]
616 fn test_render_leftovers() {
617 assert_eq!(
618 render_all_leftovers(&Row {
619 label: "nope".to_owned(),
620 entries: HashMap::from([("foo".to_owned(), vec![None])]),
621 }),
622 HTML::from("foo")
623 );
624 assert_eq!(
625 render_all_leftovers(&Row {
626 label: "nope".to_owned(),
627 entries: HashMap::from([
628 ("foo".to_owned(), vec![None]),
629 ("bar".to_owned(), vec![None])
630 ]),
631 }),
632 HTML::from("bar, foo")
633 );
634 assert_eq!(
635 render_all_leftovers(&Row {
636 label: "nope".to_owned(),
637 entries: HashMap::from([
638 ("foo".to_owned(), vec![None]),
639 ("bar".to_owned(), vec![None, None])
640 ]),
641 }),
642 HTML::from("bar: 2, foo")
643 );
644 }
645
646 #[test]
647 fn test_render_row() {
648 assert_eq!(
649 render_row(
650 &["foo".to_owned()],
651 &mut Rowlike::Row(Row {
652 label: "nope".to_owned(),
653 entries: HashMap::from([("bar".to_owned(), vec![None])]),
654 })
655 ),
656 HTML::from(
657 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>
658"#
659 )
660 );
661 }
662}
Summarize a text log as an HTML table