]> 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
Lighten background shading
[tablify] / src / lib.rs
... / ...
CommitLineData
1use std::borrow::ToOwned;
2use std::collections::{HashMap, HashSet};
3use std::fmt::Write;
4use std::io::BufRead;
5use std::iter::Iterator;
6
7fn tally_marks(n: usize) -> String {
8 let fives = { 0..n / 5 }.map(|_| '𝍸');
9 let ones = { 0..n % 5 }.map(|_| '𝍷');
10 fives.chain(ones).collect()
11}
12
13#[derive(PartialEq, Eq, Debug)]
14struct Config {
15 column_threshold: usize,
16 static_columns: Vec<Option<String>>,
17 hidden_columns: HashSet<String>,
18 substitute_labels: HashMap<String, String>,
19}
20impl Config {
21 fn apply_command(&mut self, line_num: usize, cmd: &str) -> Result<(), std::io::Error> {
22 if let Some(threshold) = cmd.strip_prefix("col_threshold ") {
23 self.column_threshold = threshold.parse().map_err(|e| {
24 std::io::Error::new(
25 std::io::ErrorKind::InvalidInput,
26 format!("line {line_num}: col_threshold must be numeric: {e}"),
27 )
28 })?;
29 } else if let Some(col) = cmd.strip_prefix("hide ") {
30 self.hidden_columns.insert(col.to_owned());
31 } else if let Some(col) = cmd.strip_prefix("col ") {
32 self.static_columns.push(Some(col.to_owned()));
33 } else if cmd == "colsep" {
34 self.static_columns.push(None);
35 } else if let Some(directive) = cmd.strip_prefix("label ") {
36 match directive.split_once(':') {
37 None => {
38 return Err(std::io::Error::new(
39 std::io::ErrorKind::InvalidInput,
40 format!("line {line_num}: Annotation missing ':'"),
41 ))
42 }
43 Some((col, label)) => self
44 .substitute_labels
45 .insert(col.to_owned(), label.to_owned()),
46 };
47 } else {
48 return Err(std::io::Error::new(
49 std::io::ErrorKind::InvalidInput,
50 format!("line {line_num}: Unknown command: {cmd}"),
51 ));
52 }
53 Ok(())
54 }
55}
56impl Default for Config {
57 fn default() -> Self {
58 Self {
59 column_threshold: 2,
60 static_columns: vec![],
61 hidden_columns: HashSet::new(),
62 substitute_labels: HashMap::new(),
63 }
64 }
65}
66
67const HEADER: &str = r#"<!DOCTYPE html>
68<html>
69<head>
70 <meta charset="utf-8">
71 <meta name="viewport" content="width=device-width, initial-scale=1">
72 <style>
73 td { text-align: center; }
74 /* h/t https://wabain.github.io/2019/10/13/css-rotated-table-header.html */
75 th, td { white-space: nowrap; }
76 th { text-align: left; font-weight: normal; }
77 th.spacer_row { height: .3em; }
78 .spacer_col { border: none; width: .2em; }
79 table { border-collapse: collapse }
80 tr.key > th { height: 10em; vertical-align: bottom; line-height: 1 }
81 tr.key > th > div { width: 1em; }
82 tr.key > th > div > div { width: 5em; transform-origin: bottom left; transform: translateX(1em) rotate(-65deg) }
83 td { border: thin solid gray; }
84 td.leftover { text-align: left; border: none; padding-left: .4em; }
85 td.yes { border: thin solid gray; background-color: #eee; }
86 /* h/t https://stackoverflow.com/questions/5687035/css-bolding-some-text-without-changing-its-containers-size/46452396#46452396 */
87 .highlight { text-shadow: -0.06ex 0 black, 0.06ex 0 black; }
88 </style>
89 <script>
90 function highlight(id) { const e = document.getElementById(id); if (e) { e.classList.add( "highlight"); } }
91 function clear_highlight(id) { const e = document.getElementById(id); if (e) { e.classList.remove("highlight"); } }
92 function h2(a, b) { highlight(a); highlight(b); }
93 function ch2(a, b) { clear_highlight(a); clear_highlight(b); }
94 </script>
95</head>
96<body>
97 <table>
98 <tbody>
99"#;
100const FOOTER: &str = " </tbody>
101 </table>
102</body>
103</html>";
104
105#[derive(PartialEq, Eq, Debug)]
106pub struct HTML(String);
107impl HTML {
108 fn escape(value: &str) -> HTML {
109 let mut escaped: String = String::new();
110 for c in value.chars() {
111 match c {
112 '>' => escaped.push_str("&gt;"),
113 '<' => escaped.push_str("&lt;"),
114 '\'' => escaped.push_str("&#39;"),
115 '"' => escaped.push_str("&quot;"),
116 '&' => escaped.push_str("&amp;"),
117 ok_c => escaped.push(ok_c),
118 }
119 }
120 HTML(escaped)
121 }
122}
123impl From<&str> for HTML {
124 fn from(value: &str) -> HTML {
125 HTML(String::from(value))
126 }
127}
128impl FromIterator<HTML> for HTML {
129 fn from_iter<T>(iter: T) -> HTML
130 where
131 T: IntoIterator<Item = HTML>,
132 {
133 HTML(iter.into_iter().map(|html| html.0).collect::<String>())
134 }
135}
136impl std::fmt::Display for HTML {
137 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
138 write!(f, "{}", self.0)
139 }
140}
141
142#[derive(Debug, PartialEq, Eq)]
143enum InputLine<'a> {
144 Blank,
145 RowHeader(&'a str),
146 Entry(&'a str, Option<&'a str>),
147 Command(&'a str),
148}
149impl<'a> From<&'a str> for InputLine<'a> {
150 fn from(value: &'a str) -> InputLine<'a> {
151 let trimmed = value.trim_end();
152 if trimmed.is_empty() {
153 InputLine::Blank
154 } else if let Some(cmd) = trimmed.strip_prefix('!') {
155 InputLine::Command(cmd)
156 } else if !trimmed.starts_with(' ') {
157 InputLine::RowHeader(value.trim())
158 } else {
159 match value.split_once(':') {
160 None => InputLine::Entry(value.trim(), None),
161 Some((col, instance)) => InputLine::Entry(col.trim(), Some(instance.trim())),
162 }
163 }
164 }
165}
166
167#[derive(Debug, PartialEq, Eq)]
168struct Row {
169 label: String,
170 entries: HashMap<String, Vec<Option<String>>>,
171}
172
173#[derive(Debug, PartialEq, Eq)]
174enum Rowlike {
175 Row(Row),
176 Spacer,
177}
178
179struct Reader<'cfg, Input: Iterator<Item = Result<String, std::io::Error>>> {
180 input: std::iter::Enumerate<Input>,
181 row: Option<Row>,
182 config: &'cfg mut Config,
183}
184impl<'cfg, Input: Iterator<Item = Result<String, std::io::Error>>> Reader<'cfg, Input> {
185 fn new(config: &'cfg mut Config, input: Input) -> Self {
186 Self {
187 input: input.enumerate(),
188 row: None,
189 config,
190 }
191 }
192}
193impl<'cfg, Input: Iterator<Item = Result<String, std::io::Error>>> Iterator
194 for Reader<'cfg, Input>
195{
196 type Item = Result<Rowlike, std::io::Error>;
197 fn next(&mut self) -> Option<Self::Item> {
198 loop {
199 match self.input.next() {
200 None => return Ok(std::mem::take(&mut self.row).map(Rowlike::Row)).transpose(),
201 Some((_, Err(e))) => return Some(Err(e)),
202 Some((n, Ok(line))) => match InputLine::from(line.as_ref()) {
203 InputLine::Command(cmd) => {
204 if let Err(e) = self.config.apply_command(n + 1, cmd) {
205 return Some(Err(e));
206 }
207 }
208 InputLine::Blank if self.row.is_some() => {
209 return Ok(std::mem::take(&mut self.row).map(Rowlike::Row)).transpose()
210 }
211 InputLine::Blank => return Some(Ok(Rowlike::Spacer)),
212 InputLine::Entry(col, instance) => match &mut self.row {
213 None => {
214 return Some(Err(std::io::Error::other(format!(
215 "line {}: Entry with no header",
216 n + 1
217 ))))
218 }
219 Some(ref mut row) => {
220 row.entries
221 .entry(col.to_owned())
222 .and_modify(|is| is.push(instance.map(ToOwned::to_owned)))
223 .or_insert_with(|| vec![instance.map(ToOwned::to_owned)]);
224 }
225 },
226 InputLine::RowHeader(row) => {
227 let prev = std::mem::take(&mut self.row);
228 self.row = Some(Row {
229 label: row.to_owned(),
230 entries: HashMap::new(),
231 });
232 if prev.is_some() {
233 return Ok(prev.map(Rowlike::Row)).transpose();
234 }
235 }
236 },
237 }
238 }
239 }
240}
241
242fn read_input(input: impl std::io::Read) -> Result<(Vec<Rowlike>, Config), std::io::Error> {
243 let mut config = Config::default();
244 let reader = Reader::new(&mut config, std::io::BufReader::new(input).lines());
245 reader
246 .collect::<Result<Vec<_>, _>>()
247 .map(|rows| (rows, config))
248}
249
250fn column_counts(rows: &[Rowlike]) -> Vec<(usize, String)> {
251 let empty = HashMap::new();
252 let mut counts: Vec<_> = rows
253 .iter()
254 .flat_map(|rl| match rl {
255 Rowlike::Row(r) => r.entries.keys(),
256 Rowlike::Spacer => empty.keys(),
257 })
258 .fold(HashMap::new(), |mut cs, col| {
259 cs.entry(col.to_owned())
260 .and_modify(|n| *n += 1)
261 .or_insert(1);
262 cs
263 })
264 .into_iter()
265 .map(|(col, n)| (n, col))
266 .collect();
267 counts.sort_unstable_by(|(an, acol), (bn, bcol)| bn.cmp(an).then(acol.cmp(bcol)));
268 counts
269}
270fn column_order(config: &Config, rows: &[Rowlike]) -> Vec<String> {
271 let static_columns: HashSet<&str> = config
272 .static_columns
273 .iter()
274 .flatten()
275 .map(std::string::String::as_str)
276 .collect();
277 column_counts(rows)
278 .into_iter()
279 .filter_map(|(n, col)| {
280 (n >= config.column_threshold
281 && !static_columns.contains(col.as_str())
282 && !config.hidden_columns.contains(&col))
283 .then_some(col)
284 })
285 .collect()
286}
287
288fn render_instances(instances: &[Option<String>]) -> HTML {
289 let mut tally = 0;
290 let mut out = vec![];
291 for ins in instances {
292 match ins {
293 None => tally += 1,
294 Some(content) => {
295 if tally > 0 {
296 out.push(HTML(tally_marks(tally)));
297 tally = 0;
298 }
299 out.push(HTML::escape(content));
300 }
301 }
302 }
303 if tally > 0 {
304 out.push(HTML(tally_marks(tally)));
305 }
306 HTML(
307 out.into_iter()
308 .map(|html| html.0) // Waiting for slice_concat_trait to stabilize
309 .collect::<Vec<_>>()
310 .join(" "),
311 )
312}
313
314fn render_cell(config: &Config, col: &str, row: &mut Row) -> HTML {
315 let row_label = HTML::escape(row.label.as_ref());
316 let col_label = HTML::escape(
317 config
318 .substitute_labels
319 .get(col)
320 .map_or(col, std::string::String::as_str),
321 );
322 let instances: Option<&Vec<Option<String>>> = row.entries.get(col);
323 let is_empty = match instances {
324 None => true,
325 Some(is) => is.iter().all(|ins| match ins {
326 None => false,
327 Some(content) => content == "×",
328 }),
329 };
330 let class = HTML::from(if is_empty { "" } else { r#" class="yes""# });
331 let contents = match instances {
332 None => HTML::from(""),
333 Some(is) => render_instances(is),
334 };
335 row.entries.remove(col);
336 HTML(format!(
337 r#"<td{class} onmouseover="h2('{row_label}','{col_label}')" onmouseout="ch2('{row_label}','{col_label}')">{contents}</td>"#
338 ))
339}
340
341fn render_leftover(notcol: &str, instances: &[Option<String>]) -> HTML {
342 let label = HTML::escape(notcol);
343 if instances.len() == 1 && instances[0].is_none() {
344 HTML(format!("{label}"))
345 } else {
346 let rest = render_instances(instances);
347 HTML(format!("{label}: {rest}"))
348 }
349}
350
351fn render_all_leftovers(config: &Config, row: &Row) -> HTML {
352 let mut order: Vec<_> = row
353 .entries
354 .keys()
355 .filter(|&col| !config.hidden_columns.contains(col))
356 .collect();
357 order.sort_unstable();
358 HTML(
359 order
360 .into_iter()
361 .map(|notcol| render_leftover(notcol, row.entries.get(notcol).expect("Key vanished?!")))
362 .map(|html| html.0) // Waiting for slice_concat_trait to stabilize
363 .collect::<Vec<_>>()
364 .join(", "),
365 )
366}
367
368fn render_row(config: &Config, columns: &[String], rowlike: &mut Rowlike) -> HTML {
369 match rowlike {
370 Rowlike::Spacer => HTML::from("<tr><th class=\"spacer_row\"></th></tr>\n"),
371 Rowlike::Row(row) => {
372 let row_label = HTML::escape(row.label.as_ref());
373 let static_cells = config
374 .static_columns
375 .iter()
376 .map(|ocol| match ocol {
377 Some(col) if config.hidden_columns.contains(col) => HTML::from(""),
378 Some(col) => render_cell(config, col, row),
379 None => HTML::from(r#"<td class="spacer_col"></td>"#),
380 })
381 .collect::<HTML>();
382 let dynamic_cells = columns
383 .iter()
384 .filter(|&col| !config.hidden_columns.contains(col))
385 .map(|col| render_cell(config, col, row))
386 .collect::<HTML>();
387 let leftovers = render_all_leftovers(config, row);
388 HTML(format!(
389 "<tr><th id=\"{row_label}\">{row_label}</th>{static_cells}{dynamic_cells}<td class=\"leftover\" onmouseover=\"highlight('{row_label}')\" onmouseout=\"clear_highlight('{row_label}')\">{leftovers}</td></tr>\n"
390 ))
391 }
392 }
393}
394
395fn column_header_labels<'a>(
396 config: &'a Config,
397 columns: &'a [String],
398) -> impl Iterator<Item = Option<&'a String>> {
399 let static_columns = config.static_columns.iter().map(|oc| oc.as_ref());
400 let dynamic_columns = columns.iter().map(Some);
401 static_columns
402 .chain(dynamic_columns)
403 .filter(|ocol| ocol.map_or(true, |col| !config.hidden_columns.contains(col)))
404 .map(|ocol| {
405 ocol.map(|col| match config.substitute_labels.get(col) {
406 None => col,
407 Some(substitute) => substitute,
408 })
409 })
410}
411
412fn render_column_headers(config: &Config, columns: &[String]) -> HTML {
413 HTML(
414 String::from(r#"<tr class="key"><th></th>"#)
415 + &column_header_labels(config, columns).fold(String::new(), |mut acc, ocol| {
416 match ocol {
417 Some(col) => {
418 let col_header = HTML::escape(col);
419 write!(
420 &mut acc,
421 r#"<th id="{col_header}"><div><div>{col_header}</div></div></th>"#
422 )
423 }
424 None => write!(&mut acc, r#"<th class="col_spacer"></th>"#),
425 }
426 .unwrap();
427 acc
428 })
429 + "</tr>\n",
430 )
431}
432
433/// # Errors
434///
435/// Will return `Err` if
436/// * there's an i/o error while reading `input`
437/// * the log has invalid syntax:
438/// * an indented line with no preceding non-indented line
439pub fn tablify(input: impl std::io::Read) -> Result<HTML, std::io::Error> {
440 let (rows, config) = read_input(input)?;
441 let columns = column_order(&config, &rows);
442 Ok(HTML(format!(
443 "{HEADER}{}{}{FOOTER}",
444 render_column_headers(&config, &columns),
445 rows.into_iter()
446 .map(|mut r| render_row(&config, &columns, &mut r))
447 .collect::<HTML>()
448 )))
449}
450
451#[cfg(test)]
452mod tests {
453 use super::*;
454
455 #[test]
456 fn test_parse_line() {
457 assert_eq!(InputLine::from(""), InputLine::Blank);
458 assert_eq!(InputLine::from(" "), InputLine::Blank);
459 assert_eq!(InputLine::from("foo"), InputLine::RowHeader("foo"));
460 assert_eq!(InputLine::from("foo "), InputLine::RowHeader("foo"));
461 assert_eq!(InputLine::from(" foo"), InputLine::Entry("foo", None));
462 assert_eq!(
463 InputLine::from(" foo:bar"),
464 InputLine::Entry("foo", Some("bar"))
465 );
466 assert_eq!(
467 InputLine::from(" foo: bar"),
468 InputLine::Entry("foo", Some("bar"))
469 );
470 assert_eq!(
471 InputLine::from(" foo: bar "),
472 InputLine::Entry("foo", Some("bar"))
473 );
474 assert_eq!(
475 InputLine::from(" foo: bar "),
476 InputLine::Entry("foo", Some("bar"))
477 );
478 assert_eq!(
479 InputLine::from(" foo : bar "),
480 InputLine::Entry("foo", Some("bar"))
481 );
482 }
483
484 #[test]
485 fn test_tally_marks() {
486 assert_eq!(tally_marks(1), "𝍷");
487 assert_eq!(tally_marks(2), "𝍷𝍷");
488 assert_eq!(tally_marks(3), "𝍷𝍷𝍷");
489 assert_eq!(tally_marks(4), "𝍷𝍷𝍷𝍷");
490 assert_eq!(tally_marks(5), "𝍸");
491 assert_eq!(tally_marks(6), "𝍸𝍷");
492 assert_eq!(tally_marks(7), "𝍸𝍷𝍷");
493 assert_eq!(tally_marks(8), "𝍸𝍷𝍷𝍷");
494 assert_eq!(tally_marks(9), "𝍸𝍷𝍷𝍷𝍷");
495 assert_eq!(tally_marks(10), "𝍸𝍸");
496 assert_eq!(tally_marks(11), "𝍸𝍸𝍷");
497 }
498
499 fn read_rows(input: impl std::io::Read) -> Result<Vec<Rowlike>, std::io::Error> {
500 read_input(input).map(|(rows, _)| rows)
501 }
502 fn read_config(input: impl std::io::Read) -> Result<Config, std::io::Error> {
503 read_input(input).map(|(_, config)| config)
504 }
505 #[test]
506 fn test_read_rows() {
507 assert_eq!(
508 read_rows(&b"foo"[..]).unwrap(),
509 vec![Rowlike::Row(Row {
510 label: "foo".to_owned(),
511 entries: HashMap::new(),
512 })]
513 );
514 assert_eq!(
515 read_rows(&b"bar"[..]).unwrap(),
516 vec![Rowlike::Row(Row {
517 label: "bar".to_owned(),
518 entries: HashMap::new(),
519 })]
520 );
521 assert_eq!(
522 read_rows(&b"foo\nbar\n"[..]).unwrap(),
523 vec![
524 Rowlike::Row(Row {
525 label: "foo".to_owned(),
526 entries: HashMap::new(),
527 }),
528 Rowlike::Row(Row {
529 label: "bar".to_owned(),
530 entries: HashMap::new(),
531 })
532 ]
533 );
534 assert_eq!(
535 read_rows(&b"foo\n bar\n"[..]).unwrap(),
536 vec![Rowlike::Row(Row {
537 label: "foo".to_owned(),
538 entries: HashMap::from([("bar".to_owned(), vec![None])]),
539 })]
540 );
541 assert_eq!(
542 read_rows(&b"foo\n bar\n baz\n"[..]).unwrap(),
543 vec![Rowlike::Row(Row {
544 label: "foo".to_owned(),
545 entries: HashMap::from([
546 ("bar".to_owned(), vec![None]),
547 ("baz".to_owned(), vec![None])
548 ]),
549 })]
550 );
551 assert_eq!(
552 read_rows(&b"foo\n\nbar\n"[..]).unwrap(),
553 vec![
554 Rowlike::Row(Row {
555 label: "foo".to_owned(),
556 entries: HashMap::new(),
557 }),
558 Rowlike::Row(Row {
559 label: "bar".to_owned(),
560 entries: HashMap::new(),
561 })
562 ]
563 );
564 assert_eq!(
565 read_rows(&b"foo\n\n\nbar\n"[..]).unwrap(),
566 vec![
567 Rowlike::Row(Row {
568 label: "foo".to_owned(),
569 entries: HashMap::new(),
570 }),
571 Rowlike::Spacer,
572 Rowlike::Row(Row {
573 label: "bar".to_owned(),
574 entries: HashMap::new(),
575 })
576 ]
577 );
578 assert_eq!(
579 read_rows(&b"foo\n \nbar\n"[..]).unwrap(),
580 vec![
581 Rowlike::Row(Row {
582 label: "foo".to_owned(),
583 entries: HashMap::new(),
584 }),
585 Rowlike::Row(Row {
586 label: "bar".to_owned(),
587 entries: HashMap::new(),
588 })
589 ]
590 );
591 assert_eq!(
592 read_rows(&b"foo \n bar \n"[..]).unwrap(),
593 vec![Rowlike::Row(Row {
594 label: "foo".to_owned(),
595 entries: HashMap::from([("bar".to_owned(), vec![None])]),
596 })]
597 );
598
599 let bad = read_rows(&b" foo"[..]);
600 assert!(bad.is_err());
601 assert!(format!("{bad:?}").contains("line 1: Entry with no header"));
602
603 let bad2 = read_rows(&b"foo\n\n bar"[..]);
604 assert!(bad2.is_err());
605 assert!(format!("{bad2:?}").contains("line 3: Entry with no header"));
606 }
607
608 #[test]
609 fn test_read_config() {
610 assert_eq!(
611 read_config(&b"!col_threshold 10"[..])
612 .unwrap()
613 .column_threshold,
614 10
615 );
616 assert_eq!(
617 read_config(&b"!col foo"[..]).unwrap().static_columns,
618 vec![Some("foo".to_owned())]
619 );
620 assert_eq!(
621 read_config(&b"!label foo:bar"[..])
622 .unwrap()
623 .substitute_labels["foo"],
624 "bar"
625 );
626
627 let bad_command = read_config(&b"!no such command"[..]);
628 assert!(bad_command.is_err());
629 assert!(format!("{bad_command:?}").contains("line 1: Unknown command"));
630
631 let bad_num = read_config(&b"!col_threshold foo"[..]);
632 assert!(bad_num.is_err());
633 assert!(format!("{bad_num:?}").contains("line 1: col_threshold must be numeric"));
634
635 let bad_sub = read_config(&b"!label foo"[..]);
636 assert!(bad_sub.is_err());
637 assert!(format!("{bad_sub:?}").contains("line 1: Annotation missing ':'"));
638 }
639
640 #[test]
641 fn test_column_counts() {
642 assert_eq!(
643 column_counts(&read_rows(&b"foo\n bar\n baz\n"[..]).unwrap()),
644 vec![(1, String::from("bar")), (1, String::from("baz"))]
645 );
646 assert_eq!(
647 column_counts(&read_rows(&b"foo\n bar\n baz\nquux\n baz"[..]).unwrap()),
648 vec![(2, String::from("baz")), (1, String::from("bar"))]
649 );
650 assert_eq!(
651 column_counts(&read_rows(&b"foo\n bar\n bar\n baz\n bar\nquux\n baz"[..]).unwrap()),
652 vec![(2, String::from("baz")), (1, String::from("bar"))]
653 );
654 assert_eq!(
655 column_counts(
656 &read_rows(&b"foo\n bar: 1\n bar: 2\n baz\n bar\nquux\n baz"[..]).unwrap()
657 ),
658 vec![(2, String::from("baz")), (1, String::from("bar"))]
659 );
660 }
661
662 #[test]
663 fn test_column_header_labels() {
664 let mut cfg = Config::default();
665
666 assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([Some(&"foo".to_owned())]));
667
668 cfg.static_columns.push(Some("bar".to_owned()));
669 assert!(column_header_labels(&cfg, &["foo".to_owned()])
670 .eq([Some(&"bar".to_owned()), Some(&"foo".to_owned())]));
671
672 cfg.static_columns.push(None);
673 assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([
674 Some(&"bar".to_owned()),
675 None,
676 Some(&"foo".to_owned())
677 ]));
678
679 cfg.substitute_labels
680 .insert("foo".to_owned(), "foo (bits)".to_owned());
681 assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([
682 Some(&"bar".to_owned()),
683 None,
684 Some(&"foo (bits)".to_owned())
685 ]));
686
687 cfg.hidden_columns.insert("foo".to_owned());
688 assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([Some(&"bar".to_owned()), None]));
689
690 cfg.hidden_columns.insert("bar".to_owned());
691 assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([None]));
692 }
693
694 #[test]
695 fn test_render_cell() {
696 assert_eq!(
697 render_cell(
698 &Config::default(),
699 "foo",
700 &mut Row {
701 label: "nope".to_owned(),
702 entries: HashMap::new(),
703 }
704 ),
705 HTML::from(
706 r#"<td onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td>"#
707 )
708 );
709 assert_eq!(
710 render_cell(
711 &Config::default(),
712 "foo",
713 &mut Row {
714 label: "nope".to_owned(),
715 entries: HashMap::from([("bar".to_owned(), vec![None])]),
716 }
717 ),
718 HTML::from(
719 r#"<td onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td>"#
720 )
721 );
722 assert_eq!(
723 render_cell(
724 &Config::default(),
725 "foo",
726 &mut Row {
727 label: "nope".to_owned(),
728 entries: HashMap::from([("foo".to_owned(), vec![None])]),
729 }
730 ),
731 HTML::from(
732 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">𝍷</td>"#
733 )
734 );
735 assert_eq!(
736 render_cell(
737 &Config::default(),
738 "foo",
739 &mut Row {
740 label: "nope".to_owned(),
741 entries: HashMap::from([("foo".to_owned(), vec![None, None])]),
742 }
743 ),
744 HTML::from(
745 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">𝍷𝍷</td>"#
746 )
747 );
748 assert_eq!(
749 render_cell(
750 &Config::default(),
751 "foo",
752 &mut Row {
753 label: "nope".to_owned(),
754 entries: HashMap::from([(
755 "foo".to_owned(),
756 vec![Some("5".to_owned()), Some("10".to_owned())]
757 )]),
758 }
759 ),
760 HTML::from(
761 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">5 10</td>"#
762 )
763 );
764 assert_eq!(
765 render_cell(
766 &Config::default(),
767 "foo",
768 &mut Row {
769 label: "nope".to_owned(),
770 entries: HashMap::from([("foo".to_owned(), vec![Some("5".to_owned()), None])]),
771 }
772 ),
773 HTML::from(
774 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">5 𝍷</td>"#
775 )
776 );
777 assert_eq!(
778 render_cell(
779 &Config::default(),
780 "foo",
781 &mut Row {
782 label: "nope".to_owned(),
783 entries: HashMap::from([("foo".to_owned(), vec![Some("×".to_owned())])]),
784 }
785 ),
786 HTML::from(
787 r#"<td onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">×</td>"#
788 )
789 );
790 assert_eq!(
791 render_cell(
792 &Config::default(),
793 "heart",
794 &mut Row {
795 label: "nope".to_owned(),
796 entries: HashMap::from([("heart".to_owned(), vec![Some("<3".to_owned())])]),
797 }
798 ),
799 HTML::from(
800 r#"<td class="yes" onmouseover="h2('nope','heart')" onmouseout="ch2('nope','heart')">&lt;3</td>"#
801 )
802 );
803 assert_eq!(
804 render_cell(
805 &Config::default(),
806 "foo",
807 &mut Row {
808 label: "bob's".to_owned(),
809 entries: HashMap::from([("foo".to_owned(), vec![None])]),
810 }
811 ),
812 HTML::from(
813 r#"<td class="yes" onmouseover="h2('bob&#39;s','foo')" onmouseout="ch2('bob&#39;s','foo')">𝍷</td>"#
814 )
815 );
816 let mut r = Row {
817 label: "nope".to_owned(),
818 entries: HashMap::from([
819 ("foo".to_owned(), vec![None]),
820 ("baz".to_owned(), vec![None]),
821 ]),
822 };
823 assert_eq!(r.entries.len(), 2);
824 render_cell(&Config::default(), "foo", &mut r);
825 assert_eq!(r.entries.len(), 1);
826 render_cell(&Config::default(), "bar", &mut r);
827 assert_eq!(r.entries.len(), 1);
828 render_cell(&Config::default(), "baz", &mut r);
829 assert_eq!(r.entries.len(), 0);
830 }
831
832 #[test]
833 fn test_render_leftovers() {
834 assert_eq!(
835 render_all_leftovers(
836 &Config::default(),
837 &Row {
838 label: "nope".to_owned(),
839 entries: HashMap::from([("foo".to_owned(), vec![None])]),
840 }
841 ),
842 HTML::from("foo")
843 );
844 assert_eq!(
845 render_all_leftovers(
846 &Config::default(),
847 &Row {
848 label: "nope".to_owned(),
849 entries: HashMap::from([
850 ("foo".to_owned(), vec![None]),
851 ("bar".to_owned(), vec![None])
852 ]),
853 }
854 ),
855 HTML::from("bar, foo")
856 );
857 assert_eq!(
858 render_all_leftovers(
859 &Config::default(),
860 &Row {
861 label: "nope".to_owned(),
862 entries: HashMap::from([
863 ("foo".to_owned(), vec![None]),
864 ("bar".to_owned(), vec![None, None])
865 ]),
866 }
867 ),
868 HTML::from("bar: 𝍷𝍷, foo")
869 );
870 assert_eq!(
871 render_all_leftovers(
872 &Config {
873 column_threshold: 2,
874 static_columns: vec![],
875 hidden_columns: HashSet::from(["private".to_owned()]),
876 substitute_labels: HashMap::new(),
877 },
878 &Row {
879 label: "nope".to_owned(),
880 entries: HashMap::from([("private".to_owned(), vec![None]),]),
881 }
882 ),
883 HTML::from("")
884 );
885 }
886
887 #[test]
888 fn test_render_row() {
889 assert_eq!(
890 render_row(
891 &Config::default(),
892 &["foo".to_owned()],
893 &mut Rowlike::Row(Row {
894 label: "nope".to_owned(),
895 entries: HashMap::from([("bar".to_owned(), vec![None])]),
896 })
897 ),
898 HTML::from(
899 r#"<tr><th id="nope">nope</th><td onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td><td class="leftover" onmouseover="highlight('nope')" onmouseout="clear_highlight('nope')">bar</td></tr>
900"#
901 )
902 );
903 assert_eq!(
904 render_row(
905 &Config {
906 column_threshold: 0,
907 static_columns: vec![Some("foo".to_owned()), Some("bar".to_owned())],
908 hidden_columns: HashSet::new(),
909 substitute_labels: HashMap::new(),
910 },
911 &["baz".to_owned()],
912 &mut Rowlike::Row(Row {
913 label: "nope".to_owned(),
914 entries: HashMap::from([
915 ("bar".to_owned(), vec![Some("r".to_owned())]),
916 ("baz".to_owned(), vec![Some("z".to_owned())]),
917 ("foo".to_owned(), vec![Some("f".to_owned())]),
918 ]),
919 })
920 ),
921 HTML::from(
922 r#"<tr><th id="nope">nope</th><td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">f</td><td class="yes" onmouseover="h2('nope','bar')" onmouseout="ch2('nope','bar')">r</td><td class="yes" onmouseover="h2('nope','baz')" onmouseout="ch2('nope','baz')">z</td><td class="leftover" onmouseover="highlight('nope')" onmouseout="clear_highlight('nope')"></td></tr>
923"#
924 )
925 );
926 assert_eq!(
927 render_row(
928 &Config {
929 column_threshold: 0,
930 static_columns: vec![Some("foo".to_owned()), None, Some("bar".to_owned())],
931 hidden_columns: HashSet::new(),
932 substitute_labels: HashMap::new(),
933 },
934 &[],
935 &mut Rowlike::Row(Row {
936 label: "nope".to_owned(),
937 entries: HashMap::from([
938 ("bar".to_owned(), vec![Some("r".to_owned())]),
939 ("foo".to_owned(), vec![Some("f".to_owned())]),
940 ]),
941 })
942 ),
943 HTML::from(
944 r#"<tr><th id="nope">nope</th><td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">f</td><td class="spacer_col"></td><td class="yes" onmouseover="h2('nope','bar')" onmouseout="ch2('nope','bar')">r</td><td class="leftover" onmouseover="highlight('nope')" onmouseout="clear_highlight('nope')"></td></tr>
945"#
946 )
947 );
948 assert_eq!(
949 render_row(
950 &Config {
951 column_threshold: 0,
952 static_columns: vec![],
953 hidden_columns: HashSet::from(["foo".to_owned()]),
954 substitute_labels: HashMap::new(),
955 },
956 &[],
957 &mut Rowlike::Row(Row {
958 label: "nope".to_owned(),
959 entries: HashMap::from([("foo".to_owned(), vec![Some("f".to_owned())]),]),
960 })
961 ),
962 HTML::from(
963 r#"<tr><th id="nope">nope</th><td class="leftover" onmouseover="highlight('nope')" onmouseout="clear_highlight('nope')"></td></tr>
964"#
965 )
966 );
967 assert_eq!(
968 render_row(
969 &Config {
970 column_threshold: 0,
971 static_columns: vec![Some("foo".to_owned())],
972 hidden_columns: HashSet::from(["foo".to_owned()]),
973 substitute_labels: HashMap::new(),
974 },
975 &[],
976 &mut Rowlike::Row(Row {
977 label: "nope".to_owned(),
978 entries: HashMap::from([("foo".to_owned(), vec![Some("f".to_owned())]),]),
979 })
980 ),
981 HTML::from(
982 r#"<tr><th id="nope">nope</th><td class="leftover" onmouseover="highlight('nope')" onmouseout="clear_highlight('nope')"></td></tr>
983"#
984 )
985 );
986 assert_eq!(
987 render_row(
988 &Config {
989 column_threshold: 0,
990 static_columns: vec![],
991 hidden_columns: HashSet::new(),
992 substitute_labels: HashMap::from([("foo".to_owned(), "bar".to_owned())]),
993 },
994 &["foo".to_owned()],
995 &mut Rowlike::Row(Row {
996 label: "nope".to_owned(),
997 entries: HashMap::from([("foo".to_owned(), vec![None])]),
998 })
999 ),
1000 HTML::from(
1001 r#"<tr><th id="nope">nope</th><td class="yes" onmouseover="h2('nope','bar')" onmouseout="ch2('nope','bar')">𝍷</td><td class="leftover" onmouseover="highlight('nope')" onmouseout="clear_highlight('nope')"></td></tr>
1002"#
1003 )
1004 );
1005 }
1006}
Summarize a text log as an HTML table