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