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