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, 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)]
  19 struct 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 }
  26 impl 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 }
  72 impl 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
  84 const 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 "#;
 117 const FOOTER: &str = "    </tbody>
 118   </table>
 119 </body>
 120 </html>";
 121
 122 #[derive(PartialEq, Eq, Debug)]
 123 pub struct HTML(String);
 124 impl 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 }
 140 impl From<&str> for HTML {
 141     fn from(value: &str) -> HTML {
 142         HTML(String::from(value))
 143     }
 144 }
 145 impl 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 }
 153 impl 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)]
 160 enum InputLine<'a> {
 161     Blank,
 162     RowHeader(&'a str),
 163     Entry(&'a str, Option<&'a str>),
 164     Command(&'a str),
 165 }
 166 impl<'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)]
 185 struct Row {
 186     label: String,
 187     entries: HashMap<String, Vec<Option<String>>>,
 188 }
 189
 190 #[derive(Debug, PartialEq, Eq)]
 191 enum Rowlike {
 192     Row(Row),
 193     Spacer,
 194 }
 195
 196 struct 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 }
 201 impl<'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 }
 210 impl<'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
 259 fn 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
 267 fn 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 }
 287 fn 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
 305 fn 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
 331 fn 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
 358 fn 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
 368 fn 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
 391 fn 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
 418 fn 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
 435 fn 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
 462 pub 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)]
 475 mod 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 }