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