Add parsing of more logical combinators

Signed-off-by: Marcel Müller <neikos@neikos.email>

src/ast/mod.rs

@@ -663,6 +663,7 @@ fn parse_expression<'input>(
             TokenOperator::Divide => Left(7, |_, lhs, rhs| Ok(TemplateAstExpr::Operation { op: TokenOperator::Divide, lhs: Box::new(lhs), rhs: Box::new(rhs) })),
             TokenOperator::And => Left(7, |_, lhs, rhs| Ok(TemplateAstExpr::Operation { op: TokenOperator::And, lhs: Box::new(lhs), rhs: Box::new(rhs) })),
             TokenOperator::Or => Left(5, |_, lhs, rhs| Ok(TemplateAstExpr::Operation { op: TokenOperator::Or, lhs: Box::new(lhs), rhs: Box::new(rhs) })),
+            _ => winnow::combinator::todo
         }),
     )
     .parse_next(input)

src/eval/mod.rs

@@ -203,6 +203,7 @@ pub fn execute(vm: &VMInstructions, global_context: &Context) -> Result<String,
                     crate::parser::TokenOperator::Divide => left_value.try_div(right_value),
                     crate::parser::TokenOperator::And => left_value.try_and(right_value),
                     crate::parser::TokenOperator::Or => left_value.try_or(right_value),
+                    _ => todo!(),
                 };
 
                 scopes.insert_into_slot(*result_slot, result.unwrap());

src/parser/mod.rs

@@ -230,6 +230,12 @@ pub enum TokenOperator {
     Divide,
     And,
     Or,
+    Equal,
+    NotEqual,
+    Greater,
+    GreaterOrEqual,
+    Lesser,
+    LesserOrEqual,
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
@@ -522,6 +528,22 @@ fn parse_operator<'input>(input: &mut Input<'input>) -> PResult<'input, Template
                 "|".value(TokenOperator::Or),
                 cut_err(fail),
             )),
+            '<' => alt((
+                "=".value(TokenOperator::LesserOrEqual),
+                empty.value(TokenOperator::Lesser),
+            )),
+            '>' => alt((
+                "=".value(TokenOperator::GreaterOrEqual),
+                empty.value(TokenOperator::Greater),
+            )),
+            '!' => alt((
+                "=".value(TokenOperator::NotEqual),
+                cut_err(fail),
+            )),
+            '=' => alt((
+                "=".value(TokenOperator::Equal),
+                cut_err(fail),
+            )),
             _ => fail,
         },
     )
@@ -747,7 +769,7 @@ mod tests {
 
     #[test]
     fn parse_operations() {
-        let input = "{{= 5 * 14 + 3 / 2 - 1 }}{{ if foo && bar || baz }}{{ end }}";
+        let input = "{{= 5 * 14 + 3 / 2 - 1 }}{{ if foo && bar || baz && 2 != 3 || 4 > 2 || 43 <= 5 }}{{ end }}";
         let output = parse(input.into());
 
         insta::assert_debug_snapshot!(output, @r#"
@@ -790,12 +812,36 @@ mod tests {
                     [Whitespace]" " (44..45),
                     [Ident]"baz" (45..48),
                     [Whitespace]" " (48..49),
-                    [RightDelim]"}}" (49..51),
+                    [Operator(And)]"&&" (49..51),
-                    [LeftDelim]"{{" (51..53),
+                    [Whitespace]" " (51..52),
+                    [Literal(Integer(2))]"2" (52..53),
                     [Whitespace]" " (53..54),
-                    [End]"end" (54..57),
+                    [Operator(NotEqual)]"!=" (54..56),
-                    [Whitespace]" " (57..58),
+                    [Whitespace]" " (56..57),
-                    [RightDelim]"}}" (58..60),
+                    [Literal(Integer(3))]"3" (57..58),
+                    [Whitespace]" " (58..59),
+                    [Operator(Or)]"||" (59..61),
+                    [Whitespace]" " (61..62),
+                    [Literal(Integer(4))]"4" (62..63),
+                    [Whitespace]" " (63..64),
+                    [Operator(Greater)]">" (64..65),
+                    [Whitespace]" " (65..66),
+                    [Literal(Integer(2))]"2" (66..67),
+                    [Whitespace]" " (67..68),
+                    [Operator(Or)]"||" (68..70),
+                    [Whitespace]" " (70..71),
+                    [Literal(Integer(43))]"43" (71..73),
+                    [Whitespace]" " (73..74),
+                    [Operator(LesserOrEqual)]"<=" (74..76),
+                    [Whitespace]" " (76..77),
+                    [Literal(Integer(5))]"5" (77..78),
+                    [Whitespace]" " (78..79),
+                    [RightDelim]"}}" (79..81),
+                    [LeftDelim]"{{" (81..83),
+                    [Whitespace]" " (83..84),
+                    [End]"end" (84..87),
+                    [Whitespace]" " (87..88),
+                    [RightDelim]"}}" (88..90),
                 ],
             },
         )