macro-sani: skipping the algorithm, if no macro is in the string.

1 files changed, 53 insertions, 41 deletions

diff --git a/src/bibiman/sanitize/optimized_sanitize.rs b/src/bibiman/sanitize/optimized_sanitize.rs
index 8788d39..3a9dc67 100644
--- a/src/bibiman/sanitize/optimized_sanitize.rs
+++ b/src/bibiman/sanitize/optimized_sanitize.rs
@@ -42,56 +42,68 @@ enum Token {
 }
 
 pub fn optimized_sanitize(input_text: &str) -> String {
-    let mut out: Vec<&str> = Vec::with_capacity(input_text.chars().count());
-    let mut bracket_counter: u32 = 0;
-    let mut bc_up: bool = false;
-    let mut counter_actions: HashMap<u32, &str> = HashMap::new();
-    let mut lex = Token::lexer(input_text);
-    while let Some(sometoken) = lex.next() {
-        match sometoken {
-            Ok(token) => match token {
-                Token::ForcedSpace => {
-                    out.push(" ");
-                    bc_up = false;
-                }
-                Token::OpenCurlyBracket => {
-                    if bc_up {
-                        bracket_counter = bracket_counter.saturating_add(1);
-                    } else {
-                        out.push("{")
+    let mut char_counter: usize = 0;
+    let mut contains_macro: bool = false;
+    for char in input_text.chars() {
+        if char == '\\' {
+            contains_macro = true;
+        }
+        char_counter = char_counter.saturating_add(1);
+    }
+    if !contains_macro {
+        input_text.to_string()
+    } else {
+        let mut out: Vec<&str> = Vec::with_capacity(char_counter);
+        let mut bracket_counter: u32 = 0;
+        let mut bc_up: bool = false;
+        let mut counter_actions: HashMap<u32, &str> = HashMap::new();
+        let mut lex = Token::lexer(input_text);
+        while let Some(sometoken) = lex.next() {
+            match sometoken {
+                Ok(token) => match token {
+                    Token::ForcedSpace => {
+                        out.push(" ");
+                        bc_up = false;
                     }
-                }
-                Token::ClosedCurlyBracket => {
-                    if bracket_counter == 0 {
-                        out.push("}")
-                    } else {
-                        match counter_actions.remove(&bracket_counter) {
-                            None => out.push("}"),
-                            Some(a) => out.push(a),
+                    Token::OpenCurlyBracket => {
+                        if bc_up {
+                            bracket_counter = bracket_counter.saturating_add(1);
+                        } else {
+                            out.push("{")
                         }
-                        bracket_counter = bracket_counter - 1;
                     }
-                }
-                Token::LaTeXMacro => {
-                    let texmacro = lex.slice();
-                    if let Some(x) = LOOKUP.get(&texmacro) {
-                        if let Some(end) = x.1 {
-                            bc_up = true;
-                            counter_actions.insert(bracket_counter + 1, end);
+                    Token::ClosedCurlyBracket => {
+                        if bracket_counter == 0 {
+                            out.push("}")
+                        } else {
+                            match counter_actions.remove(&bracket_counter) {
+                                None => out.push("}"),
+                                Some(a) => out.push(a),
+                            }
+                            bracket_counter = bracket_counter - 1;
+                        }
+                    }
+                    Token::LaTeXMacro => {
+                        let texmacro = lex.slice();
+                        if let Some(x) = LOOKUP.get(&texmacro) {
+                            if let Some(end) = x.1 {
+                                bc_up = true;
+                                counter_actions.insert(bracket_counter + 1, end);
+                            }
+                            out.push(x.0);
+                        } else {
+                            out.push(texmacro)
                         }
-                        out.push(x.0);
-                    } else {
-                        out.push(texmacro)
                     }
+                },
+                Err(_) => {
+                    out.push(lex.slice());
+                    bc_up = false;
                 }
-            },
-            Err(_) => {
-                out.push(lex.slice());
-                bc_up = false;
             }
         }
+        out.into_iter().collect::<String>()
     }
-    out.into_iter().collect::<String>()
 }
 
 #[cfg(test)]