]> git.scottworley.com Git - tablify/blobdiff - src/lib.rs
projects / tablify / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Plumb config around
[tablify] / src / lib.rs
diff --git a/src/lib.rs b/src/lib.rs
index 5c994c9f20a0d8eeb63650d4d9618c6da6dc75dc..acf53834208d68cc32fc75f9959c027e850f54ed 100644 (file)
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,8 +4,19 @@ use std::fmt::Write;
 use std::io::BufRead;
 use std::iter::Iterator;
 
 use std::io::BufRead;
 use std::iter::Iterator;
 
-pub struct Config {
-    pub column_threshold: usize,
+#[derive(PartialEq, Eq, Debug)]
+struct Config {
+    column_threshold: usize,
+}
+impl Config {
+    fn apply_command(&mut self, cmd: &str) -> Result<(), std::io::Error> {
+        if let Some(threshold) = cmd.strip_prefix("col_threshold ") {
+            self.column_threshold = threshold
+                .parse()
+                .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e))?;
+        }
+        Ok(())
+    }
 }
 
 const HEADER: &str = r#"<!DOCTYPE html>
 }
 
 const HEADER: &str = r#"<!DOCTYPE html>
@@ -87,12 +98,15 @@ enum InputLine<'a> {
     Blank,
     RowHeader(&'a str),
     Entry(&'a str, Option<&'a str>),
     Blank,
     RowHeader(&'a str),
     Entry(&'a str, Option<&'a str>),
+    Command(&'a str),
 }
 impl<'a> From<&'a str> for InputLine<'a> {
     fn from(value: &'a str) -> InputLine<'a> {
         let trimmed = value.trim_end();
         if trimmed.is_empty() {
             InputLine::Blank
 }
 impl<'a> From<&'a str> for InputLine<'a> {
     fn from(value: &'a str) -> InputLine<'a> {
         let trimmed = value.trim_end();
         if trimmed.is_empty() {
             InputLine::Blank
+        } else if let Some(cmd) = trimmed.strip_prefix('!') {
+            InputLine::Command(cmd)
         } else if !trimmed.starts_with(' ') {
             InputLine::RowHeader(value.trim())
         } else {
         } else if !trimmed.starts_with(' ') {
             InputLine::RowHeader(value.trim())
         } else {
@@ -116,19 +130,23 @@ enum Rowlike {
     Spacer,
 }
 
     Spacer,
 }
 
-struct Reader<Input: Iterator<Item = Result<String, std::io::Error>>> {
+struct Reader<'cfg, Input: Iterator<Item = Result<String, std::io::Error>>> {
     input: std::iter::Enumerate<Input>,
     row: Option<Row>,
     input: std::iter::Enumerate<Input>,
     row: Option<Row>,
+    config: &'cfg mut Config,
 }
 }
-impl<Input: Iterator<Item = Result<String, std::io::Error>>> Reader<Input> {
-    fn new(input: Input) -> Self {
+impl<'cfg, Input: Iterator<Item = Result<String, std::io::Error>>> Reader<'cfg, Input> {
+    fn new(config: &'cfg mut Config, input: Input) -> Self {
         Self {
             input: input.enumerate(),
             row: None,
         Self {
             input: input.enumerate(),
             row: None,
+            config,
         }
     }
 }
         }
     }
 }
-impl<Input: Iterator<Item = Result<String, std::io::Error>>> Iterator for Reader<Input> {
+impl<'cfg, Input: Iterator<Item = Result<String, std::io::Error>>> Iterator
+    for Reader<'cfg, Input>
+{
     type Item = Result<Rowlike, std::io::Error>;
     fn next(&mut self) -> Option<Self::Item> {
         loop {
     type Item = Result<Rowlike, std::io::Error>;
     fn next(&mut self) -> Option<Self::Item> {
         loop {
@@ -136,6 +154,11 @@ impl<Input: Iterator<Item = Result<String, std::io::Error>>> Iterator for Reader
                 None => return Ok(std::mem::take(&mut self.row).map(Rowlike::Row)).transpose(),
                 Some((_, Err(e))) => return Some(Err(e)),
                 Some((n, Ok(line))) => match InputLine::from(line.as_ref()) {
                 None => return Ok(std::mem::take(&mut self.row).map(Rowlike::Row)).transpose(),
                 Some((_, Err(e))) => return Some(Err(e)),
                 Some((n, Ok(line))) => match InputLine::from(line.as_ref()) {
+                    InputLine::Command(cmd) => {
+                        if let Err(e) = self.config.apply_command(cmd) {
+                            return Some(Err(e));
+                        }
+                    }
                     InputLine::Blank if self.row.is_some() => {
                         return Ok(std::mem::take(&mut self.row).map(Rowlike::Row)).transpose()
                     }
                     InputLine::Blank if self.row.is_some() => {
                         return Ok(std::mem::take(&mut self.row).map(Rowlike::Row)).transpose()
                     }
@@ -171,12 +194,13 @@ impl<Input: Iterator<Item = Result<String, std::io::Error>>> Iterator for Reader
 }
 
 fn read_input(input: impl std::io::Read) -> Result<(Vec<Rowlike>, Config), std::io::Error> {
 }
 
 fn read_input(input: impl std::io::Read) -> Result<(Vec<Rowlike>, Config), std::io::Error> {
-    let default_config = Config {
+    let mut config = Config {
         column_threshold: 2,
     };
         column_threshold: 2,
     };
-    Reader::new(std::io::BufReader::new(input).lines())
+    let reader = Reader::new(&mut config, std::io::BufReader::new(input).lines());
+    reader
         .collect::<Result<Vec<_>, _>>()
         .collect::<Result<Vec<_>, _>>()
-        .map(|rows| (rows, default_config))
+        .map(|rows| (rows, config))
 }
 
 fn column_counts(rows: &[Rowlike]) -> Vec<(usize, String)> {
 }
 
 fn column_counts(rows: &[Rowlike]) -> Vec<(usize, String)> {
@@ -269,7 +293,7 @@ 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) => {
     match rowlike {
         Rowlike::Spacer => HTML::from("<tr><th class=\"spacer_row\"></th></tr>\n"),
         Rowlike::Row(row) => {
@@ -286,7 +310,7 @@ fn render_row(columns: &[String], rowlike: &mut Rowlike) -> HTML {
     }
 }
 
     }
 }
 
-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>"#)
             + &columns.iter().fold(String::new(), |mut acc, col| {
     HTML(
         String::from(r#"<tr class="key"><th></th>"#)
             + &columns.iter().fold(String::new(), |mut acc, col| {
@@ -313,9 +337,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>()
     )))
 }
@@ -356,6 +380,9 @@ mod tests {
     fn read_rows(input: impl std::io::Read) -> Result<Vec<Rowlike>, std::io::Error> {
         read_input(input).map(|(rows, _)| rows)
     }
     fn read_rows(input: impl std::io::Read) -> Result<Vec<Rowlike>, std::io::Error> {
         read_input(input).map(|(rows, _)| rows)
     }
+    fn read_config(input: impl std::io::Read) -> Result<Config, std::io::Error> {
+        read_input(input).map(|(_, config)| config)
+    }
     #[test]
     fn test_read_rows() {
         assert_eq!(
     #[test]
     fn test_read_rows() {
         assert_eq!(
@@ -459,6 +486,20 @@ mod tests {
         assert!(format!("{bad2:?}").contains("3: Entry with no header"));
     }
 
         assert!(format!("{bad2:?}").contains("3: Entry with no header"));
     }
 
+    #[test]
+    fn test_read_config() {
+        assert_eq!(
+            read_config(&b"!col_threshold 10"[..])
+                .unwrap()
+                .column_threshold,
+            10
+        );
+
+        let bad_num = read_config(&b"!col_threshold foo"[..]);
+        assert!(bad_num.is_err());
+        assert!(format!("{bad_num:?}").contains("Parse"));
+    }
+
     #[test]
     fn test_column_counts() {
         assert_eq!(
     #[test]
     fn test_column_counts() {
         assert_eq!(
@@ -633,6 +674,9 @@ mod tests {
     fn test_render_row() {
         assert_eq!(
             render_row(
     fn test_render_row() {
         assert_eq!(
             render_row(
+                &Config {
+                    column_threshold: 0,
+                },
                 &["foo".to_owned()],
                 &mut Rowlike::Row(Row {
                     label: "nope".to_owned(),
                 &["foo".to_owned()],
                 &mut Rowlike::Row(Row {
                     label: "nope".to_owned(),
Summarize a text log as an HTML table