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