Add fs.write

CHANGELOG.md

@@ -10,6 +10,7 @@
 * Add `abi.decodeData` to decode function calldata and errors from any known ABI
 * Add `address.transfer` to send ETH to an address
 * Add `json.stringify` to convert a value to a JSON string
+* Add `fs.write` to write a string to a file
 
 ### Other changes
 

src/interpreter/builtins/fs.rs

@@ -0,0 +1,30 @@
+use std::sync::Arc;
+
+use anyhow::{anyhow, Result};
+use lazy_static::lazy_static;
+
+use crate::interpreter::{
+    functions::{FunctionDef, FunctionParam, SyncMethod},
+    Env, Type, Value,
+};
+
+fn write(_env: &mut Env, _receiver: &Value, args: &[Value]) -> Result<Value> {
+    let filepath = args
+        .first()
+        .ok_or(anyhow!("missing filepath"))?
+        .as_string()?;
+    let value = args.get(1).ok_or(anyhow!("missing value"))?.as_string()?;
+    std::fs::write(filepath, value)?;
+    Ok(Value::Null)
+}
+
+lazy_static! {
+    pub static ref FS_WRITE: Arc<dyn FunctionDef> = SyncMethod::arc(
+        "write",
+        write,
+        vec![vec![
+            FunctionParam::new("filepath", Type::String),
+            FunctionParam::new("content", Type::String)
+        ]]
+    );
+}

src/interpreter/builtins/mod.rs

@@ -12,6 +12,7 @@ mod console;
 mod event;
 mod events;
 mod format;
+mod fs;
 mod iterable;
 mod json;
 mod misc;
@@ -32,6 +33,7 @@ lazy_static! {
         m.insert("repl".to_string(), Value::TypeObject(Type::Repl));
         m.insert("console".to_string(), Value::TypeObject(Type::Console));
         m.insert("json".to_string(), Value::TypeObject(Type::Json));
+        m.insert("fs".to_string(), Value::TypeObject(Type::Fs));
         m.insert("block".to_string(), Value::TypeObject(Type::Block));
         m.insert("events".to_string(), Value::TypeObject(Type::Events));
         m.insert(
@@ -145,6 +147,10 @@ lazy_static! {
         json_methods.insert("stringify".to_string(), json::JSON_STRINGIFY.clone());
         m.insert(NonParametricType::Json, json_methods);
 
+        let mut fs_methods = HashMap::new();
+        fs_methods.insert("write".to_string(), fs::FS_WRITE.clone());
+        m.insert(NonParametricType::Fs, fs_methods);
+
         let mut event_methods = HashMap::new();
         event_methods.insert("selector".to_string(), event::EVENT_SELECTOR.clone());
         m.insert(NonParametricType::Event, event_methods);

src/interpreter/types.rs

@@ -139,6 +139,7 @@ pub enum NonParametricType {
     Repl,
     Block,
     Console,
+    Fs,
     Json,
     Events,
     Abi,
@@ -168,6 +169,7 @@ pub enum Type {
     Repl,
     Block,
     Console,
+    Fs,
     Json,
     Events,
     Abi,
@@ -208,6 +210,7 @@ impl Display for Type {
             Type::Events => write!(f, "events"),
             Type::Console => write!(f, "console"),
             Type::Json => write!(f, "json"),
+            Type::Fs => write!(f, "fs"),
             Type::Abi => write!(f, "abi"),
             Type::Type(t) => write!(f, "type({})", t),
         }
@@ -238,6 +241,7 @@ impl<T: AsRef<Type>> From<T> for NonParametricType {
             Type::Repl => NonParametricType::Repl,
             Type::Block => NonParametricType::Block,
             Type::Console => NonParametricType::Console,
+            Type::Fs => NonParametricType::Fs,
             Type::Json => NonParametricType::Json,
             Type::Events => NonParametricType::Events,
             Type::Abi => NonParametricType::Abi,