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