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

   1 use std::borrow::ToOwned;
   2 use std::collections::HashMap;
   3 use std::fmt::Write;
   4 use std::io::BufRead;
   5 use std::iter::Iterator;
   6
   7 pub struct Config {}
   8
   9 const HEADER: &str = r#"<!DOCTYPE html>
  10 <html>
  11 <head>
  12   <meta charset="utf-8">
  13   <meta name="viewport" content="width=device-width, initial-scale=1">
  14   <style>
  15     td { text-align: center; }
  16     /* h/t https://wabain.github.io/2019/10/13/css-rotated-table-header.html */
  17     th, td { white-space: nowrap; }
  18     th { text-align: left; font-weight: normal; }
  19     table { border-collapse: collapse }
  20     tr.key > th { height: 10em; vertical-align: bottom; line-height: 1 }
  21     tr.key > th > div { width: 1em; }
  22     tr.key > th > div > div { width: 5em; transform-origin: bottom left; transform: translateX(1em) rotate(-65deg) }
  23     td { border: thin solid gray; }
  24     td.yes { border: thin solid gray; background-color: #ddd; }
  25     /* h/t https://stackoverflow.com/questions/5687035/css-bolding-some-text-without-changing-its-containers-size/46452396#46452396 */
  26     .highlight { text-shadow: -0.06ex 0 black, 0.06ex 0 black; }
  27   </style>
  28   <script>
  29     function highlight(id)       { const e = document.getElementById(id); if (e) { e.classList.add(   "highlight"); } }
  30     function clear_highlight(id) { const e = document.getElementById(id); if (e) { e.classList.remove("highlight"); } }
  31     function h2(a, b)  {       highlight(a);       highlight(b); }
  32     function ch2(a, b) { clear_highlight(a); clear_highlight(b); }
  33   </script>
  34 </head>
  35 <body>
  36   <table>
  37     <tbody>
  38 "#;
  39 const FOOTER: &str = "    </tbody>
  40   </table>
  41 </body>
  42 </html>";
  43
  44 #[derive(PartialEq, Eq, Debug)]
  45 pub struct HTML(String);
  46 impl HTML {
  47     fn escape(value: &str) -> HTML {
  48         let mut escaped: String = String::new();
  49         for c in value.chars() {
  50             match c {
  51                 '>' => escaped.push_str("&gt;"),
  52                 '<' => escaped.push_str("&lt;"),
  53                 '\'' => escaped.push_str("&#39;"),
  54                 '"' => escaped.push_str("&quot;"),
  55                 '&' => escaped.push_str("&amp;"),
  56                 ok_c => escaped.push(ok_c),
  57             }
  58         }
  59         HTML(escaped)
  60     }
  61 }
  62 impl From<&str> for HTML {
  63     fn from(value: &str) -> HTML {
  64         HTML(String::from(value))
  65     }
  66 }
  67 impl FromIterator<HTML> for HTML {
  68     fn from_iter<T>(iter: T) -> HTML
  69     where
  70         T: IntoIterator<Item = HTML>,
  71     {
  72         HTML(iter.into_iter().map(|html| html.0).collect::<String>())
  73     }
  74 }
  75 impl std::fmt::Display for HTML {
  76     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  77         write!(f, "{}", self.0)
  78     }
  79 }
  80
  81 #[derive(Debug, PartialEq, Eq)]
  82 enum InputLine<'a> {
  83     Blank,
  84     RowHeader(&'a str),
  85     Entry(&'a str, Option<&'a str>),
  86 }
  87 impl<'a> From<&'a str> for InputLine<'a> {
  88     fn from(value: &'a str) -> InputLine<'a> {
  89         let trimmed = value.trim_end();
  90         if trimmed.is_empty() {
  91             InputLine::Blank
  92         } else if !trimmed.starts_with(' ') {
  93             InputLine::RowHeader(value.trim())
  94         } else {
  95             match value.split_once(':') {
  96                 None => InputLine::Entry(value.trim(), None),
  97                 Some((col, instance)) => InputLine::Entry(col.trim(), Some(instance.trim())),
  98             }
  99         }
 100     }
 101 }
 102
 103 #[derive(Debug, PartialEq, Eq)]
 104 struct Row {
 105     label: String,
 106     entries: HashMap<String, Vec<Option<String>>>,
 107 }
 108
 109 struct Reader<Input: Iterator<Item = Result<String, std::io::Error>>> {
 110     input: std::iter::Enumerate<Input>,
 111     row: Option<Row>,
 112 }
 113 impl<Input: Iterator<Item = Result<String, std::io::Error>>> Reader<Input> {
 114     fn new(input: Input) -> Self {
 115         Self {
 116             input: input.enumerate(),
 117             row: None,
 118         }
 119     }
 120 }
 121 impl<Input: Iterator<Item = Result<String, std::io::Error>>> Iterator for Reader<Input> {
 122     type Item = Result<Row, std::io::Error>;
 123     fn next(&mut self) -> Option<Self::Item> {
 124         loop {
 125             match self.input.next() {
 126                 None => return Ok(std::mem::take(&mut self.row)).transpose(),
 127                 Some((_, Err(e))) => return Some(Err(e)),
 128                 Some((n, Ok(line))) => match InputLine::from(line.as_ref()) {
 129                     InputLine::Blank if self.row.is_some() => {
 130                         return Ok(std::mem::take(&mut self.row)).transpose()
 131                     }
 132                     InputLine::Blank => {}
 133                     InputLine::Entry(col, instance) => match &mut self.row {
 134                         None => {
 135                             return Some(Err(std::io::Error::other(format!(
 136                                 "{}: Entry with no header",
 137                                 n + 1
 138                             ))))
 139                         }
 140                         Some(ref mut row) => {
 141                             row.entries
 142                                 .entry(col.to_owned())
 143                                 .and_modify(|is| is.push(instance.map(ToOwned::to_owned)))
 144                                 .or_insert_with(|| vec![instance.map(ToOwned::to_owned)]);
 145                         }
 146                     },
 147                     InputLine::RowHeader(row) => {
 148                         let prev = std::mem::take(&mut self.row);
 149                         self.row = Some(Row {
 150                             label: row.to_owned(),
 151                             entries: HashMap::new(),
 152                         });
 153                         if prev.is_some() {
 154                             return Ok(prev).transpose();
 155                         }
 156                     }
 157                 },
 158             }
 159         }
 160     }
 161 }
 162
 163 fn read_rows(input: impl std::io::Read) -> impl Iterator<Item = Result<Row, std::io::Error>> {
 164     Reader::new(std::io::BufReader::new(input).lines())
 165 }
 166
 167 fn column_counts(rows: &[Row]) -> Vec<(usize, String)> {
 168     let mut counts: Vec<_> = rows
 169         .iter()
 170         .flat_map(|r| r.entries.keys())
 171         .fold(HashMap::new(), |mut cs, col| {
 172             cs.entry(col.to_owned())
 173                 .and_modify(|n| *n += 1)
 174                 .or_insert(1);
 175             cs
 176         })
 177         .into_iter()
 178         .map(|(col, n)| (n, col))
 179         .collect();
 180     counts.sort_unstable_by(|(an, acol), (bn, bcol)| bn.cmp(an).then(acol.cmp(bcol)));
 181     counts
 182 }
 183 fn column_order(rows: &[Row]) -> Vec<String> {
 184     column_counts(rows)
 185         .into_iter()
 186         .map(|(_, col)| col)
 187         .collect()
 188 }
 189
 190 fn render_one_instance(instance: &Option<String>) -> HTML {
 191     match instance {
 192         None => HTML::from("✓"),
 193         Some(instance) => HTML::escape(instance.as_ref()),
 194     }
 195 }
 196
 197 fn render_instances(instances: &[Option<String>]) -> HTML {
 198     let all_empty = instances.iter().all(Option::is_none);
 199     if all_empty && instances.len() == 1 {
 200         HTML::from("")
 201     } else if all_empty {
 202         HTML(format!("{}", instances.len()))
 203     } else {
 204         HTML(
 205             instances
 206                 .iter()
 207                 .map(render_one_instance)
 208                 .map(|html| html.0) // Waiting for slice_concat_trait to stabilize
 209                 .collect::<Vec<_>>()
 210                 .join(" "),
 211         )
 212     }
 213 }
 214
 215 fn render_cell(col: &str, row: &mut Row) -> HTML {
 216     let row_label = HTML::escape(row.label.as_ref());
 217     let col_label = HTML::escape(col);
 218     let instances: Option<&Vec<Option<String>>> = row.entries.get(col);
 219     let class = HTML::from(if instances.is_none() { "" } else { "yes" });
 220     let contents = match instances {
 221         None => HTML::from(""),
 222         Some(is) => render_instances(is),
 223     };
 224     row.entries.remove(col);
 225     HTML(format!(
 226         r#"<td class="{class}" onmouseover="h2('{row_label}','{col_label}')" onmouseout="ch2('{row_label}','{col_label}')">{contents}</td>"#
 227     ))
 228 }
 229
 230 fn render_leftover(notcol: &str, instances: &[Option<String>]) -> HTML {
 231     let label = HTML::escape(notcol);
 232     let rest = render_instances(instances);
 233     if rest == HTML::from("") {
 234         HTML(format!("{label}"))
 235     } else {
 236         HTML(format!("{label}: {rest}"))
 237     }
 238 }
 239
 240 fn render_all_leftovers(row: &Row) -> HTML {
 241     let mut order: Vec<_> = row.entries.keys().collect();
 242     order.sort_unstable();
 243     HTML(
 244         order
 245             .into_iter()
 246             .map(|notcol| render_leftover(notcol, row.entries.get(notcol).expect("Key vanished?!")))
 247             .map(|html| html.0) // Waiting for slice_concat_trait to stabilize
 248             .collect::<Vec<_>>()
 249             .join(", "),
 250     )
 251 }
 252
 253 fn render_row(columns: &[String], row: &mut Row) -> HTML {
 254     let row_label = HTML::escape(row.label.as_ref());
 255     let cells = columns
 256         .iter()
 257         .map(|col| render_cell(col, row))
 258         .collect::<HTML>();
 259     let leftovers = render_all_leftovers(row);
 260     HTML(format!(
 261         "<tr><th id=\"{row_label}\">{row_label}</th>{cells}<td onmouseover=\"highlight('{row_label}')\" onmouseout=\"clear_highlight('{row_label}')\">{leftovers}</td></tr>\n"
 262     ))
 263 }
 264
 265 fn render_column_headers(columns: &[String]) -> HTML {
 266     HTML(
 267         String::from(r#"<tr class="key"><th></th>"#)
 268             + &columns.iter().fold(String::new(), |mut acc, col| {
 269                 let col_header = HTML::escape(col.as_ref());
 270                 write!(
 271                     &mut acc,
 272                     r#"<th id="{col_header}"><div><div>{col_header}</div></div></th>"#
 273                 )
 274                 .unwrap();
 275                 acc
 276             })
 277             + "</tr>\n",
 278     )
 279 }
 280
 281 /// # Errors
 282 ///
 283 /// Will return `Err` if
 284 ///   * there's an i/o error while reading `input`
 285 ///   * the log has invalid syntax:
 286 ///     * an indented line with no preceding non-indented line
 287 pub fn tablify(config: &Config, input: impl std::io::Read) -> Result<HTML, std::io::Error> {
 288     let rows = read_rows(input).collect::<Result<Vec<_>, _>>()?;
 289     let columns = column_order(&rows);
 290     Ok(HTML(format!(
 291         "{HEADER}{}{}{FOOTER}",
 292         render_column_headers(&columns),
 293         rows.into_iter()
 294             .map(|mut r| render_row(&columns, &mut r))
 295             .collect::<HTML>()
 296     )))
 297 }
 298
 299 #[cfg(test)]
 300 mod tests {
 301     use super::*;
 302
 303     #[test]
 304     fn test_parse_line() {
 305         assert_eq!(InputLine::from(""), InputLine::Blank);
 306         assert_eq!(InputLine::from(" "), InputLine::Blank);
 307         assert_eq!(InputLine::from("foo"), InputLine::RowHeader("foo"));
 308         assert_eq!(InputLine::from("foo "), InputLine::RowHeader("foo"));
 309         assert_eq!(InputLine::from(" foo"), InputLine::Entry("foo", None));
 310         assert_eq!(
 311             InputLine::from(" foo:bar"),
 312             InputLine::Entry("foo", Some("bar"))
 313         );
 314         assert_eq!(
 315             InputLine::from(" foo: bar"),
 316             InputLine::Entry("foo", Some("bar"))
 317         );
 318         assert_eq!(
 319             InputLine::from(" foo: bar "),
 320             InputLine::Entry("foo", Some("bar"))
 321         );
 322         assert_eq!(
 323             InputLine::from(" foo:  bar "),
 324             InputLine::Entry("foo", Some("bar"))
 325         );
 326         assert_eq!(
 327             InputLine::from(" foo :  bar "),
 328             InputLine::Entry("foo", Some("bar"))
 329         );
 330     }
 331
 332     #[test]
 333     fn test_read_rows() {
 334         assert_eq!(
 335             read_rows(&b"foo"[..]).flatten().collect::<Vec<_>>(),
 336             vec![Row {
 337                 label: "foo".to_owned(),
 338                 entries: HashMap::new(),
 339             }]
 340         );
 341         assert_eq!(
 342             read_rows(&b"bar"[..]).flatten().collect::<Vec<_>>(),
 343             vec![Row {
 344                 label: "bar".to_owned(),
 345                 entries: HashMap::new(),
 346             }]
 347         );
 348         assert_eq!(
 349             read_rows(&b"foo\nbar\n"[..]).flatten().collect::<Vec<_>>(),
 350             vec![
 351                 Row {
 352                     label: "foo".to_owned(),
 353                     entries: HashMap::new(),
 354                 },
 355                 Row {
 356                     label: "bar".to_owned(),
 357                     entries: HashMap::new(),
 358                 }
 359             ]
 360         );
 361         assert_eq!(
 362             read_rows(&b"foo\n bar\n"[..]).flatten().collect::<Vec<_>>(),
 363             vec![Row {
 364                 label: "foo".to_owned(),
 365                 entries: HashMap::from([("bar".to_owned(), vec![None])]),
 366             }]
 367         );
 368         assert_eq!(
 369             read_rows(&b"foo\n bar\n baz\n"[..])
 370                 .flatten()
 371                 .collect::<Vec<_>>(),
 372             vec![Row {
 373                 label: "foo".to_owned(),
 374                 entries: HashMap::from([
 375                     ("bar".to_owned(), vec![None]),
 376                     ("baz".to_owned(), vec![None])
 377                 ]),
 378             }]
 379         );
 380         assert_eq!(
 381             read_rows(&b"foo\n\nbar\n"[..])
 382                 .flatten()
 383                 .collect::<Vec<_>>(),
 384             vec![
 385                 Row {
 386                     label: "foo".to_owned(),
 387                     entries: HashMap::new(),
 388                 },
 389                 Row {
 390                     label: "bar".to_owned(),
 391                     entries: HashMap::new(),
 392                 }
 393             ]
 394         );
 395         assert_eq!(
 396             read_rows(&b"foo\n \nbar\n"[..])
 397                 .flatten()
 398                 .collect::<Vec<_>>(),
 399             vec![
 400                 Row {
 401                     label: "foo".to_owned(),
 402                     entries: HashMap::new(),
 403                 },
 404                 Row {
 405                     label: "bar".to_owned(),
 406                     entries: HashMap::new(),
 407                 }
 408             ]
 409         );
 410         assert_eq!(
 411             read_rows(&b"foo  \n bar  \n"[..])
 412                 .flatten()
 413                 .collect::<Vec<_>>(),
 414             vec![Row {
 415                 label: "foo".to_owned(),
 416                 entries: HashMap::from([("bar".to_owned(), vec![None])]),
 417             }]
 418         );
 419
 420         let bad = read_rows(&b" foo"[..]).next().unwrap();
 421         assert!(bad.is_err());
 422         assert!(format!("{bad:?}").contains("1: Entry with no header"));
 423
 424         let bad2 = read_rows(&b"foo\n\n bar"[..]).nth(1).unwrap();
 425         assert!(bad2.is_err());
 426         assert!(format!("{bad2:?}").contains("3: Entry with no header"));
 427     }
 428
 429     #[test]
 430     fn test_column_counts() {
 431         assert_eq!(
 432             column_counts(
 433                 &read_rows(&b"foo\n bar\n baz\n"[..])
 434                     .collect::<Result<Vec<_>, _>>()
 435                     .unwrap()
 436             ),
 437             vec![(1, String::from("bar")), (1, String::from("baz"))]
 438         );
 439         assert_eq!(
 440             column_counts(
 441                 &read_rows(&b"foo\n bar\n baz\nquux\n baz"[..])
 442                     .collect::<Result<Vec<_>, _>>()
 443                     .unwrap()
 444             ),
 445             vec![(2, String::from("baz")), (1, String::from("bar"))]
 446         );
 447         assert_eq!(
 448             column_counts(
 449                 &read_rows(&b"foo\n bar\n bar\n baz\n bar\nquux\n baz"[..])
 450                     .collect::<Result<Vec<_>, _>>()
 451                     .unwrap()
 452             ),
 453             vec![(2, String::from("baz")), (1, String::from("bar"))]
 454         );
 455         assert_eq!(
 456             column_counts(
 457                 &read_rows(&b"foo\n bar: 1\n bar: 2\n baz\n bar\nquux\n baz"[..])
 458                     .collect::<Result<Vec<_>, _>>()
 459                     .unwrap()
 460             ),
 461             vec![(2, String::from("baz")), (1, String::from("bar"))]
 462         );
 463     }
 464
 465     #[test]
 466     fn test_render_cell() {
 467         assert_eq!(
 468             render_cell(
 469                 "foo",
 470                 &mut Row {
 471                     label: "nope".to_owned(),
 472                     entries: HashMap::new(),
 473                 }
 474             ),
 475             HTML::from(
 476                 r#"<td class="" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td>"#
 477             )
 478         );
 479         assert_eq!(
 480             render_cell(
 481                 "foo",
 482                 &mut Row {
 483                     label: "nope".to_owned(),
 484                     entries: HashMap::from([("bar".to_owned(), vec![None])]),
 485                 }
 486             ),
 487             HTML::from(
 488                 r#"<td class="" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td>"#
 489             )
 490         );
 491         assert_eq!(
 492             render_cell(
 493                 "foo",
 494                 &mut Row {
 495                     label: "nope".to_owned(),
 496                     entries: HashMap::from([("foo".to_owned(), vec![None])]),
 497                 }
 498             ),
 499             HTML::from(
 500                 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td>"#
 501             )
 502         );
 503         assert_eq!(
 504             render_cell(
 505                 "foo",
 506                 &mut Row {
 507                     label: "nope".to_owned(),
 508                     entries: HashMap::from([("foo".to_owned(), vec![None, None])]),
 509                 }
 510             ),
 511             HTML::from(
 512                 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">2</td>"#
 513             )
 514         );
 515         assert_eq!(
 516             render_cell(
 517                 "foo",
 518                 &mut Row {
 519                     label: "nope".to_owned(),
 520                     entries: HashMap::from([(
 521                         "foo".to_owned(),
 522                         vec![Some("5".to_owned()), Some("10".to_owned())]
 523                     )]),
 524                 }
 525             ),
 526             HTML::from(
 527                 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">5 10</td>"#
 528             )
 529         );
 530         assert_eq!(
 531             render_cell(
 532                 "foo",
 533                 &mut Row {
 534                     label: "nope".to_owned(),
 535                     entries: HashMap::from([("foo".to_owned(), vec![Some("5".to_owned()), None])]),
 536                 }
 537             ),
 538             HTML::from(
 539                 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">5 ✓</td>"#
 540             )
 541         );
 542         assert_eq!(
 543             render_cell(
 544                 "heart",
 545                 &mut Row {
 546                     label: "nope".to_owned(),
 547                     entries: HashMap::from([("heart".to_owned(), vec![Some("<3".to_owned())])]),
 548                 }
 549             ),
 550             HTML::from(
 551                 r#"<td class="yes" onmouseover="h2('nope','heart')" onmouseout="ch2('nope','heart')">&lt;3</td>"#
 552             )
 553         );
 554         assert_eq!(
 555             render_cell(
 556                 "foo",
 557                 &mut Row {
 558                     label: "bob's".to_owned(),
 559                     entries: HashMap::from([("foo".to_owned(), vec![None])]),
 560                 }
 561             ),
 562             HTML::from(
 563                 r#"<td class="yes" onmouseover="h2('bob&#39;s','foo')" onmouseout="ch2('bob&#39;s','foo')"></td>"#
 564             )
 565         );
 566         let mut r = Row {
 567             label: "nope".to_owned(),
 568             entries: HashMap::from([
 569                 ("foo".to_owned(), vec![None]),
 570                 ("baz".to_owned(), vec![None]),
 571             ]),
 572         };
 573         assert_eq!(r.entries.len(), 2);
 574         render_cell("foo", &mut r);
 575         assert_eq!(r.entries.len(), 1);
 576         render_cell("bar", &mut r);
 577         assert_eq!(r.entries.len(), 1);
 578         render_cell("baz", &mut r);
 579         assert_eq!(r.entries.len(), 0);
 580     }
 581
 582     #[test]
 583     fn test_render_leftovers() {
 584         assert_eq!(
 585             render_all_leftovers(&Row {
 586                 label: "nope".to_owned(),
 587                 entries: HashMap::from([("foo".to_owned(), vec![None])]),
 588             }),
 589             HTML::from("foo")
 590         );
 591         assert_eq!(
 592             render_all_leftovers(&Row {
 593                 label: "nope".to_owned(),
 594                 entries: HashMap::from([
 595                     ("foo".to_owned(), vec![None]),
 596                     ("bar".to_owned(), vec![None])
 597                 ]),
 598             }),
 599             HTML::from("bar, foo")
 600         );
 601         assert_eq!(
 602             render_all_leftovers(&Row {
 603                 label: "nope".to_owned(),
 604                 entries: HashMap::from([
 605                     ("foo".to_owned(), vec![None]),
 606                     ("bar".to_owned(), vec![None, None])
 607                 ]),
 608             }),
 609             HTML::from("bar: 2, foo")
 610         );
 611     }
 612
 613     #[test]
 614     fn test_render_row() {
 615         assert_eq!(
 616             render_row(
 617                 &["foo".to_owned()],
 618                 &mut Row {
 619                     label: "nope".to_owned(),
 620                     entries: HashMap::from([("bar".to_owned(), vec![None])]),
 621                 }
 622             ),
 623             HTML::from(
 624                 r#"<tr><th id="nope">nope</th><td class="" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td><td onmouseover="highlight('nope')" onmouseout="clear_highlight('nope')">bar</td></tr>
 625 "#
 626             )
 627         );
 628     }
 629 }