eval work in progress

src/ast.rs

@@ -3,7 +3,7 @@ use core::fmt;
 use chrono::NaiveDate;
 
 /// TODO: add date and datetime as its common
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, PartialOrd)]
 pub enum Atom {
     String(String),
     Number(i64),
@@ -104,3 +104,15 @@ pub enum AstNode {
     Logic(Box<AstNode>, LogicOp, Box<AstNode>),
     Scope { expr: Box<AstNode>, negate: bool },
 }
+
+impl AstNode {
+    pub fn as_str(&self) -> Option<&str> {
+        match self {
+            AstNode::Variable(val) => match val {
+                Atom::Variable(s) => Some(s.as_str()),
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+}

src/eval.rs

@@ -1,5 +1,53 @@
 use std::collections::HashMap;
 
-use crate::ast::AstNode;
+use crate::ast::{AstNode, Atom, ComparisonOp};
 
-pub fn eval(expr: AstNode, context: HashMap<&str, &str>) {}
+pub fn eval<'a>(expr: &AstNode, context: &HashMap<&str, Atom>) -> Result<bool, &'a str> {
+    let mut result = false;
+    result = match expr {
+        AstNode::Compare(var, op, val) => {
+            // check var in context
+            // compare with val
+            let context_val = context.get(var.as_str().unwrap());
+            let val_content = match val.as_ref() {
+                AstNode::Constant(a) => Some(a),
+                _ => None,
+            }
+            .unwrap();
+
+            if let Some(c_val) = context_val {
+                dbg!(c_val, val_content);
+                let res = match op {
+                    ComparisonOp::More => c_val > val_content,
+                    ComparisonOp::MoreEq => c_val >= val_content,
+                    _ => false,
+                };
+                dbg!(context_val);
+                res
+            } else {
+                false
+            }
+        }
+        _ => false,
+    };
+    dbg!(expr);
+    Ok(result)
+}
+
+mod tests {
+    use crate::{ast::Atom, parse::parse};
+
+    use super::*;
+
+    #[test]
+    fn test_basic_eval() {
+        let context = HashMap::from([
+            ("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);
+    }
+}

src/parse.rs

@@ -380,6 +380,5 @@ mod tests {
         and demo == false) and ((a=2) and not (c=3))"###;
         let (i, v) = parse(expression).unwrap();
         assert_eq!(i, "");
-        dbg!(v);
     }
 }