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 => {}
 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::Row(Row {
 423                     label: "bar".to_owned(),
 424                     entries: HashMap::new(),
 425                 })
 426             ]
 427         );
 428         assert_eq!(
 429             read_rows(&b"foo\n \nbar\n"[..])
 430                 .flatten()
 431                 .collect::<Vec<_>>(),
 432             vec![
 433                 Rowlike::Row(Row {
 434                     label: "foo".to_owned(),
 435                     entries: HashMap::new(),
 436                 }),
 437                 Rowlike::Row(Row {
 438                     label: "bar".to_owned(),
 439                     entries: HashMap::new(),
 440                 })
 441             ]
 442         );
 443         assert_eq!(
 444             read_rows(&b"foo  \n bar  \n"[..])
 445                 .flatten()
 446                 .collect::<Vec<_>>(),
 447             vec![Rowlike::Row(Row {
 448                 label: "foo".to_owned(),
 449                 entries: HashMap::from([("bar".to_owned(), vec![None])]),
 450             })]
 451         );
 452
 453         let bad = read_rows(&b" foo"[..]).next().unwrap();
 454         assert!(bad.is_err());
 455         assert!(format!("{bad:?}").contains("1: Entry with no header"));
 456
 457         let bad2 = read_rows(&b"foo\n\n bar"[..]).nth(1).unwrap();
 458         assert!(bad2.is_err());
 459         assert!(format!("{bad2:?}").contains("3: Entry with no header"));
 460     }
 461
 462     #[test]
 463     fn test_column_counts() {
 464         assert_eq!(
 465             column_counts(
 466                 &read_rows(&b"foo\n bar\n baz\n"[..])
 467                     .collect::<Result<Vec<_>, _>>()
 468                     .unwrap()
 469             ),
 470             vec![(1, String::from("bar")), (1, String::from("baz"))]
 471         );
 472         assert_eq!(
 473             column_counts(
 474                 &read_rows(&b"foo\n bar\n baz\nquux\n baz"[..])
 475                     .collect::<Result<Vec<_>, _>>()
 476                     .unwrap()
 477             ),
 478             vec![(2, String::from("baz")), (1, String::from("bar"))]
 479         );
 480         assert_eq!(
 481             column_counts(
 482                 &read_rows(&b"foo\n bar\n bar\n baz\n bar\nquux\n baz"[..])
 483                     .collect::<Result<Vec<_>, _>>()
 484                     .unwrap()
 485             ),
 486             vec![(2, String::from("baz")), (1, String::from("bar"))]
 487         );
 488         assert_eq!(
 489             column_counts(
 490                 &read_rows(&b"foo\n bar: 1\n bar: 2\n baz\n bar\nquux\n baz"[..])
 491                     .collect::<Result<Vec<_>, _>>()
 492                     .unwrap()
 493             ),
 494             vec![(2, String::from("baz")), (1, String::from("bar"))]
 495         );
 496     }
 497
 498     #[test]
 499     fn test_render_cell() {
 500         assert_eq!(
 501             render_cell(
 502                 "foo",
 503                 &mut Row {
 504                     label: "nope".to_owned(),
 505                     entries: HashMap::new(),
 506                 }
 507             ),
 508             HTML::from(
 509                 r#"<td class="" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td>"#
 510             )
 511         );
 512         assert_eq!(
 513             render_cell(
 514                 "foo",
 515                 &mut Row {
 516                     label: "nope".to_owned(),
 517                     entries: HashMap::from([("bar".to_owned(), vec![None])]),
 518                 }
 519             ),
 520             HTML::from(
 521                 r#"<td class="" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td>"#
 522             )
 523         );
 524         assert_eq!(
 525             render_cell(
 526                 "foo",
 527                 &mut Row {
 528                     label: "nope".to_owned(),
 529                     entries: HashMap::from([("foo".to_owned(), vec![None])]),
 530                 }
 531             ),
 532             HTML::from(
 533                 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')"></td>"#
 534             )
 535         );
 536         assert_eq!(
 537             render_cell(
 538                 "foo",
 539                 &mut Row {
 540                     label: "nope".to_owned(),
 541                     entries: HashMap::from([("foo".to_owned(), vec![None, None])]),
 542                 }
 543             ),
 544             HTML::from(
 545                 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">2</td>"#
 546             )
 547         );
 548         assert_eq!(
 549             render_cell(
 550                 "foo",
 551                 &mut Row {
 552                     label: "nope".to_owned(),
 553                     entries: HashMap::from([(
 554                         "foo".to_owned(),
 555                         vec![Some("5".to_owned()), Some("10".to_owned())]
 556                     )]),
 557                 }
 558             ),
 559             HTML::from(
 560                 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">5 10</td>"#
 561             )
 562         );
 563         assert_eq!(
 564             render_cell(
 565                 "foo",
 566                 &mut Row {
 567                     label: "nope".to_owned(),
 568                     entries: HashMap::from([("foo".to_owned(), vec![Some("5".to_owned()), None])]),
 569                 }
 570             ),
 571             HTML::from(
 572                 r#"<td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">5 ✓</td>"#
 573             )
 574         );
 575         assert_eq!(
 576             render_cell(
 577                 "heart",
 578                 &mut Row {
 579                     label: "nope".to_owned(),
 580                     entries: HashMap::from([("heart".to_owned(), vec![Some("<3".to_owned())])]),
 581                 }
 582             ),
 583             HTML::from(
 584                 r#"<td class="yes" onmouseover="h2('nope','heart')" onmouseout="ch2('nope','heart')">&lt;3</td>"#
 585             )
 586         );
 587         assert_eq!(
 588             render_cell(
 589                 "foo",
 590                 &mut Row {
 591                     label: "bob's".to_owned(),
 592                     entries: HashMap::from([("foo".to_owned(), vec![None])]),
 593                 }
 594             ),
 595             HTML::from(
 596                 r#"<td class="yes" onmouseover="h2('bob&#39;s','foo')" onmouseout="ch2('bob&#39;s','foo')"></td>"#
 597             )
 598         );
 599         let mut r = Row {
 600             label: "nope".to_owned(),
 601             entries: HashMap::from([
 602                 ("foo".to_owned(), vec![None]),
 603                 ("baz".to_owned(), vec![None]),
 604             ]),
 605         };
 606         assert_eq!(r.entries.len(), 2);
 607         render_cell("foo", &mut r);
 608         assert_eq!(r.entries.len(), 1);
 609         render_cell("bar", &mut r);
 610         assert_eq!(r.entries.len(), 1);
 611         render_cell("baz", &mut r);
 612         assert_eq!(r.entries.len(), 0);
 613     }
 614
 615     #[test]
 616     fn test_render_leftovers() {
 617         assert_eq!(
 618             render_all_leftovers(&Row {
 619                 label: "nope".to_owned(),
 620                 entries: HashMap::from([("foo".to_owned(), vec![None])]),
 621             }),
 622             HTML::from("foo")
 623         );
 624         assert_eq!(
 625             render_all_leftovers(&Row {
 626                 label: "nope".to_owned(),
 627                 entries: HashMap::from([
 628                     ("foo".to_owned(), vec![None]),
 629                     ("bar".to_owned(), vec![None])
 630                 ]),
 631             }),
 632             HTML::from("bar, foo")
 633         );
 634         assert_eq!(
 635             render_all_leftovers(&Row {
 636                 label: "nope".to_owned(),
 637                 entries: HashMap::from([
 638                     ("foo".to_owned(), vec![None]),
 639                     ("bar".to_owned(), vec![None, None])
 640                 ]),
 641             }),
 642             HTML::from("bar: 2, foo")
 643         );
 644     }
 645
 646     #[test]
 647     fn test_render_row() {
 648         assert_eq!(
 649             render_row(
 650                 &["foo".to_owned()],
 651                 &mut Rowlike::Row(Row {
 652                     label: "nope".to_owned(),
 653                     entries: HashMap::from([("bar".to_owned(), vec![None])]),
 654                 })
 655             ),
 656             HTML::from(
 657                 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>
 658 "#
 659             )
 660         );
 661     }
 662 }