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