Merge pull request #3 from derickandrade/update_open

Adjust <open> to new metaStmt structure

Author: derickandrade

src/parser/keywords.rs

@@ -23,4 +23,5 @@ pub const KEYWORDS: &[&str] = &[
     "False",
     "print",
     "input",
+    "open",
 ];

src/stdlib/standard_library.rs

@@ -2,6 +2,9 @@ use crate::environment::environment::Environment;
 use crate::ir::ast::{Statement, Expression};
 use std::collections::HashMap;
 use std::sync::OnceLock;
+use std::fs::File;
+use std::io::Read;
+use std::io::Write;
 
 pub type MetaBuiltinStmt = fn(&mut Environment<Expression>) -> Statement;
 
@@ -13,6 +16,7 @@ pub fn get_metabuiltins_table() -> &'static HashMap<String, MetaBuiltinStmt> {
         let mut table = HashMap::new();
         table.insert("input".to_string(), input_builtin as MetaBuiltinStmt);
         table.insert("print".to_string(), print_builtin as MetaBuiltinStmt);
+        table.insert("open".to_string(), open_builtin as MetaBuiltinStmt);
         table
     })
 }
@@ -44,6 +48,88 @@ pub fn print_builtin(env: &mut Environment<Expression>) -> Statement {
     Statement::Return(Box::new(Expression::CVoid))
 }
 
+pub fn open_builtin(env: &mut Environment<Expression>) -> Statement{
+    let path = match env.lookup(&"path".to_string()) {
+        Some((_, Expression::CString(p))) => p.clone(),
+        _ => {
+            return Statement::Return(Box::new(Expression::CString(
+                "open: first argument must be a string with the file path".to_string())));
+        }
+    };
+
+    let mode = match env.lookup(&"mode".to_string()) {
+        Some((_, Expression::CString(m))) => m.clone(),
+        _ => "r".to_string(), 
+    };
+
+    match mode.as_str() {
+        "r" => {
+            let mut file = match File::open(&path) {
+                Ok(f) => f,
+                Err(e) => {
+                    return Statement::Return(Box::new(Expression::CString(
+                        format!("open: could not open '{}' for reading: {}", path, e))));
+                }
+            };
+            let mut contents = String::new();
+            if let Err(e) = file.read_to_string(&mut contents) {
+                return Statement::Return(Box::new(Expression::CString(
+                    format!("open: error reading '{}': {}", path, e))));
+            }
+
+            Statement::Return(Box::new(Expression::CString(contents)))
+        }
+
+        "w" => {
+            let content = match env.lookup(&"content".to_string()) {
+                Some((_, Expression::CString(c))) => c.clone(),
+                _ => {
+                    return Statement::Return(Box::new(Expression::CString(
+                        "open: when using mode 'w', a third argument with the content to write is required".to_string())));
+                }
+            };
+
+            match std::fs::write(&path, content) {
+                Ok(_) => Statement::Return(Box::new(Expression::CVoid)),
+                Err(e) => Statement::Return(Box::new(Expression::CString(
+                    format!("open: could not write to '{}': {}", path, e)))),
+            }
+        }
+        
+        "a" => {
+            let content = match env.lookup(&"content".to_string()) {
+                Some((_, Expression::CString(c))) => c.clone(),
+                _ => {
+                    return Statement::Return(Box::new(Expression::CString(
+                        "open: when using mode 'a', a third argument with the content to append is required".to_string())));
+                }
+            };
+
+            match std::fs::OpenOptions::new()
+                .append(true)
+                .create(true)
+                .open(&path) {
+                Ok(mut file) => {
+                    if let Err(e) = writeln!(file, "{}", content) {
+                        return Statement::Return(Box::new(Expression::CString(
+                            format!("open: could not append to '{}': {}", path, e))));
+                    }
+                    Statement::Return(Box::new(Expression::CVoid))
+                },
+                Err(e) => Statement::Return(Box::new(Expression::CString(
+                    format!("open: could not open '{}' for appending: {}", path, e)))),
+            }
+            
+        }
+
+        m => {
+            Statement::Return(Box::new(Expression::CString(
+                format!("open: unsupported mode '{}'.", m))))
+        }
+    }
+
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -80,7 +166,7 @@ mod tests {
     #[test]
     fn test_meta_stmt_table_has_correct_size() {
         let table = get_metabuiltins_table();
-        assert_eq!(table.len(), 2, "The table must contain exactly 2 functions");
+        assert_eq!(table.len(), 3, "The table must contain exactly 3 functions");
     }
 
     #[test]
@@ -90,7 +176,8 @@ mod tests {
 
         assert!(keys.contains(&&"input".to_string()), "The table must contain the key 'input'");
         assert!(keys.contains(&&"print".to_string()), "The table must contain the key 'print'");
-        assert_eq!(keys.len(), 2, "The table must contain only 2 keys");
+        assert!(keys.contains(&&"open".to_string()), "The table must contain the key 'open'");
+        assert_eq!(keys.len(), 3, "The table must contain only 3 keys");
     }
 
     #[test]
@@ -133,4 +220,31 @@ mod tests {
             panic!("The 'print' function must be in the table");
         }
     }
+
+    #[test]
+    fn test_open_builtin_read_mode_success() {
+        use std::fs;
+        let test_file_path = "test_read_file.txt";
+        let test_content = "Hello, World!\nThis is a test file.";
+        fs::write(test_file_path, test_content).unwrap();
+
+        let mut env: Environment<Expression> = Environment::new();
+        env.map_variable("path".to_string(), false, Expression::CString(test_file_path.to_string()));
+        env.map_variable("mode".to_string(), false, Expression::CString("r".to_string()));
+
+        let result = open_builtin(&mut env);
+        
+        match result {
+            Statement::Return(expr) => {
+                if let Expression::CString(content) = *expr {
+                    assert_eq!(content, test_content, "File content should match");
+                } else {
+                    panic!("Expected CString with file content");
+                }
+            }
+            _ => panic!("Expected Statement::Return"),
+        }
+
+        fs::remove_file(test_file_path).unwrap();
+    }
 }