]> git.scottworley.com Git - tablify/commitdiff
projects / tablify / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (from parent 1: 5a070b3)
Read column threshold from `!col_threshold <N>` in input
authorScott Worley <scottworley@scottworley.com>
Wed, 2 Oct 2024 21:15:46 +0000 (14:15 -0700)
committerScott Worley <scottworley@scottworley.com>
Fri, 4 Oct 2024 05:09:16 +0000 (22:09 -0700)
Changelog patch | blob | blame | history
src/lib.rs patch | blob | blame | history

diff --git a/Changelog b/Changelog
index 2bf12615d8ff0a50acb6497f87b1d90a0a0152e4..cf5af535db62ecb94c5a4d2e21199912758c7a5b 100644 (file)
--- a/Changelog
+++ b/Changelog
@@ -1,4 +1,5 @@
 ## [Unreleased]
 ## [Unreleased]
+- Read column threshold from `!col_threshold <N>` in input
 
 ## [0.3.0] - 2024-10-02
 - Center text in each cell
 
 ## [0.3.0] - 2024-10-02
 - Center text in each cell
diff --git a/src/lib.rs b/src/lib.rs
index 5c994c9f20a0d8eeb63650d4d9618c6da6dc75dc..b52806a744df217691d50d43d471f01cdbd15e0d 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)> {
@@ -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(),
+            Config {
+                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!(
Summarize a text log as an HTML table