git.scottworley.com Git - tablify/blob - src/lib.rs

   1 use std::borrow::ToOwned;
   2 use std::collections::{HashMap, HashSet};
   3 use std::fmt::Write;
   4 use std::io::BufRead;
   5 use std::iter::Iterator;
   6
   7 fn 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)]
  14 struct Config {
  15     column_threshold: usize,
  16     static_columns: Vec<Option<String>>,
  17     hidden_columns: HashSet<String>,
  18     substitute_labels: HashMap<String, String>,
  19 }
  20 impl 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 }
  56 impl 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
  67 const 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: #ddd; }
  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 "#;
 100 const FOOTER: &str = "    </tbody>
 101   </table>
 102 </body>
 103 </html>";
 104
 105 #[derive(PartialEq, Eq, Debug)]
 106 pub struct HTML(String);
 107 impl 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 }
 123 impl From<&str> for HTML {
 124     fn from(value: &str) -> HTML {
 125         HTML(String::from(value))
 126     }
 127 }
 128 impl 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 }
 136 impl 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)]
 143 enum InputLine<'a> {
 144     Blank,
 145     RowHeader(&'a str),
 146     Entry(&'a str, Option<&'a str>),
 147     Command(&'a str),
 148 }
 149 impl<'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)]
 168 struct Row {
 169     label: String,
 170     entries: HashMap<String, Vec<Option<String>>>,
 171 }
 172
 173 #[derive(Debug, PartialEq, Eq)]
 174 enum Rowlike {
 175     Row(Row),
 176     Spacer,
 177 }
 178
 179 struct 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 }
 184 impl<'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 }
 193 impl<'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
 242 fn 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
 250 fn 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 }
 270 fn 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
 288 fn 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
 314 fn 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(col);
 317     let instances: Option<&Vec<Option<String>>> = row.entries.get(col);
 318     let is_empty = match instances {
 319         None => true,
 320         Some(is) => is.iter().all(|ins| match ins {
 321             None => false,
 322             Some(content) => content == "×",
 323         }),
 324     };
 325     let class = HTML::from(if is_empty { "" } else { r#" class="yes""# });
 326     let contents = match instances {
 327         None => HTML::from(""),
 328         Some(is) => render_instances(is),
 329     };
 330     row.entries.remove(col);
 331     HTML(format!(
 332         r#"<td{class} onmouseover="h2('{row_label}','{col_label}')" onmouseout="ch2('{row_label}','{col_label}')">{contents}</td>"#
 333     ))
 334 }
 335
 336 fn render_leftover(notcol: &str, instances: &[Option<String>]) -> HTML {
 337     let label = HTML::escape(notcol);
 338     if instances.len() == 1 && instances[0].is_none() {
 339         HTML(format!("{label}"))
 340     } else {
 341         let rest = render_instances(instances);
 342         HTML(format!("{label}: {rest}"))
 343     }
 344 }
 345
 346 fn render_all_leftovers(config: &Config, row: &Row) -> HTML {
 347     let mut order: Vec<_> = row
 348         .entries
 349         .keys()
 350         .filter(|&col| !config.hidden_columns.contains(col))
 351         .collect();
 352     order.sort_unstable();
 353     HTML(
 354         order
 355             .into_iter()
 356             .map(|notcol| render_leftover(notcol, row.entries.get(notcol).expect("Key vanished?!")))
 357             .map(|html| html.0) // Waiting for slice_concat_trait to stabilize
 358             .collect::<Vec<_>>()
 359             .join(", "),
 360     )
 361 }
 362
 363 fn render_row(config: &Config, columns: &[String], rowlike: &mut Rowlike) -> HTML {
 364     match rowlike {
 365         Rowlike::Spacer => HTML::from("<tr><th class=\"spacer_row\"></th></tr>\n"),
 366         Rowlike::Row(row) => {
 367             let row_label = HTML::escape(row.label.as_ref());
 368             let static_cells = config
 369                 .static_columns
 370                 .iter()
 371                 .map(|ocol| match ocol {
 372                     Some(col) if config.hidden_columns.contains(col) => HTML::from(""),
 373                     Some(col) => render_cell(config, col, row),
 374                     None => HTML::from(r#"<td class="spacer_col"></td>"#),
 375                 })
 376                 .collect::<HTML>();
 377             let dynamic_cells = columns
 378                 .iter()
 379                 .filter(|&col| !config.hidden_columns.contains(col))
 380                 .map(|col| render_cell(config, col, row))
 381                 .collect::<HTML>();
 382             let leftovers = render_all_leftovers(config, row);
 383             HTML(format!(
 384                 "<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"
 385             ))
 386         }
 387     }
 388 }
 389
 390 fn column_header_labels<'a>(
 391     config: &'a Config,
 392     columns: &'a [String],
 393 ) -> impl Iterator<Item = Option<&'a String>> {
 394     let static_columns = config.static_columns.iter().map(|oc| oc.as_ref());
 395     let dynamic_columns = columns.iter().map(Some);
 396     static_columns
 397         .chain(dynamic_columns)
 398         .filter(|ocol| ocol.map_or(true, |col| !config.hidden_columns.contains(col)))
 399         .map(|ocol| {
 400             ocol.map(|col| match config.substitute_labels.get(col) {
 401                 None => col,
 402                 Some(substitute) => substitute,
 403             })
 404         })
 405 }
 406
 407 fn render_column_headers(config: &Config, columns: &[String]) -> HTML {
 408     HTML(
 409         String::from(r#"<tr class="key"><th></th>"#)
 410             + &column_header_labels(config, columns).fold(String::new(), |mut acc, ocol| {
 411                 match ocol {
 412                     Some(col) => {
 413                         let col_header = HTML::escape(col);
 414                         write!(
 415                             &mut acc,
 416                             r#"<th id="{col_header}"><div><div>{col_header}</div></div></th>"#
 417                         )
 418                     }
 419                     None => write!(&mut acc, r#"<th class="col_spacer"></th>"#),
 420                 }
 421                 .unwrap();
 422                 acc
 423             })
 424             + "</tr>\n",
 425     )
 426 }
 427
 428 /// # Errors
 429 ///
 430 /// Will return `Err` if
 431 ///   * there's an i/o error while reading `input`
 432 ///   * the log has invalid syntax:
 433 ///     * an indented line with no preceding non-indented line
 434 pub fn tablify(input: impl std::io::Read) -> Result<HTML, std::io::Error> {
 435     let (rows, config) = read_input(input)?;
 436     let columns = column_order(&config, &rows);
 437     Ok(HTML(format!(
 438         "{HEADER}{}{}{FOOTER}",
 439         render_column_headers(&config, &columns),
 440         rows.into_iter()
 441             .map(|mut r| render_row(&config, &columns, &mut r))
 442             .collect::<HTML>()
 443     )))
 444 }
 445
 446 #[cfg(test)]
 447 mod tests {
 448     use super::*;
 449
 450     #[test]
 451     fn test_parse_line() {
 452         assert_eq!(InputLine::from(""), InputLine::Blank);
 453         assert_eq!(InputLine::from(" "), InputLine::Blank);
 454         assert_eq!(InputLine::from("foo"), InputLine::RowHeader("foo"));
 455         assert_eq!(InputLine::from("foo "), InputLine::RowHeader("foo"));
 456         assert_eq!(InputLine::from(" foo"), InputLine::Entry("foo", None));
 457         assert_eq!(
 458             InputLine::from(" foo:bar"),
 459             InputLine::Entry("foo", Some("bar"))
 460         );
 461         assert_eq!(
 462             InputLine::from(" foo: bar"),
 463             InputLine::Entry("foo", Some("bar"))
 464         );
 465         assert_eq!(
 466             InputLine::from(" foo: bar "),
 467             InputLine::Entry("foo", Some("bar"))
 468         );
 469         assert_eq!(
 470             InputLine::from(" foo:  bar "),
 471             InputLine::Entry("foo", Some("bar"))
 472         );
 473         assert_eq!(
 474             InputLine::from(" foo :  bar "),
 475             InputLine::Entry("foo", Some("bar"))
 476         );
 477     }
 478
 479     #[test]
 480     fn test_tally_marks() {
 481         assert_eq!(tally_marks(1), "𝍷");
 482         assert_eq!(tally_marks(2), "𝍷𝍷");
 483         assert_eq!(tally_marks(3), "𝍷𝍷𝍷");
 484         assert_eq!(tally_marks(4), "𝍷𝍷𝍷𝍷");
 485         assert_eq!(tally_marks(5), "𝍸");
 486         assert_eq!(tally_marks(6), "𝍸𝍷");
 487         assert_eq!(tally_marks(7), "𝍸𝍷𝍷");
 488         assert_eq!(tally_marks(8), "𝍸𝍷𝍷𝍷");
 489         assert_eq!(tally_marks(9), "𝍸𝍷𝍷𝍷𝍷");
 490         assert_eq!(tally_marks(10), "𝍸𝍸");
 491         assert_eq!(tally_marks(11), "𝍸𝍸𝍷");
 492     }
 493
 494     fn read_rows(input: impl std::io::Read) -> Result<Vec<Rowlike>, std::io::Error> {
 495         read_input(input).map(|(rows, _)| rows)
 496     }
 497     fn read_config(input: impl std::io::Read) -> Result<Config, std::io::Error> {
 498         read_input(input).map(|(_, config)| config)
 499     }
 500     #[test]
 501     fn test_read_rows() {
 502         assert_eq!(
 503             read_rows(&b"foo"[..]).unwrap(),
 504             vec![Rowlike::Row(Row {
 505                 label: "foo".to_owned(),
 506                 entries: HashMap::new(),
 507             })]
 508         );
 509         assert_eq!(
 510             read_rows(&b"bar"[..]).unwrap(),
 511             vec![Rowlike::Row(Row {
 512                 label: "bar".to_owned(),
 513                 entries: HashMap::new(),
 514             })]
 515         );
 516         assert_eq!(
 517             read_rows(&b"foo\nbar\n"[..]).unwrap(),
 518             vec![
 519                 Rowlike::Row(Row {
 520                     label: "foo".to_owned(),
 521                     entries: HashMap::new(),
 522                 }),
 523                 Rowlike::Row(Row {
 524                     label: "bar".to_owned(),
 525                     entries: HashMap::new(),
 526                 })
 527             ]
 528         );
 529         assert_eq!(
 530             read_rows(&b"foo\n bar\n"[..]).unwrap(),
 531             vec![Rowlike::Row(Row {
 532                 label: "foo".to_owned(),
 533                 entries: HashMap::from([("bar".to_owned(), vec![None])]),
 534             })]
 535         );
 536         assert_eq!(
 537             read_rows(&b"foo\n bar\n baz\n"[..]).unwrap(),
 538             vec![Rowlike::Row(Row {
 539                 label: "foo".to_owned(),
 540                 entries: HashMap::from([
 541                     ("bar".to_owned(), vec![None]),
 542                     ("baz".to_owned(), vec![None])
 543                 ]),
 544             })]
 545         );
 546         assert_eq!(
 547             read_rows(&b"foo\n\nbar\n"[..]).unwrap(),
 548             vec![
 549                 Rowlike::Row(Row {
 550                     label: "foo".to_owned(),
 551                     entries: HashMap::new(),
 552                 }),
 553                 Rowlike::Row(Row {
 554                     label: "bar".to_owned(),
 555                     entries: HashMap::new(),
 556                 })
 557             ]
 558         );
 559         assert_eq!(
 560             read_rows(&b"foo\n\n\nbar\n"[..]).unwrap(),
 561             vec![
 562                 Rowlike::Row(Row {
 563                     label: "foo".to_owned(),
 564                     entries: HashMap::new(),
 565                 }),
 566                 Rowlike::Spacer,
 567                 Rowlike::Row(Row {
 568                     label: "bar".to_owned(),
 569                     entries: HashMap::new(),
 570                 })
 571             ]
 572         );
 573         assert_eq!(
 574             read_rows(&b"foo\n \nbar\n"[..]).unwrap(),
 575             vec![
 576                 Rowlike::Row(Row {
 577                     label: "foo".to_owned(),
 578                     entries: HashMap::new(),
 579                 }),
 580                 Rowlike::Row(Row {
 581                     label: "bar".to_owned(),
 582                     entries: HashMap::new(),
 583                 })
 584             ]
 585         );
 586         assert_eq!(
 587             read_rows(&b"foo  \n bar  \n"[..]).unwrap(),
 588             vec![Rowlike::Row(Row {
 589                 label: "foo".to_owned(),
 590                 entries: HashMap::from([("bar".to_owned(), vec![None])]),
 591             })]
 592         );
 593
 594         let bad = read_rows(&b" foo"[..]);
 595         assert!(bad.is_err());
 596         assert!(format!("{bad:?}").contains("line 1: Entry with no header"));
 597
 598         let bad2 = read_rows(&b"foo\n\n bar"[..]);
 599         assert!(bad2.is_err());
 600         assert!(format!("{bad2:?}").contains("line 3: Entry with no header"));
 601     }
 602
 603     #[test]
 604     fn test_read_config() {
 605         assert_eq!(
 606             read_config(&b"!col_threshold 10"[..])
 607                 .unwrap()
 608                 .column_threshold,
 609             10
 610         );
 611         assert_eq!(
 612             read_config(&b"!col foo"[..]).unwrap().static_columns,
 613             vec![Some("foo".to_owned())]
 614         );
 615         assert_eq!(
 616             read_config(&b"!label foo:bar"[..])
 617                 .unwrap()
 618                 .substitute_labels["foo"],
 619             "bar"
 620         );
 621
 622         let bad_command = read_config(&b"!no such command"[..]);
 623         assert!(bad_command.is_err());
 624         assert!(format!("{bad_command:?}").contains("line 1: Unknown command"));
 625
 626         let bad_num = read_config(&b"!col_threshold foo"[..]);
 627         assert!(bad_num.is_err());
 628         assert!(format!("{bad_num:?}").contains("line 1: col_threshold must be numeric"));
 629
 630         let bad_sub = read_config(&b"!label foo"[..]);
 631         assert!(bad_sub.is_err());
 632         assert!(format!("{bad_sub:?}").contains("line 1: Annotation missing ':'"));
 633     }
 634
 635     #[test]
 636     fn test_column_counts() {
 637         assert_eq!(
 638             column_counts(&read_rows(&b"foo\n bar\n baz\n"[..]).unwrap()),
 639             vec![(1, String::from("bar")), (1, String::from("baz"))]
 640         );
 641         assert_eq!(
 642             column_counts(&read_rows(&b"foo\n bar\n baz\nquux\n baz"[..]).unwrap()),
 643             vec![(2, String::from("baz")), (1, String::from("bar"))]
 644         );
 645         assert_eq!(
 646             column_counts(&read_rows(&b"foo\n bar\n bar\n baz\n bar\nquux\n baz"[..]).unwrap()),
 647             vec![(2, String::from("baz")), (1, String::from("bar"))]
 648         );
 649         assert_eq!(
 650             column_counts(
 651                 &read_rows(&b"foo\n bar: 1\n bar: 2\n baz\n bar\nquux\n baz"[..]).unwrap()
 652             ),
 653             vec![(2, String::from("baz")), (1, String::from("bar"))]
 654         );
 655     }
 656
 657     #[test]
 658     fn test_column_header_labels() {
 659         let mut cfg = Config::default();
 660
 661         assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([Some(&"foo".to_owned())]));
 662
 663         cfg.static_columns.push(Some("bar".to_owned()));
 664         assert!(column_header_labels(&cfg, &["foo".to_owned()])
 665             .eq([Some(&"bar".to_owned()), Some(&"foo".to_owned())]));
 666
 667         cfg.static_columns.push(None);
 668         assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([
 669             Some(&"bar".to_owned()),
 670             None,
 671             Some(&"foo".to_owned())
 672         ]));
 673
 674         cfg.substitute_labels
 675             .insert("foo".to_owned(), "foo (bits)".to_owned());
 676         assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([
 677             Some(&"bar".to_owned()),
 678             None,
 679             Some(&"foo (bits)".to_owned())
 680         ]));
 681
 682         cfg.hidden_columns.insert("foo".to_owned());
 683         assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([Some(&"bar".to_owned()), None]));
 684
 685         cfg.hidden_columns.insert("bar".to_owned());
 686         assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([None]));
 687     }
 688
 689     #[test]
 690     fn test_render_cell() {
 691         assert_eq!(
 692             render_cell(
 693                 &Config::default(),
 694                 "foo",
 695                 &mut Row {
 696                     label: "nope".to_owned(),
 697                     entries: HashMap::new(),
 698                 }
 699             ),
 700             HTML::from(
 701                 r#"<td onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td>"#
 702             )
 703         );
 704         assert_eq!(
 705             render_cell(
 706                 &Config::default(),
 707                 "foo",
 708                 &mut Row {
 709                     label: "nope".to_owned(),
 710                     entries: HashMap::from([("bar".to_owned(), vec![None])]),
 711                 }
 712             ),
 713             HTML::from(
 714                 r#"<td onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td>"#
 715             )
 716         );
 717         assert_eq!(
 718             render_cell(
 719                 &Config::default(),
 720                 "foo",
 721                 &mut Row {
 722                     label: "nope".to_owned(),
 723                     entries: HashMap::from([("foo".to_owned(), vec![None])]),
 724                 }
 725             ),
 726             HTML::from(
 727                 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">𝍷</td>"#
 728             )
 729         );
 730         assert_eq!(
 731             render_cell(
 732                 &Config::default(),
 733                 "foo",
 734                 &mut Row {
 735                     label: "nope".to_owned(),
 736                     entries: HashMap::from([("foo".to_owned(), vec![None, None])]),
 737                 }
 738             ),
 739             HTML::from(
 740                 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">𝍷𝍷</td>"#
 741             )
 742         );
 743         assert_eq!(
 744             render_cell(
 745                 &Config::default(),
 746                 "foo",
 747                 &mut Row {
 748                     label: "nope".to_owned(),
 749                     entries: HashMap::from([(
 750                         "foo".to_owned(),
 751                         vec![Some("5".to_owned()), Some("10".to_owned())]
 752                     )]),
 753                 }
 754             ),
 755             HTML::from(
 756                 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">5 10</td>"#
 757             )
 758         );
 759         assert_eq!(
 760             render_cell(
 761                 &Config::default(),
 762                 "foo",
 763                 &mut Row {
 764                     label: "nope".to_owned(),
 765                     entries: HashMap::from([("foo".to_owned(), vec![Some("5".to_owned()), None])]),
 766                 }
 767             ),
 768             HTML::from(
 769                 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">5 𝍷</td>"#
 770             )
 771         );
 772         assert_eq!(
 773             render_cell(
 774                 &Config::default(),
 775                 "foo",
 776                 &mut Row {
 777                     label: "nope".to_owned(),
 778                     entries: HashMap::from([("foo".to_owned(), vec![Some("×".to_owned())])]),
 779                 }
 780             ),
 781             HTML::from(
 782                 r#"<td onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">×</td>"#
 783             )
 784         );
 785         assert_eq!(
 786             render_cell(
 787                 &Config::default(),
 788                 "heart",
 789                 &mut Row {
 790                     label: "nope".to_owned(),
 791                     entries: HashMap::from([("heart".to_owned(), vec![Some("<3".to_owned())])]),
 792                 }
 793             ),
 794             HTML::from(
 795                 r#"<td class="yes" onmouseover="h2('nope','heart')" onmouseout="ch2('nope','heart')">&lt;3</td>"#
 796             )
 797         );
 798         assert_eq!(
 799             render_cell(
 800                 &Config::default(),
 801                 "foo",
 802                 &mut Row {
 803                     label: "bob's".to_owned(),
 804                     entries: HashMap::from([("foo".to_owned(), vec![None])]),
 805                 }
 806             ),
 807             HTML::from(
 808                 r#"<td class="yes" onmouseover="h2('bob&#39;s','foo')" onmouseout="ch2('bob&#39;s','foo')">𝍷</td>"#
 809             )
 810         );
 811         let mut r = Row {
 812             label: "nope".to_owned(),
 813             entries: HashMap::from([
 814                 ("foo".to_owned(), vec![None]),
 815                 ("baz".to_owned(), vec![None]),
 816             ]),
 817         };
 818         assert_eq!(r.entries.len(), 2);
 819         render_cell(&Config::default(), "foo", &mut r);
 820         assert_eq!(r.entries.len(), 1);
 821         render_cell(&Config::default(), "bar", &mut r);
 822         assert_eq!(r.entries.len(), 1);
 823         render_cell(&Config::default(), "baz", &mut r);
 824         assert_eq!(r.entries.len(), 0);
 825     }
 826
 827     #[test]
 828     fn test_render_leftovers() {
 829         assert_eq!(
 830             render_all_leftovers(
 831                 &Config::default(),
 832                 &Row {
 833                     label: "nope".to_owned(),
 834                     entries: HashMap::from([("foo".to_owned(), vec![None])]),
 835                 }
 836             ),
 837             HTML::from("foo")
 838         );
 839         assert_eq!(
 840             render_all_leftovers(
 841                 &Config::default(),
 842                 &Row {
 843                     label: "nope".to_owned(),
 844                     entries: HashMap::from([
 845                         ("foo".to_owned(), vec![None]),
 846                         ("bar".to_owned(), vec![None])
 847                     ]),
 848                 }
 849             ),
 850             HTML::from("bar, foo")
 851         );
 852         assert_eq!(
 853             render_all_leftovers(
 854                 &Config::default(),
 855                 &Row {
 856                     label: "nope".to_owned(),
 857                     entries: HashMap::from([
 858                         ("foo".to_owned(), vec![None]),
 859                         ("bar".to_owned(), vec![None, None])
 860                     ]),
 861                 }
 862             ),
 863             HTML::from("bar: 𝍷𝍷, foo")
 864         );
 865         assert_eq!(
 866             render_all_leftovers(
 867                 &Config {
 868                     column_threshold: 2,
 869                     static_columns: vec![],
 870                     hidden_columns: HashSet::from(["private".to_owned()]),
 871                     substitute_labels: HashMap::new(),
 872                 },
 873                 &Row {
 874                     label: "nope".to_owned(),
 875                     entries: HashMap::from([("private".to_owned(), vec![None]),]),
 876                 }
 877             ),
 878             HTML::from("")
 879         );
 880     }
 881
 882     #[test]
 883     fn test_render_row() {
 884         assert_eq!(
 885             render_row(
 886                 &Config::default(),
 887                 &["foo".to_owned()],
 888                 &mut Rowlike::Row(Row {
 889                     label: "nope".to_owned(),
 890                     entries: HashMap::from([("bar".to_owned(), vec![None])]),
 891                 })
 892             ),
 893             HTML::from(
 894                 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>
 895 "#
 896             )
 897         );
 898         assert_eq!(
 899             render_row(
 900                 &Config {
 901                     column_threshold: 0,
 902                     static_columns: vec![Some("foo".to_owned()), Some("bar".to_owned())],
 903                     hidden_columns: HashSet::new(),
 904                     substitute_labels: HashMap::new(),
 905                 },
 906                 &["baz".to_owned()],
 907                 &mut Rowlike::Row(Row {
 908                     label: "nope".to_owned(),
 909                     entries: HashMap::from([
 910                         ("bar".to_owned(), vec![Some("r".to_owned())]),
 911                         ("baz".to_owned(), vec![Some("z".to_owned())]),
 912                         ("foo".to_owned(), vec![Some("f".to_owned())]),
 913                     ]),
 914                 })
 915             ),
 916             HTML::from(
 917                 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>
 918 "#
 919             )
 920         );
 921         assert_eq!(
 922             render_row(
 923                 &Config {
 924                     column_threshold: 0,
 925                     static_columns: vec![Some("foo".to_owned()), None, Some("bar".to_owned())],
 926                     hidden_columns: HashSet::new(),
 927                     substitute_labels: HashMap::new(),
 928                 },
 929                 &[],
 930                 &mut Rowlike::Row(Row {
 931                     label: "nope".to_owned(),
 932                     entries: HashMap::from([
 933                         ("bar".to_owned(), vec![Some("r".to_owned())]),
 934                         ("foo".to_owned(), vec![Some("f".to_owned())]),
 935                     ]),
 936                 })
 937             ),
 938             HTML::from(
 939                 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>
 940 "#
 941             )
 942         );
 943         assert_eq!(
 944             render_row(
 945                 &Config {
 946                     column_threshold: 0,
 947                     static_columns: vec![],
 948                     hidden_columns: HashSet::from(["foo".to_owned()]),
 949                     substitute_labels: HashMap::new(),
 950                 },
 951                 &[],
 952                 &mut Rowlike::Row(Row {
 953                     label: "nope".to_owned(),
 954                     entries: HashMap::from([("foo".to_owned(), vec![Some("f".to_owned())]),]),
 955                 })
 956             ),
 957             HTML::from(
 958                 r#"<tr><th id="nope">nope</th><td class="leftover" onmouseover="highlight('nope')" onmouseout="clear_highlight('nope')"></td></tr>
 959 "#
 960             )
 961         );
 962         assert_eq!(
 963             render_row(
 964                 &Config {
 965                     column_threshold: 0,
 966                     static_columns: vec![Some("foo".to_owned())],
 967                     hidden_columns: HashSet::from(["foo".to_owned()]),
 968                     substitute_labels: HashMap::new(),
 969                 },
 970                 &[],
 971                 &mut Rowlike::Row(Row {
 972                     label: "nope".to_owned(),
 973                     entries: HashMap::from([("foo".to_owned(), vec![Some("f".to_owned())]),]),
 974                 })
 975             ),
 976             HTML::from(
 977                 r#"<tr><th id="nope">nope</th><td class="leftover" onmouseover="highlight('nope')" onmouseout="clear_highlight('nope')"></td></tr>
 978 "#
 979             )
 980         );
 981     }
 982 }