evaluation of rules simple comparison first

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bool_expr_parser_nom"
-version = "0.2.1"
+version = "0.2.2"
 edition = "2021"
 authors = ["Nikolajus Krauklis <[email protected]>"]
 

src/ast.rs

@@ -3,17 +3,35 @@ use core::fmt;
 use chrono::NaiveDate;
 
 /// TODO: add date and datetime as its common
-#[derive(Debug, Clone, PartialEq, PartialOrd)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum Atom {
     String(String),
-    Number(i64),
+    Number(i32),
     Float(f64),
     Boolean(bool),
     Variable(String),
     Date(NaiveDate),
     DateTime(String),
 }
 
+impl PartialOrd for Atom {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        match self {
+            Atom::Number(v) => match other {
+                Atom::Number(v2) => Some(v.cmp(v2)),
+                Atom::Float(v2) => f64::from(*v).partial_cmp(v2),
+                _ => None,
+            },
+            Atom::Float(v) => match other {
+                Atom::Float(v2) => v.partial_cmp(v2),
+                Atom::Number(v2) => v.partial_cmp(&f64::from(*v2)),
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+}
+
 impl fmt::Display for Atom {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
@@ -108,10 +126,9 @@ pub enum AstNode {
 impl AstNode {
     pub fn as_str(&self) -> Option<&str> {
         match self {
-            AstNode::Variable(val) => match val {
-                Atom::Variable(s) => Some(s.as_str()),
-                _ => None,
-            },
+            AstNode::Variable(Atom::Variable(s)) => Some(s.as_str()),
+            AstNode::Constant(Atom::String(s)) => Some(s.as_str()),
+            AstNode::Constant(Atom::Variable(s)) => Some(s.as_str()),
             _ => None,
         }
     }

src/eval.rs

@@ -16,21 +16,20 @@ pub fn eval<'a>(expr: &AstNode, context: &HashMap<&str, Atom>) -> Result<bool, &
             .unwrap();
 
             if let Some(c_val) = context_val {
-                dbg!(c_val, val_content);
-                let res = match op {
+                match op {
                     ComparisonOp::More => c_val > val_content,
                     ComparisonOp::MoreEq => c_val >= val_content,
-                    _ => false,
-                };
-                dbg!(context_val);
-                res
+                    ComparisonOp::Less => c_val < val_content,
+                    ComparisonOp::LessEq => c_val <= val_content,
+                    ComparisonOp::Eq => c_val == val_content,
+                    ComparisonOp::NotEq => c_val != val_content,
+                }
             } else {
                 false
             }
         }
         _ => false,
     };
-    dbg!(expr);
     Ok(result)
 }
 
@@ -45,9 +44,22 @@ mod tests {
             ("a", Atom::Number(3)),
             ("b", Atom::String("demo".to_string())),
         ]);
-        let (i, expr) = parse("a < 4 ").unwrap();
 
-        let res = eval(&expr, &context).unwrap();
-        assert_eq!(res, false);
+        assert_eq!(eval(&parse("a < 4").unwrap().1, &context).unwrap(), true);
+        assert_eq!(eval(&parse("a < 3.3").unwrap().1, &context).unwrap(), true);
+        assert_eq!(
+            eval(
+                &parse("a < 3.1415").unwrap().1,
+                &HashMap::from([("a", Atom::Float(3.0))])
+            )
+            .unwrap(),
+            true
+        );
+        assert_eq!(eval(&parse("a>4").unwrap().1, &context).unwrap(), false);
+        assert_eq!(eval(&parse("a<=4").unwrap().1, &context).unwrap(), true);
+        assert_eq!(eval(&parse("a>=3").unwrap().1, &context).unwrap(), true);
+        assert_eq!(eval(&parse("a!=4").unwrap().1, &context).unwrap(), true);
+        assert_eq!(eval(&parse("a==4").unwrap().1, &context).unwrap(), false);
+        assert_eq!(eval(&parse("a==3").unwrap().1, &context).unwrap(), true);
     }
 }