#[derive(PartialEq, Eq, Debug)]
struct Config {
column_threshold: usize,
- static_columns: Vec<String>,
+ static_columns: Vec<Option<String>>,
+ hidden_columns: HashSet<String>,
+ substitute_labels: HashMap<String, String>,
}
impl Config {
fn apply_command(&mut self, line_num: usize, cmd: &str) -> Result<(), std::io::Error> {
format!("line {line_num}: col_threshold must be numeric: {e}"),
)
})?;
+ } else if let Some(col) = cmd.strip_prefix("hide ") {
+ self.hidden_columns.insert(col.to_owned());
} else if let Some(col) = cmd.strip_prefix("col ") {
- self.static_columns.push(col.to_owned());
+ self.static_columns.push(Some(col.to_owned()));
+ } else if cmd == "colsep" {
+ self.static_columns.push(None);
+ } else if let Some(directive) = cmd.strip_prefix("label ") {
+ match directive.split_once(':') {
+ None => {
+ return Err(std::io::Error::new(
+ std::io::ErrorKind::InvalidInput,
+ format!("line {line_num}: Annotation missing ':'"),
+ ))
+ }
+ Some((col, label)) => self
+ .substitute_labels
+ .insert(col.to_owned(), label.to_owned()),
+ };
} else {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidInput,
Ok(())
}
}
+impl Default for Config {
+ fn default() -> Self {
+ Self {
+ column_threshold: 2,
+ static_columns: vec![],
+ hidden_columns: HashSet::new(),
+ substitute_labels: HashMap::new(),
+ }
+ }
+}
const HEADER: &str = r#"<!DOCTYPE html>
<html>
th, td { white-space: nowrap; }
th { text-align: left; font-weight: normal; }
th.spacer_row { height: .3em; }
+ .spacer_col { border: none; width: .2em; }
table { border-collapse: collapse }
tr.key > th { height: 10em; vertical-align: bottom; line-height: 1 }
tr.key > th > div { width: 1em; }
}
fn read_input(input: impl std::io::Read) -> Result<(Vec<Rowlike>, Config), std::io::Error> {
- let mut config = Config {
- column_threshold: 2,
- static_columns: vec![],
- };
+ let mut config = Config::default();
let reader = Reader::new(&mut config, std::io::BufReader::new(input).lines());
reader
.collect::<Result<Vec<_>, _>>()
let static_columns: HashSet<&str> = config
.static_columns
.iter()
+ .flatten()
.map(std::string::String::as_str)
.collect();
column_counts(rows)
.into_iter()
.filter_map(|(n, col)| {
- (n >= config.column_threshold && !static_columns.contains(col.as_str())).then_some(col)
+ (n >= config.column_threshold
+ && !static_columns.contains(col.as_str())
+ && !config.hidden_columns.contains(&col))
+ .then_some(col)
})
.collect()
}
}
}
-fn render_all_leftovers(row: &Row) -> HTML {
- let mut order: Vec<_> = row.entries.keys().collect();
+fn render_all_leftovers(config: &Config, row: &Row) -> HTML {
+ let mut order: Vec<_> = row
+ .entries
+ .keys()
+ .filter(|&col| !config.hidden_columns.contains(col))
+ .collect();
order.sort_unstable();
HTML(
order
let static_cells = config
.static_columns
.iter()
- .map(|col| render_cell(col, row))
+ .map(|ocol| match ocol {
+ Some(col) if config.hidden_columns.contains(col) => HTML::from(""),
+ Some(col) => render_cell(col, row),
+ None => HTML::from(r#"<td class="spacer_col"></td>"#),
+ })
.collect::<HTML>();
let dynamic_cells = columns
.iter()
+ .filter(|&col| !config.hidden_columns.contains(col))
.map(|col| render_cell(col, row))
.collect::<HTML>();
- let leftovers = render_all_leftovers(row);
+ let leftovers = render_all_leftovers(config, row);
HTML(format!(
"<tr><th id=\"{row_label}\">{row_label}</th>{static_cells}{dynamic_cells}<td class=\"leftover\" onmouseover=\"highlight('{row_label}')\" onmouseout=\"clear_highlight('{row_label}')\">{leftovers}</td></tr>\n"
))
}
}
+fn column_header_labels<'a>(
+ config: &'a Config,
+ columns: &'a [String],
+) -> impl Iterator<Item = Option<&'a String>> {
+ let static_columns = config.static_columns.iter().map(|oc| oc.as_ref());
+ let dynamic_columns = columns.iter().map(Some);
+ static_columns
+ .chain(dynamic_columns)
+ .filter(|ocol| ocol.map_or(true, |col| !config.hidden_columns.contains(col)))
+ .map(|ocol| {
+ ocol.map(|col| match config.substitute_labels.get(col) {
+ None => col,
+ Some(substitute) => substitute,
+ })
+ })
+}
+
fn render_column_headers(config: &Config, columns: &[String]) -> HTML {
HTML(
String::from(r#"<tr class="key"><th></th>"#)
- + &config.static_columns.iter().chain(columns.iter()).fold(
- String::new(),
- |mut acc, col| {
- let col_header = HTML::escape(col.as_ref());
- write!(
- &mut acc,
- r#"<th id="{col_header}"><div><div>{col_header}</div></div></th>"#
- )
- .unwrap();
- acc
- },
- )
+ + &column_header_labels(config, columns).fold(String::new(), |mut acc, ocol| {
+ match ocol {
+ Some(col) => {
+ let col_header = HTML::escape(col);
+ write!(
+ &mut acc,
+ r#"<th id="{col_header}"><div><div>{col_header}</div></div></th>"#
+ )
+ }
+ None => write!(&mut acc, r#"<th class="col_spacer"></th>"#),
+ }
+ .unwrap();
+ acc
+ })
+ "</tr>\n",
)
}
);
assert_eq!(
read_config(&b"!col foo"[..]).unwrap().static_columns,
- vec!["foo".to_owned()]
+ vec![Some("foo".to_owned())]
+ );
+ assert_eq!(
+ read_config(&b"!label foo:bar"[..])
+ .unwrap()
+ .substitute_labels["foo"],
+ "bar"
);
let bad_command = read_config(&b"!no such command"[..]);
let bad_num = read_config(&b"!col_threshold foo"[..]);
assert!(bad_num.is_err());
assert!(format!("{bad_num:?}").contains("line 1: col_threshold must be numeric"));
+
+ let bad_sub = read_config(&b"!label foo"[..]);
+ assert!(bad_sub.is_err());
+ assert!(format!("{bad_sub:?}").contains("line 1: Annotation missing ':'"));
}
#[test]
);
}
+ #[test]
+ fn test_column_header_labels() {
+ let mut cfg = Config::default();
+
+ assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([Some(&"foo".to_owned())]));
+
+ cfg.static_columns.push(Some("bar".to_owned()));
+ assert!(column_header_labels(&cfg, &["foo".to_owned()])
+ .eq([Some(&"bar".to_owned()), Some(&"foo".to_owned())]));
+
+ cfg.static_columns.push(None);
+ assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([
+ Some(&"bar".to_owned()),
+ None,
+ Some(&"foo".to_owned())
+ ]));
+
+ cfg.substitute_labels
+ .insert("foo".to_owned(), "foo (bits)".to_owned());
+ assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([
+ Some(&"bar".to_owned()),
+ None,
+ Some(&"foo (bits)".to_owned())
+ ]));
+
+ cfg.hidden_columns.insert("foo".to_owned());
+ assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([Some(&"bar".to_owned()), None]));
+
+ cfg.hidden_columns.insert("bar".to_owned());
+ assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([None]));
+ }
+
#[test]
fn test_render_cell() {
assert_eq!(
#[test]
fn test_render_leftovers() {
assert_eq!(
- render_all_leftovers(&Row {
- label: "nope".to_owned(),
- entries: HashMap::from([("foo".to_owned(), vec![None])]),
- }),
+ render_all_leftovers(
+ &Config::default(),
+ &Row {
+ label: "nope".to_owned(),
+ entries: HashMap::from([("foo".to_owned(), vec![None])]),
+ }
+ ),
HTML::from("foo")
);
assert_eq!(
- render_all_leftovers(&Row {
- label: "nope".to_owned(),
- entries: HashMap::from([
- ("foo".to_owned(), vec![None]),
- ("bar".to_owned(), vec![None])
- ]),
- }),
+ render_all_leftovers(
+ &Config::default(),
+ &Row {
+ label: "nope".to_owned(),
+ entries: HashMap::from([
+ ("foo".to_owned(), vec![None]),
+ ("bar".to_owned(), vec![None])
+ ]),
+ }
+ ),
HTML::from("bar, foo")
);
assert_eq!(
- render_all_leftovers(&Row {
- label: "nope".to_owned(),
- entries: HashMap::from([
- ("foo".to_owned(), vec![None]),
- ("bar".to_owned(), vec![None, None])
- ]),
- }),
+ render_all_leftovers(
+ &Config::default(),
+ &Row {
+ label: "nope".to_owned(),
+ entries: HashMap::from([
+ ("foo".to_owned(), vec![None]),
+ ("bar".to_owned(), vec![None, None])
+ ]),
+ }
+ ),
HTML::from("bar: 2, foo")
);
+ assert_eq!(
+ render_all_leftovers(
+ &Config {
+ column_threshold: 2,
+ static_columns: vec![],
+ hidden_columns: HashSet::from(["private".to_owned()]),
+ substitute_labels: HashMap::new(),
+ },
+ &Row {
+ label: "nope".to_owned(),
+ entries: HashMap::from([("private".to_owned(), vec![None]),]),
+ }
+ ),
+ HTML::from("")
+ );
}
#[test]
fn test_render_row() {
assert_eq!(
render_row(
- &Config {
- column_threshold: 0,
- static_columns: vec![],
- },
+ &Config::default(),
&["foo".to_owned()],
&mut Rowlike::Row(Row {
label: "nope".to_owned(),
render_row(
&Config {
column_threshold: 0,
- static_columns: vec!["foo".to_owned(), "bar".to_owned()],
+ static_columns: vec![Some("foo".to_owned()), Some("bar".to_owned())],
+ hidden_columns: HashSet::new(),
+ substitute_labels: HashMap::new(),
},
&["baz".to_owned()],
&mut Rowlike::Row(Row {
),
HTML::from(
r#"<tr><th id="nope">nope</th><td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">f</td><td class="yes" onmouseover="h2('nope','bar')" onmouseout="ch2('nope','bar')">r</td><td class="yes" onmouseover="h2('nope','baz')" onmouseout="ch2('nope','baz')">z</td><td class="leftover" onmouseover="highlight('nope')" onmouseout="clear_highlight('nope')"></td></tr>
+"#
+ )
+ );
+ assert_eq!(
+ render_row(
+ &Config {
+ column_threshold: 0,
+ static_columns: vec![Some("foo".to_owned()), None, Some("bar".to_owned())],
+ hidden_columns: HashSet::new(),
+ substitute_labels: HashMap::new(),
+ },
+ &[],
+ &mut Rowlike::Row(Row {
+ label: "nope".to_owned(),
+ entries: HashMap::from([
+ ("bar".to_owned(), vec![Some("r".to_owned())]),
+ ("foo".to_owned(), vec![Some("f".to_owned())]),
+ ]),
+ })
+ ),
+ HTML::from(
+ r#"<tr><th id="nope">nope</th><td class="yes" onmouseover="h2('nope','foo')" onmouseout="ch2('nope','foo')">f</td><td class="spacer_col"></td><td class="yes" onmouseover="h2('nope','bar')" onmouseout="ch2('nope','bar')">r</td><td class="leftover" onmouseover="highlight('nope')" onmouseout="clear_highlight('nope')"></td></tr>
+"#
+ )
+ );
+ assert_eq!(
+ render_row(
+ &Config {
+ column_threshold: 0,
+ static_columns: vec![],
+ hidden_columns: HashSet::from(["foo".to_owned()]),
+ substitute_labels: HashMap::new(),
+ },
+ &[],
+ &mut Rowlike::Row(Row {
+ label: "nope".to_owned(),
+ entries: HashMap::from([("foo".to_owned(), vec![Some("f".to_owned())]),]),
+ })
+ ),
+ HTML::from(
+ r#"<tr><th id="nope">nope</th><td class="leftover" onmouseover="highlight('nope')" onmouseout="clear_highlight('nope')"></td></tr>
+"#
+ )
+ );
+ assert_eq!(
+ render_row(
+ &Config {
+ column_threshold: 0,
+ static_columns: vec![Some("foo".to_owned())],
+ hidden_columns: HashSet::from(["foo".to_owned()]),
+ substitute_labels: HashMap::new(),
+ },
+ &[],
+ &mut Rowlike::Row(Row {
+ label: "nope".to_owned(),
+ entries: HashMap::from([("foo".to_owned(), vec![Some("f".to_owned())]),]),
+ })
+ ),
+ HTML::from(
+ r#"<tr><th id="nope">nope</th><td class="leftover" onmouseover="highlight('nope')" onmouseout="clear_highlight('nope')"></td></tr>
"#
)
);
projects / tablify / blobdiff