Add base64 encode/decode builtins

Author: kyleect

Cargo.lock

@@ -28,3 +28,4 @@ thiserror = "2"
 once_cell = "1.21.3"
 codespan-reporting = "0.12.0"
 line-col = "0.2.1"
+base64 = "0.22.1"

Cargo.toml

@@ -83,6 +83,8 @@ See [/spec](./spec/) for more syntax examples.
 | `type(value: Value) -> Type`                              | Get the string representation of a value's type |
 | `eq(a: Value, b: Value) -> Bool`                          | Compare two values for equality                 |
 | `not(value: Bool) -> Bool`                                | Logical NOT operation on a boolean value        |
+| `base64encode(value: String) -> String`                   | Base64 encode a string value                    |
+| `base64decode(value: String) -> String`                   | Base64 decode a string value                    |
 
 ### Why Backticks For Strings?
 

README.md

@@ -0,0 +1 @@
+(b64decode `SGVsbG8=`)

spec/valid/call_b64decode.expr

@@ -0,0 +1 @@
+`Hello`

spec/valid/call_b64decode.expr.interpreted

@@ -0,0 +1 @@
+(b64encode `Hello`)

spec/valid/call_b64encode.expr

@@ -0,0 +1 @@
+`SGVsbG8=`

spec/valid/call_b64encode.expr.interpreted

@@ -63,7 +63,7 @@ impl<'a> BuiltinFn<'a> {
     /// The default set of builtin functions
     ///
     /// This also defines the lookup index for builtins during compilation
-    pub const DEFAULT_BUILTINS: [BuiltinFn<'a>; 17] = [
+    pub const DEFAULT_BUILTINS: [BuiltinFn<'a>; 19] = [
         BuiltinFn::ID,
         BuiltinFn::NOOP,
         BuiltinFn::IS_EMPTY,
@@ -81,6 +81,8 @@ impl<'a> BuiltinFn<'a> {
         BuiltinFn::TYPE,
         BuiltinFn::EQ,
         BuiltinFn::NOT,
+        BuiltinFn::BASE64_ENCODE,
+        BuiltinFn::BASE64_DECODE,
     ];
 
     // Builtin Definitions
@@ -546,6 +548,62 @@ impl<'a> BuiltinFn<'a> {
 
         Ok(Value::Bool(!value))
     }
+
+    /// Return a base64 encoded the [`Value`] passed in
+    ///
+    /// `(base64_encode ?string_prompt)`
+    pub const BASE64_ENCODE: BuiltinFn<'static> = BuiltinFn {
+        name: "b64encode",
+        args: &[FnArg {
+            name: "value",
+            ty: Type::Value,
+            variadic: false,
+        }],
+        return_type: Type::Value,
+        func: Self::base64_encode,
+    };
+
+    fn base64_encode(args: Vec<Value>) -> ExprResult<Value> {
+        let string_arg = args
+            .first()
+            .expect("should have string expression passed")
+            .get_string()?;
+
+        use base64::prelude::*;
+
+        let encoded = BASE64_STANDARD.encode(string_arg);
+
+        Ok(Value::String(encoded))
+    }
+
+    /// Return a base64 decoded of the [`Value`] passed in
+    ///
+    /// `(base64_encode ?string_prompt)`
+    pub const BASE64_DECODE: BuiltinFn<'static> = BuiltinFn {
+        name: "b64decode",
+        args: &[FnArg {
+            name: "value",
+            ty: Type::Value,
+            variadic: false,
+        }],
+        return_type: Type::Value,
+        func: Self::base64_decode,
+    };
+
+    fn base64_decode(args: Vec<Value>) -> ExprResult<Value> {
+        let string_arg = args
+            .first()
+            .expect("should have string expression passed")
+            .get_string()?;
+
+        use base64::prelude::*;
+
+        let decoded = BASE64_STANDARD
+            .decode(string_arg)
+            .expect("unable to decode");
+
+        Ok(Value::String(String::from_utf8(decoded).unwrap()))
+    }
 }
 
 impl<'a> PartialEq for BuiltinFn<'a> {

src/builtins.rs

@@ -36,7 +36,8 @@ fn spec_files_disassembled(#[files("spec/**/*.expr")] path: PathBuf) -> ExprResu
         let (args, expected_disassembled) = if let Some((i, _)) = expected_disassembled
             .lines()
             .next()
-            .filter(|line| line.starts_with("//")).map(|line| (line.len() + 1, line))
+            .filter(|line| line.starts_with("//"))
+            .map(|line| (line.len() + 1, line))
         {
             expected_disassembled.split_at(i)
         } else {
@@ -96,7 +97,8 @@ fn spec_files_interpreted(#[files("spec/**/*.expr")] path: PathBuf) -> ExprResul
         let (args, expected_interpreted) = if let Some((i, _)) = expected_interpreted
             .lines()
             .next()
-            .filter(|line| line.starts_with("//")).map(|line| (line.len() + 1, line))
+            .filter(|line| line.starts_with("//"))
+            .map(|line| (line.len() + 1, line))
         {
             expected_interpreted.split_at(i)
         } else {