From 459acb2d63e9554c3760552516b95ca04e36eacb Mon Sep 17 00:00:00 2001
From: Jeff <dev@jeffa.io>
Date: Fri, 1 Mar 2024 19:15:03 -0500
Subject: [PATCH] Pass assignment test

---
 src/abstract_tree/assignment.rs | 37 +++++++++++++++++----------------
 src/abstract_tree/identifier.rs |  4 ++++
 src/abstract_tree/statement.rs  |  2 +-
 src/abstract_tree/value_node.rs |  8 ++++++-
 src/value.rs                    | 10 +++++++++
 5 files changed, 41 insertions(+), 20 deletions(-)

diff --git a/src/abstract_tree/assignment.rs b/src/abstract_tree/assignment.rs
index a6ce593..ba36c5d 100644
--- a/src/abstract_tree/assignment.rs
+++ b/src/abstract_tree/assignment.rs
@@ -32,35 +32,36 @@ impl<'src> AbstractTree for Assignment<'src> {
         todo!()
     }
 
-    fn run(self, _context: &Context) -> Result<Value, RuntimeError> {
-        todo!()
-        // let value = self.statement.run(context)?;
+    fn run(self, context: &Context) -> Result<Value, RuntimeError> {
+        let value = self.statement.run(context)?;
 
-        // context.set(self.identifier, value)?;
+        context.set(self.identifier, value)?;
 
-        // Ok(Value::none())
+        Ok(Value::none())
     }
 }
 
 #[cfg(test)]
 mod tests {
-    // use super::*;
+    use crate::abstract_tree::{Expression, ValueNode};
+
+    use super::*;
 
     #[test]
     fn assign_value() {
-        todo!()
-        // let context = Context::new();
+        let context = Context::new();
 
-        // Assignment::new(
-        //     Identifier::new("foobar"),
-        //     Statement::Value(Value::integer(42)),
-        // )
-        // .run(&context)
-        // .unwrap();
+        Assignment::new(
+            Identifier::new("foobar"),
+            None,
+            Statement::Expression(Expression::Value(ValueNode::Integer(42))),
+        )
+        .run(&context)
+        .unwrap();
 
-        // assert_eq!(
-        //     context.get(&Identifier::new("foobar")).unwrap(),
-        //     Some(Value::integer(42))
-        // )
+        assert_eq!(
+            context.get(&Identifier::new("foobar")),
+            Ok(Some(Value::integer(42)))
+        )
     }
 }
diff --git a/src/abstract_tree/identifier.rs b/src/abstract_tree/identifier.rs
index fd45f60..22f128d 100644
--- a/src/abstract_tree/identifier.rs
+++ b/src/abstract_tree/identifier.rs
@@ -15,6 +15,10 @@ impl Identifier {
     pub fn new<T: ToString>(string: T) -> Self {
         Identifier(Arc::new(string.to_string()))
     }
+
+    pub fn as_str(&self) -> &str {
+        self.0.as_str()
+    }
 }
 
 impl AbstractTree for Identifier {
diff --git a/src/abstract_tree/statement.rs b/src/abstract_tree/statement.rs
index 6e2311a..017cb65 100644
--- a/src/abstract_tree/statement.rs
+++ b/src/abstract_tree/statement.rs
@@ -26,7 +26,7 @@ impl<'src> AbstractTree for Statement<'src> {
         match self {
             Statement::Assignment(assignment) => assignment.run(_context),
             Statement::Block(_) => todo!(),
-            Statement::Expression(_) => todo!(),
+            Statement::Expression(expression) => expression.run(_context),
             Statement::Loop(_) => todo!(),
         }
     }
diff --git a/src/abstract_tree/value_node.rs b/src/abstract_tree/value_node.rs
index 4ef0f3a..c16a276 100644
--- a/src/abstract_tree/value_node.rs
+++ b/src/abstract_tree/value_node.rs
@@ -69,7 +69,13 @@ impl<'src> AbstractTree for ValueNode<'src> {
             }
             ValueNode::Range(range) => Value::range(range),
             ValueNode::String(string) => Value::string(string),
-            ValueNode::Enum(name, variant) => Value::r#enum(name, variant),
+            ValueNode::Enum(name, variant) => {
+                if name.as_str() == "Option" && variant.as_str() == "None" {
+                    Value::none()
+                } else {
+                    Value::r#enum(name, variant)
+                }
+            }
         };
 
         Ok(value)
diff --git a/src/value.rs b/src/value.rs
index f78d8f7..75e70c7 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -17,6 +17,16 @@ impl Value {
         &self.0
     }
 
+    pub fn none() -> Self {
+        NONE.get_or_init(|| {
+            Value(Arc::new(ValueInner::Enum(
+                Identifier::new("Option"),
+                Identifier::new("None"),
+            )))
+        })
+        .clone()
+    }
+
     pub fn boolean(boolean: bool) -> Self {
         Value(Arc::new(ValueInner::Boolean(boolean)))
     }