]> git.scottworley.com Git - tablify/blobdiff - src/lib.rs
projects / tablify / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Allow forcing column layout with `!col <name>` in input
[tablify] / src / lib.rs
diff --git a/src/lib.rs b/src/lib.rs
index d55aa53027e90c2e063ede8e80f0ee0bb9022b29..af582d45272207432a0d5de47e6f01be1dcf9938 100644 (file)
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,5 +1,5 @@
 use std::borrow::ToOwned;
 use std::borrow::ToOwned;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::fmt::Write;
 use std::io::BufRead;
 use std::iter::Iterator;
 use std::fmt::Write;
 use std::io::BufRead;
 use std::iter::Iterator;
@@ -7,6 +7,7 @@ use std::iter::Iterator;
 #[derive(PartialEq, Eq, Debug)]
 struct Config {
     column_threshold: usize,
 #[derive(PartialEq, Eq, Debug)]
 struct Config {
     column_threshold: usize,
+    static_columns: Vec<String>,
 }
 impl Config {
     fn apply_command(&mut self, cmd: &str) -> Result<(), std::io::Error> {
 }
 impl Config {
     fn apply_command(&mut self, cmd: &str) -> Result<(), std::io::Error> {
@@ -14,6 +15,8 @@ impl Config {
             self.column_threshold = threshold
                 .parse()
                 .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e))?;
             self.column_threshold = threshold
                 .parse()
                 .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e))?;
+        } else if let Some(col) = cmd.strip_prefix("col ") {
+            self.static_columns.push(col.to_owned());
         }
         Ok(())
     }
         }
         Ok(())
     }
@@ -196,6 +199,7 @@ impl<'cfg, Input: Iterator<Item = Result<String, std::io::Error>>> Iterator
 fn read_input(input: impl std::io::Read) -> Result<(Vec<Rowlike>, Config), std::io::Error> {
     let mut config = Config {
         column_threshold: 2,
 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 reader = Reader::new(&mut config, std::io::BufReader::new(input).lines());
     reader
     };
     let reader = Reader::new(&mut config, std::io::BufReader::new(input).lines());
     reader
@@ -224,9 +228,16 @@ fn column_counts(rows: &[Rowlike]) -> Vec<(usize, String)> {
     counts
 }
 fn column_order(config: &Config, rows: &[Rowlike]) -> Vec<String> {
     counts
 }
 fn column_order(config: &Config, rows: &[Rowlike]) -> Vec<String> {
+    let static_columns: HashSet<&str> = config
+        .static_columns
+        .iter()
+        .map(std::string::String::as_str)
+        .collect();
     column_counts(rows)
         .into_iter()
     column_counts(rows)
         .into_iter()
-        .filter_map(|(n, col)| (n >= config.column_threshold).then_some(col))
+        .filter_map(|(n, col)| {
+            (n >= config.column_threshold && !static_columns.contains(col.as_str())).then_some(col)
+        })
         .collect()
 }
 
         .collect()
 }
 
@@ -293,35 +304,43 @@ fn render_all_leftovers(row: &Row) -> HTML {
     )
 }
 
     )
 }
 
-fn render_row(columns: &[String], rowlike: &mut Rowlike) -> HTML {
+fn render_row(config: &Config, columns: &[String], rowlike: &mut Rowlike) -> HTML {
     match rowlike {
         Rowlike::Spacer => HTML::from("<tr><th class=\"spacer_row\"></th></tr>\n"),
         Rowlike::Row(row) => {
             let row_label = HTML::escape(row.label.as_ref());
     match rowlike {
         Rowlike::Spacer => HTML::from("<tr><th class=\"spacer_row\"></th></tr>\n"),
         Rowlike::Row(row) => {
             let row_label = HTML::escape(row.label.as_ref());
-            let cells = columns
+            let static_cells = config
+                .static_columns
+                .iter()
+                .map(|col| render_cell(col, row))
+                .collect::<HTML>();
+            let dynamic_cells = columns
                 .iter()
                 .map(|col| render_cell(col, row))
                 .collect::<HTML>();
             let leftovers = render_all_leftovers(row);
             HTML(format!(
                 .iter()
                 .map(|col| render_cell(col, row))
                 .collect::<HTML>();
             let leftovers = render_all_leftovers(row);
             HTML(format!(
-                "<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"
+                "<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 render_column_headers(columns: &[String]) -> HTML {
+fn render_column_headers(config: &Config, columns: &[String]) -> HTML {
     HTML(
         String::from(r#"<tr class="key"><th></th>"#)
     HTML(
         String::from(r#"<tr class="key"><th></th>"#)
-            + &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
-            })
+            + &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
+                },
+            )
             + "</tr>\n",
     )
 }
             + "</tr>\n",
     )
 }
@@ -337,9 +356,9 @@ pub fn tablify(input: impl std::io::Read) -> Result<HTML, std::io::Error> {
     let columns = column_order(&config, &rows);
     Ok(HTML(format!(
         "{HEADER}{}{}{FOOTER}",
     let columns = column_order(&config, &rows);
     Ok(HTML(format!(
         "{HEADER}{}{}{FOOTER}",
-        render_column_headers(&columns),
+        render_column_headers(&config, &columns),
         rows.into_iter()
         rows.into_iter()
-            .map(|mut r| render_row(&columns, &mut r))
+            .map(|mut r| render_row(&config, &columns, &mut r))
             .collect::<HTML>()
     )))
 }
             .collect::<HTML>()
     )))
 }
@@ -494,6 +513,10 @@ mod tests {
                 .column_threshold,
             10
         );
                 .column_threshold,
             10
         );
+        assert_eq!(
+            read_config(&b"!col foo"[..]).unwrap().static_columns,
+            vec!["foo".to_owned()]
+        );
 
         let bad_num = read_config(&b"!col_threshold foo"[..]);
         assert!(bad_num.is_err());
 
         let bad_num = read_config(&b"!col_threshold foo"[..]);
         assert!(bad_num.is_err());
@@ -674,6 +697,10 @@ mod tests {
     fn test_render_row() {
         assert_eq!(
             render_row(
     fn test_render_row() {
         assert_eq!(
             render_row(
+                &Config {
+                    column_threshold: 0,
+                    static_columns: vec![],
+                },
                 &["foo".to_owned()],
                 &mut Rowlike::Row(Row {
                     label: "nope".to_owned(),
                 &["foo".to_owned()],
                 &mut Rowlike::Row(Row {
                     label: "nope".to_owned(),
@@ -682,6 +709,27 @@ mod tests {
             ),
             HTML::from(
                 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>
             ),
             HTML::from(
                 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>
+"#
+            )
+        );
+        assert_eq!(
+            render_row(
+                &Config {
+                    column_threshold: 0,
+                    static_columns: vec!["foo".to_owned(), "bar".to_owned()],
+                },
+                &["baz".to_owned()],
+                &mut Rowlike::Row(Row {
+                    label: "nope".to_owned(),
+                    entries: HashMap::from([
+                        ("bar".to_owned(), vec![Some("r".to_owned())]),
+                        ("baz".to_owned(), vec![Some("z".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="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>
 "#
             )
         );
 "#
             )
         );
Summarize a text log as an HTML table