`!label col:new label` to substitute a different label for a column

[tablify] / src / lib.rs

diff --git a/src/lib.rs b/src/lib.rs
index 2111e1ed798d3c4ce31582999baf8b141f8ef667..f5d12f83f4b38b8198b434f158cbb57cc491d879 100644 (file)
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -9,6 +9,7 @@ struct Config {
     column_threshold: usize,
     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> {
@@ -25,6 +26,18 @@ impl Config {
             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,
@@ -40,6 +53,7 @@ impl Default for Config {
             column_threshold: 2,
             static_columns: vec![],
             hidden_columns: HashSet::new(),
+            substitute_labels: HashMap::new(),
         }
     }
 }
@@ -359,31 +373,40 @@ fn render_row(config: &Config, columns: &[String], rowlike: &mut Rowlike) -> HTM
     }
 }
 
-fn render_column_headers(config: &Config, columns: &[String]) -> HTML {
+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>"#)
-            + &static_columns
-                .chain(dynamic_columns)
-                .filter(|ocol| {
-                    ocol.map(|col| !config.hidden_columns.contains(col))
-                        .unwrap_or(true)
-                })
-                .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>"#),
+            + &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>"#
+                        )
                     }
-                    .unwrap();
-                    acc
-                })
+                    None => write!(&mut acc, r#"<th class="col_spacer"></th>"#),
+                }
+                .unwrap();
+                acc
+            })
             + "</tr>\n",
     )
 }
@@ -560,6 +583,12 @@ mod tests {
             read_config(&b"!col foo"[..]).unwrap().static_columns,
             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"[..]);
         assert!(bad_command.is_err());
@@ -568,6 +597,10 @@ mod tests {
         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]
@@ -592,6 +625,38 @@ mod tests {
         );
     }
 
+    #[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!(
@@ -753,6 +818,7 @@ mod tests {
                     column_threshold: 2,
                     static_columns: vec![],
                     hidden_columns: HashSet::from(["private".to_owned()]),
+                    substitute_labels: HashMap::new(),
                 },
                 &Row {
                     label: "nope".to_owned(),
@@ -785,6 +851,7 @@ mod tests {
                     column_threshold: 0,
                     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 {
@@ -807,6 +874,7 @@ mod tests {
                     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 {
@@ -828,6 +896,7 @@ mod tests {
                     column_threshold: 0,
                     static_columns: vec![],
                     hidden_columns: HashSet::from(["foo".to_owned()]),
+                    substitute_labels: HashMap::new(),
                 },
                 &[],
                 &mut Rowlike::Row(Row {
@@ -846,6 +915,7 @@ mod tests {
                     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 {