feat: Parse query

query.pest

@@ -0,0 +1,12 @@
+tag = {"#" ~ (LETTER|NUMBER|CONNECTOR_PUNCTUATION|DASH_PUNCTUATION)+}
+
+operation = _{and | or}
+  and = {"&"}
+  or = {"|"}
+
+expr = {term ~ (operation ~ term)*}
+  term = _{tag | "(" ~ expr ~ ")"}
+
+tagsearch = _{SOI ~ expr ~ EOI}
+
+WHITESPACE = _{" " | "\t" | NEWLINE}

src/parsers.rs

@@ -1,15 +1,29 @@
-use pest_derive::Parser;
+pub mod tagline {
+    use pest_derive::Parser;
 
-#[derive(Parser)]
-#[grammar = "tagline.pest"]
-/// TaglineParser is responsible for parsing the taglines at the start of each searched file.
-pub struct TaglineParser;
+    #[derive(Parser)]
+    #[grammar = "tagline.pest"]
+    /// TaglineParser is responsible for parsing the taglines at the start of each searched file.
+    /// The relevant rule is `tagline`.
+    pub struct TaglineParser;
+}
+
+pub mod query {
+    use pest_derive::Parser;
+
+    #[derive(Parser)]
+    #[grammar = "query.pest"]
+    /// QueryParser is responsible for parsing the search query.
+    /// The relevant rule is `tagsearch`.
+    pub struct QueryParser;
+}
 
 #[cfg(test)]
 mod tests {
-    use pest::Parser;
+    use super::query;
+    use super::tagline;
 
-    use super::*;
+    use pest::Parser;
 
     #[test]
     fn test_tagline_parser() {
@@ -60,9 +74,9 @@ mod tests {
         ];
 
         test_cases.iter().for_each(|test_case| {
-            println!("Testing {}", test_case.name);
+            println!("test_tagline_parser: \n\t{}", test_case.name);
 
-            let res = TaglineParser::parse(Rule::tagline, test_case.input);
+            let res = tagline::TaglineParser::parse(tagline::Rule::tagline, test_case.input);
             if res.is_err() {
                 assert!(test_case.expected_error);
                 return;
@@ -72,12 +86,78 @@ mod tests {
 
             for (i, tag) in res.unwrap().next().unwrap().into_inner().enumerate() {
                 match tag.as_rule() {
-                    Rule::tag => {
+                    tagline::Rule::tag => {
                         assert!(tag.as_str() == test_case.expected_tags[i])
                     }
                     _ => unreachable!(),
                 }
             }
         })
     }
+
+    #[test]
+    fn test_query_parser() {
+        struct TestCase<'a> {
+            name: &'a str,
+            input: &'a str,
+            expected_error: bool,
+        }
+
+        let test_cases = [
+            TestCase {
+                name: "success_with_space",
+                input: "#a & #b",
+                expected_error: false,
+            },
+            TestCase {
+                name: "success_without_space",
+                input: "#a&#b",
+                expected_error: false,
+            },
+            TestCase {
+                name: "success_with_newline",
+                input: "#a\n|\n#b",
+                expected_error: false,
+            },
+            TestCase {
+                name: "success_nested",
+                input: "#a & (#b | #c)",
+                expected_error: false,
+            },
+            TestCase {
+                name: "fail_wrong_tag",
+                input: "##",
+                expected_error: true,
+            },
+            TestCase {
+                name: "fail_no_following_tag",
+                input: "#a &",
+                expected_error: true,
+            },
+            TestCase {
+                name: "fail_no_open_parentheses",
+                input: "#a & #b)",
+                expected_error: true,
+            },
+            TestCase {
+                name: "fail_no_closing_parentheses",
+                input: "(#a & #b",
+                expected_error: true,
+            },
+        ];
+
+        test_cases.iter().for_each(|test_case| {
+            println!("test_tagline_parser: \n\t{}", test_case.name);
+
+            let res = query::QueryParser::parse(query::Rule::tagsearch, test_case.input);
+            if res.is_err() {
+                assert!(test_case.expected_error);
+                return;
+            }
+
+            assert!(!test_case.expected_error);
+
+            assert_eq!(test_case.input, res.unwrap().next().unwrap().as_str())
+        })
+    }
 }

tagline.pest

@@ -1,6 +1,6 @@
 tag = {"#" ~ (LETTER|NUMBER|CONNECTOR_PUNCTUATION|DASH_PUNCTUATION)+}
 taglist = _{"[" ~ tag* ~ "]"}
-tagline = _{"tags:" ~ taglist}
+tagline = _{SOI ~ "tags:" ~ taglist ~ EOI}
 
 WHITESPACE = _{" " | "\t" | NEWLINE}