WIP: Add tests for various parsers

Rust is not able to run the current implementation of parser combinators
since it doesn't have lazy evaluation on function calls (the parsing
graph is not acyclic).

src/parser.rs

@@ -30,12 +30,12 @@ impl std::ops::BitOr<Parser> for Parser {
 fn and_combinator(p1: Parser, p2: Parser) -> Parser {
     let combined = move |queue: &str| match p1.execute(queue) {
         Result::Failure => Result::Failure,
-        Result::Success(r1, rest) => match p2.execute(&rest) {
+        Result::Success(r1, rest1) => match p2.execute(&rest1) {
             Result::Failure => Result::Failure,
-            Result::Success(r2, rest) => {
+            Result::Success(r2, rest2) => {
                 let mut ris = r1.clone();
                 ris.push_str(&r2);
-                Result::Success(ris, rest)
+                Result::Success(ris, rest2)
             }
         },
     };
@@ -52,6 +52,7 @@ fn or_combinator(p1: Parser, p2: Parser) -> Parser {
 
 fn char_parser(c: char) -> Parser {
     let inner = move |queue: &str| {
+        let queue = queue.trim_start();
         if queue.is_empty() || queue.chars().nth(0).unwrap() != c {
             return Result::Failure;
         }
@@ -62,42 +63,38 @@ fn char_parser(c: char) -> Parser {
 
 fn word_parser() -> Parser {
     let inner = move |queue: &str| {
-        let mut started = false;
+        let queue = queue.trim_start();
         let mut buffer = String::new();
         let mut index = queue.len();
-        let offset = queue.len() - queue.trim_start().len();
-        for (i, car) in queue.chars().enumerate() {
+        let mut started = false;
+        for (i, car) in queue.trim_start().chars().enumerate() {
             if !started {
                 match car {
-                    c if c >= 'A' || c <= 'Z' || c == '_' => {
+                    c if (c >= 'A' && c <= 'Z') || c == '_' => {
                         started = true;
                         buffer.push(c);
                     }
                     _ => return Result::Failure,
                 }
             } else {
                 match car {
-                    c if c >= 'A' || c <= 'Z' || c == '_' => {
-                        buffer.push(c);
-                    }
+                    c if (c >= 'A' && c <= 'Z') || c == '_' => buffer.push(c),
                     _ => {
                         index = i;
                         break;
                     }
                 }
             }
         }
-        Result::Success(
-            buffer.chars().collect(),
-            queue[index + offset..].to_string(),
-        )
+        Result::Success(buffer.chars().collect(), queue[index..].to_string())
     };
     Parser(Box::new(inner))
 }
 
 fn string_parser(s: &str) -> Parser {
     let ss = String::from(s);
     let inner = move |queue: &str| {
+        let queue = queue.trim_start();
         let s = &ss;
         let offset = queue.len() - queue.trim_start().len();
         if queue.trim_start().starts_with(s) {
@@ -153,5 +150,46 @@ fn iff_parser() -> Parser {
 }
 
 fn expression_parser() -> Parser {
-    word_parser() | absurdum_parser() | and_parser() | or_parser() | not_parser() | implies_parser() | iff_parser()
+    absurdum_parser()
+        | word_parser()
+        | and_parser()
+        | or_parser()
+        | not_parser()
+        | implies_parser()
+        | iff_parser()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{and_parser, word_parser, Result};
+
+    #[test]
+    fn word_parser_test() {
+        let queue = " ciao ";
+        match word_parser().execute(queue) {
+            Result::Failure => assert!(true),
+            Result::Success(_, _) => assert!(false),
+        }
+
+        let queue = " CIAO ";
+        match word_parser().execute(queue) {
+            Result::Failure => assert!(false),
+            Result::Success(m, r) => {
+                assert_eq!("CIAO", m.as_str());
+                assert_eq!(" ", r.as_str());
+            }
+        }
+    }
+
+    #[test]
+    fn and_parser_test() {
+        let queue = "(A ^ B)";
+        match and_parser().execute(queue) {
+            Result::Failure => assert!(false),
+            Result::Success(m, r) => {
+                assert_eq!("(A ^ B)", m.as_str());
+                assert_eq!("", r.as_str());
+            }
+        }
+    }
 }