`!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 b4b8bbcc44ed515aec293148aa020f6bb584175f..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>,
     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> {
 }
 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);
             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,
         } 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(),
             column_threshold: 2,
             static_columns: vec![],
             hidden_columns: HashSet::new(),

+            substitute_labels: HashMap::new(),

         }
     }
 }
         }
     }
 }


@@ -359,21 +373,27 @@ fn render_row(config: &Config, columns: &[String], rowlike: &mut Rowlike) -> HTM
     }
 }
 
     }
 }
 

-fn column_header_order<'a>(
+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);
     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))
-    })
+    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>"#)
 }
 
 fn render_column_headers(config: &Config, columns: &[String]) -> HTML {
     HTML(
         String::from(r#"<tr class="key"><th></th>"#)

-            + &column_header_order(config, columns).fold(String::new(), |mut acc, ocol| {
+            + &column_header_labels(config, columns).fold(String::new(), |mut acc, ocol| {

                 match ocol {
                     Some(col) => {
                         let col_header = HTML::escape(col);
                 match ocol {
                     Some(col) => {
                         let col_header = HTML::escape(col);


@@ -563,6 +583,12 @@ mod tests {
             read_config(&b"!col foo"[..]).unwrap().static_columns,
             vec![Some("foo".to_owned())]
         );
             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());
 
         let bad_command = read_config(&b"!no such command"[..]);
         assert!(bad_command.is_err());


@@ -571,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_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]


@@ -596,27 +626,35 @@ mod tests {
     }
 
     #[test]
     }
 
     #[test]

-    fn test_column_header_order() {
+    fn test_column_header_labels() {

         let mut cfg = Config::default();
 
         let mut cfg = Config::default();
 

-        assert!(column_header_order(&cfg, &["foo".to_owned()]).eq([Some(&"foo".to_owned())]));
+        assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([Some(&"foo".to_owned())]));

 
         cfg.static_columns.push(Some("bar".to_owned()));
 
         cfg.static_columns.push(Some("bar".to_owned()));

-        assert!(column_header_order(&cfg, &["foo".to_owned()])
+        assert!(column_header_labels(&cfg, &["foo".to_owned()])

             .eq([Some(&"bar".to_owned()), Some(&"foo".to_owned())]));
 
         cfg.static_columns.push(None);
             .eq([Some(&"bar".to_owned()), Some(&"foo".to_owned())]));
 
         cfg.static_columns.push(None);

-        assert!(column_header_order(&cfg, &["foo".to_owned()]).eq([
+        assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([

             Some(&"bar".to_owned()),
             None,
             Some(&"foo".to_owned())
         ]));
 
             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());
         cfg.hidden_columns.insert("foo".to_owned());

-        assert!(column_header_order(&cfg, &["foo".to_owned()]).eq([Some(&"bar".to_owned()), None]));
+        assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([Some(&"bar".to_owned()), None]));

 
         cfg.hidden_columns.insert("bar".to_owned());
 
         cfg.hidden_columns.insert("bar".to_owned());

-        assert!(column_header_order(&cfg, &["foo".to_owned()]).eq([None]));
+        assert!(column_header_labels(&cfg, &["foo".to_owned()]).eq([None]));

     }
 
     #[test]
     }
 
     #[test]


@@ -780,6 +818,7 @@ mod tests {
                     column_threshold: 2,
                     static_columns: vec![],
                     hidden_columns: HashSet::from(["private".to_owned()]),
                     column_threshold: 2,
                     static_columns: vec![],
                     hidden_columns: HashSet::from(["private".to_owned()]),

+                    substitute_labels: HashMap::new(),

                 },
                 &Row {
                     label: "nope".to_owned(),
                 },
                 &Row {
                     label: "nope".to_owned(),


@@ -812,6 +851,7 @@ mod tests {
                     column_threshold: 0,
                     static_columns: vec![Some("foo".to_owned()), Some("bar".to_owned())],
                     hidden_columns: HashSet::new(),
                     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 {
                 },
                 &["baz".to_owned()],
                 &mut Rowlike::Row(Row {


@@ -834,6 +874,7 @@ mod tests {
                     column_threshold: 0,
                     static_columns: vec![Some("foo".to_owned()), None, Some("bar".to_owned())],
                     hidden_columns: HashSet::new(),
                     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 {
                 },
                 &[],
                 &mut Rowlike::Row(Row {


@@ -855,6 +896,7 @@ mod tests {
                     column_threshold: 0,
                     static_columns: vec![],
                     hidden_columns: HashSet::from(["foo".to_owned()]),
                     column_threshold: 0,
                     static_columns: vec![],
                     hidden_columns: HashSet::from(["foo".to_owned()]),

+                    substitute_labels: HashMap::new(),

                 },
                 &[],
                 &mut Rowlike::Row(Row {
                 },
                 &[],
                 &mut Rowlike::Row(Row {


@@ -873,6 +915,7 @@ mod tests {
                     column_threshold: 0,
                     static_columns: vec![Some("foo".to_owned())],
                     hidden_columns: HashSet::from(["foo".to_owned()]),
                     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 {
                 },
                 &[],
                 &mut Rowlike::Row(Row {