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 = "<!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_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_cell(col: &str, row: &mut Row) -> HTML {
 198     let row_label = HTML::escape(row.label.as_ref());
 199     let col_label = HTML::escape(col);
 200     let instances: Option<&Vec<Option<String>>> = row.entries.get(col);
 201     let class = HTML::from(if instances.is_none() { "" } else { "yes" });
 202     let all_empty = instances
 203         .iter()
 204         .flat_map(|is| is.iter())
 205         .all(Option::is_none);
 206     let contents = if instances.is_none() || (all_empty && instances.unwrap().len() == 1) {
 207         HTML::from("")
 208     } else if all_empty {
 209         HTML(format!("{}", instances.unwrap().len()))
 210     } else {
 211         HTML(
 212             instances
 213                 .unwrap()
 214                 .iter()
 215                 .map(render_instance)
 216                 .map(|html| html.0) // Waiting for slice_concat_trait to stabilize
 217                 .collect::<Vec<_>>()
 218                 .join(" "),
 219         )
 220     };
 221     row.entries.remove(col);
 222     HTML(format!("<td class=\"{class}\" onmouseover=\"h2('{row_label}','{col_label}')\" onmouseout=\"ch2('{row_label}','{col_label}')\">{contents}</td>"))
 223 }
 224
 225 fn render_row(columns: &[String], row: &mut Row) -> HTML {
 226     let row_label = HTML::escape(row.label.as_ref());
 227     HTML(format!(
 228         "<tr><th id=\"{row_label}\">{row_label}</th>{}</tr>\n",
 229         &columns
 230             .iter()
 231             .map(|col| render_cell(col, row))
 232             .collect::<HTML>()
 233     ))
 234 }
 235
 236 fn render_column_headers(columns: &[String]) -> HTML {
 237     HTML(
 238         String::from("<tr class=\"key\"><th></th>")
 239             + &columns.iter().fold(String::new(), |mut acc, col| {
 240                 let col_header = HTML::escape(col.as_ref());
 241                 write!(
 242                     &mut acc,
 243                     "<th id=\"{col_header}\"><div><div>{col_header}</div></div></th>"
 244                 )
 245                 .unwrap();
 246                 acc
 247             })
 248             + "</tr>\n",
 249     )
 250 }
 251
 252 /// # Errors
 253 ///
 254 /// Will return `Err` if
 255 ///   * there's an i/o error while reading `input`
 256 ///   * the log has invalid syntax:
 257 ///     * an indented line with no preceding non-indented line
 258 pub fn tablify(config: &Config, input: impl std::io::Read) -> Result<HTML, std::io::Error> {
 259     let rows = read_rows(input).collect::<Result<Vec<_>, _>>()?;
 260     let columns = column_order(&rows);
 261     Ok(HTML(format!(
 262         "{HEADER}{}{}{FOOTER}",
 263         render_column_headers(&columns),
 264         rows.into_iter()
 265             .map(|mut r| render_row(&columns, &mut r))
 266             .collect::<HTML>()
 267     )))
 268 }
 269
 270 #[cfg(test)]
 271 mod tests {
 272     use super::*;
 273
 274     #[test]
 275     fn test_parse_line() {
 276         assert_eq!(InputLine::from(""), InputLine::Blank);
 277         assert_eq!(InputLine::from(" "), InputLine::Blank);
 278         assert_eq!(InputLine::from("foo"), InputLine::RowHeader("foo"));
 279         assert_eq!(InputLine::from("foo "), InputLine::RowHeader("foo"));
 280         assert_eq!(InputLine::from(" foo"), InputLine::Entry("foo", None));
 281         assert_eq!(
 282             InputLine::from(" foo:bar"),
 283             InputLine::Entry("foo", Some("bar"))
 284         );
 285         assert_eq!(
 286             InputLine::from(" foo: bar"),
 287             InputLine::Entry("foo", Some("bar"))
 288         );
 289         assert_eq!(
 290             InputLine::from(" foo: bar "),
 291             InputLine::Entry("foo", Some("bar"))
 292         );
 293         assert_eq!(
 294             InputLine::from(" foo:  bar "),
 295             InputLine::Entry("foo", Some("bar"))
 296         );
 297         assert_eq!(
 298             InputLine::from(" foo :  bar "),
 299             InputLine::Entry("foo", Some("bar"))
 300         );
 301     }
 302
 303     #[test]
 304     fn test_read_rows() {
 305         assert_eq!(
 306             read_rows(&b"foo"[..]).flatten().collect::<Vec<_>>(),
 307             vec![Row {
 308                 label: "foo".to_owned(),
 309                 entries: HashMap::new(),
 310             }]
 311         );
 312         assert_eq!(
 313             read_rows(&b"bar"[..]).flatten().collect::<Vec<_>>(),
 314             vec![Row {
 315                 label: "bar".to_owned(),
 316                 entries: HashMap::new(),
 317             }]
 318         );
 319         assert_eq!(
 320             read_rows(&b"foo\nbar\n"[..]).flatten().collect::<Vec<_>>(),
 321             vec![
 322                 Row {
 323                     label: "foo".to_owned(),
 324                     entries: HashMap::new(),
 325                 },
 326                 Row {
 327                     label: "bar".to_owned(),
 328                     entries: HashMap::new(),
 329                 }
 330             ]
 331         );
 332         assert_eq!(
 333             read_rows(&b"foo\n bar\n"[..]).flatten().collect::<Vec<_>>(),
 334             vec![Row {
 335                 label: "foo".to_owned(),
 336                 entries: HashMap::from([("bar".to_owned(), vec![None])]),
 337             }]
 338         );
 339         assert_eq!(
 340             read_rows(&b"foo\n bar\n baz\n"[..])
 341                 .flatten()
 342                 .collect::<Vec<_>>(),
 343             vec![Row {
 344                 label: "foo".to_owned(),
 345                 entries: HashMap::from([
 346                     ("bar".to_owned(), vec![None]),
 347                     ("baz".to_owned(), vec![None])
 348                 ]),
 349             }]
 350         );
 351         assert_eq!(
 352             read_rows(&b"foo\n\nbar\n"[..])
 353                 .flatten()
 354                 .collect::<Vec<_>>(),
 355             vec![
 356                 Row {
 357                     label: "foo".to_owned(),
 358                     entries: HashMap::new(),
 359                 },
 360                 Row {
 361                     label: "bar".to_owned(),
 362                     entries: HashMap::new(),
 363                 }
 364             ]
 365         );
 366         assert_eq!(
 367             read_rows(&b"foo\n \nbar\n"[..])
 368                 .flatten()
 369                 .collect::<Vec<_>>(),
 370             vec![
 371                 Row {
 372                     label: "foo".to_owned(),
 373                     entries: HashMap::new(),
 374                 },
 375                 Row {
 376                     label: "bar".to_owned(),
 377                     entries: HashMap::new(),
 378                 }
 379             ]
 380         );
 381         assert_eq!(
 382             read_rows(&b"foo  \n bar  \n"[..])
 383                 .flatten()
 384                 .collect::<Vec<_>>(),
 385             vec![Row {
 386                 label: "foo".to_owned(),
 387                 entries: HashMap::from([("bar".to_owned(), vec![None])]),
 388             }]
 389         );
 390
 391         let bad = read_rows(&b" foo"[..]).next().unwrap();
 392         assert!(bad.is_err());
 393         assert!(format!("{bad:?}").contains("1: Entry with no header"));
 394
 395         let bad2 = read_rows(&b"foo\n\n bar"[..]).nth(1).unwrap();
 396         assert!(bad2.is_err());
 397         assert!(format!("{bad2:?}").contains("3: Entry with no header"));
 398     }
 399
 400     #[test]
 401     fn test_column_counts() {
 402         assert_eq!(
 403             column_counts(
 404                 &read_rows(&b"foo\n bar\n baz\n"[..])
 405                     .collect::<Result<Vec<_>, _>>()
 406                     .unwrap()
 407             ),
 408             vec![(1, String::from("bar")), (1, String::from("baz"))]
 409         );
 410         assert_eq!(
 411             column_counts(
 412                 &read_rows(&b"foo\n bar\n baz\nquux\n baz"[..])
 413                     .collect::<Result<Vec<_>, _>>()
 414                     .unwrap()
 415             ),
 416             vec![(2, String::from("baz")), (1, String::from("bar"))]
 417         );
 418         assert_eq!(
 419             column_counts(
 420                 &read_rows(&b"foo\n bar\n bar\n baz\n bar\nquux\n baz"[..])
 421                     .collect::<Result<Vec<_>, _>>()
 422                     .unwrap()
 423             ),
 424             vec![(2, String::from("baz")), (1, String::from("bar"))]
 425         );
 426         assert_eq!(
 427             column_counts(
 428                 &read_rows(&b"foo\n bar: 1\n bar: 2\n baz\n bar\nquux\n baz"[..])
 429                     .collect::<Result<Vec<_>, _>>()
 430                     .unwrap()
 431             ),
 432             vec![(2, String::from("baz")), (1, String::from("bar"))]
 433         );
 434     }
 435
 436     #[test]
 437     fn test_render_cell() {
 438         assert_eq!(
 439             render_cell(
 440                 "foo",
 441                 &mut Row {
 442                     label: "nope".to_owned(),
 443                     entries: HashMap::new(),
 444                 }
 445             ),
 446             HTML::from("<td class=\"\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\"></td>")
 447         );
 448         assert_eq!(
 449             render_cell(
 450                 "foo",
 451                 &mut Row {
 452                     label: "nope".to_owned(),
 453                     entries: HashMap::from([("bar".to_owned(), vec![None])]),
 454                 }
 455             ),
 456             HTML::from("<td class=\"\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\"></td>")
 457         );
 458         assert_eq!(
 459             render_cell(
 460                 "foo",
 461                 &mut Row {
 462                     label: "nope".to_owned(),
 463                     entries: HashMap::from([("foo".to_owned(), vec![None])]),
 464                 }
 465             ),
 466             HTML::from("<td class=\"yes\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\"></td>")
 467         );
 468         assert_eq!(
 469             render_cell(
 470                 "foo",
 471                 &mut Row {
 472                     label: "nope".to_owned(),
 473                     entries: HashMap::from([("foo".to_owned(), vec![None, None])]),
 474                 }
 475             ),
 476             HTML::from("<td class=\"yes\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\">2</td>")
 477         );
 478         assert_eq!(
 479             render_cell(
 480                 "foo",
 481                 &mut Row {
 482                     label: "nope".to_owned(),
 483                     entries: HashMap::from([("foo".to_owned(), vec![Some("5".to_owned()), Some("10".to_owned())])]),
 484                 }
 485             ),
 486             HTML::from("<td class=\"yes\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\">5 10</td>")
 487         );
 488         assert_eq!(
 489             render_cell(
 490                 "foo",
 491                 &mut Row {
 492                     label: "nope".to_owned(),
 493                     entries: HashMap::from([("foo".to_owned(), vec![Some("5".to_owned()), None])]),
 494                 }
 495             ),
 496             HTML::from("<td class=\"yes\" onmouseover=\"h2('nope','foo')\" onmouseout=\"ch2('nope','foo')\">5 ✓</td>")
 497         );
 498         assert_eq!(
 499             render_cell(
 500                 "heart",
 501                 &mut Row {
 502                     label: "nope".to_owned(),
 503                     entries: HashMap::from([("heart".to_owned(), vec![Some("<3".to_owned())])]),
 504                 }
 505             ),
 506             HTML::from("<td class=\"yes\" onmouseover=\"h2('nope','heart')\" onmouseout=\"ch2('nope','heart')\">&lt;3</td>")
 507         );
 508         assert_eq!(
 509             render_cell(
 510                 "foo",
 511                 &mut Row {
 512                     label: "bob's".to_owned(),
 513                     entries: HashMap::from([("foo".to_owned(), vec![None])]),
 514                 }
 515             ),
 516             HTML::from("<td class=\"yes\" onmouseover=\"h2('bob&#39;s','foo')\" onmouseout=\"ch2('bob&#39;s','foo')\"></td>")
 517         );
 518         let mut r = Row {
 519             label: "nope".to_owned(),
 520             entries: HashMap::from([
 521                 ("foo".to_owned(), vec![None]),
 522                 ("baz".to_owned(), vec![None]),
 523             ]),
 524         };
 525         assert_eq!(r.entries.len(), 2);
 526         render_cell("foo", &mut r);
 527         assert_eq!(r.entries.len(), 1);
 528         render_cell("bar", &mut r);
 529         assert_eq!(r.entries.len(), 1);
 530         render_cell("baz", &mut r);
 531         assert_eq!(r.entries.len(), 0);
 532     }
 533 }