feat: support additional functions

Cargo.toml

@@ -26,6 +26,7 @@ serde_json = "1.0.117"
 rand = "0.8.5"
 regex = "1.11.1"
 num-format = "0.4.4"
+uuid = { version = "1.8.0", features = ["fast-rng", "v4", "v7"] }
 
 [dev-dependencies]
 test-case = "3.3.1"

src/evaluator/functions.rs

@@ -4,6 +4,8 @@ use rand::Rng;
 use regex::Regex;
 use std::borrow::{Borrow, Cow};
 use std::collections::HashSet;
+use std::time::{SystemTime, UNIX_EPOCH};
+use uuid::Uuid;
 
 use crate::datetime::{format_custom_date, parse_custom_format, parse_timezone_offset};
 use crate::parser::expressions::check_balanced_brackets;
@@ -1060,6 +1062,36 @@ pub fn from_millis<'a>(
     ))
 }
 
+pub fn fn_millis<'a>(
+    context: FunctionContext<'a, '_>,
+    args: &[&'a Value<'a>],
+) -> Result<&'a Value<'a>> {
+    max_args!(context, args, 0);
+
+    let timestamp = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .expect("Time went backwards");
+
+    // Turning the timestamp to a string given that the stable millis function
+    // returns a u128 and the `Value::number` only supports f64.
+    Ok(Value::string(
+        context.arena,
+        timestamp.as_millis().to_string().as_str(),
+    ))
+}
+
+pub fn fn_uuid<'a>(
+    context: FunctionContext<'a, '_>,
+    args: &[&'a Value<'a>],
+) -> Result<&'a Value<'a>> {
+    max_args!(context, args, 0);
+
+    Ok(Value::string(
+        context.arena,
+        Uuid::new_v4().to_string().as_str(),
+    ))
+}
+
 pub fn to_millis<'a>(
     context: FunctionContext<'a, '_>,
     args: &[&'a Value<'a>],

src/evaluator/value.rs

@@ -37,7 +37,9 @@ pub const UNDEFINED: Value = Value::Undefined;
 pub const TRUE: Value = Value::Bool(true);
 pub const FALSE: Value = Value::Bool(false);
 
-/// The core value type for input, output and evaluation. There's a lot of lifetimes here to avoid
+/// The core value type for input, output and evaluation.
+///
+/// There's a lot of lifetimes here to avoid
 /// cloning any part of the input that should be kept in the output, avoiding heap allocations for
 /// every Value, and allowing structural sharing.
 ///

src/lib.rs

@@ -53,7 +53,7 @@ impl<'a> JsonAta<'a> {
     }
 
     fn json_value_to_value(&self, json_value: &serde_json::Value) -> &'a mut Value<'a> {
-        return match json_value {
+        match json_value {
             serde_json::Value::Null => Value::null(self.arena),
             serde_json::Value::Bool(b) => self.arena.alloc(Value::Bool(*b)),
             serde_json::Value::Number(n) => Value::number(self.arena, n.as_f64().unwrap()),
@@ -65,16 +65,16 @@ impl<'a> JsonAta<'a> {
                     array.push(self.json_value_to_value(v))
                 }
 
-                return array;
+                array
             }
             serde_json::Value::Object(o) => {
                 let object = Value::object_with_capacity(self.arena, o.len());
                 for (k, v) in o.iter() {
                     object.insert(k, self.json_value_to_value(v));
                 }
-                return object;
+                object
             }
-        };
+        }
     }
 
     pub fn evaluate(
@@ -171,6 +171,8 @@ impl<'a> JsonAta<'a> {
         bind_native!("trim", 1, fn_trim);
         bind_native!("uppercase", 1, fn_uppercase);
         bind_native!("zip", 1, fn_zip);
+        bind_native!("millis", 0, fn_millis);
+        bind_native!("uuid", 0, fn_uuid);
 
         let chain_ast = Some(parser::parse(
             "function($f, $g) { function($x){ $g($f($x)) } }",
@@ -217,7 +219,7 @@ mod tests {
         let jsonata = JsonAta::new("$map([1,4,9,16], $squareroot)", &arena).unwrap();
         jsonata.register_function("squareroot", 1, |ctx, args| {
             let num = &args[0];
-            return Ok(Value::number(ctx.arena, (num.as_f64()).sqrt()));
+            Ok(Value::number(ctx.arena, (num.as_f64()).sqrt()))
         });
 
         let result = jsonata.evaluate(Some(r#"anything"#), None);
@@ -238,7 +240,7 @@ mod tests {
         let jsonata = JsonAta::new("$filter([1,4,9,16], $even)", &arena).unwrap();
         jsonata.register_function("even", 1, |_ctx, args| {
             let num = &args[0];
-            return Ok(Value::bool((num.as_f64()) % 2.0 == 0.0));
+            Ok(Value::bool((num.as_f64()) % 2.0 == 0.0))
         });
 
         let result = jsonata.evaluate(Some(r#"anything"#), None);

tests/testsuite.rs

@@ -3,6 +3,7 @@ extern crate test_generator;
 
 use bumpalo::Bump;
 use jsonata_rs::{ArrayFlags, JsonAta, Value};
+use regex::Regex;
 use std::fs;
 use std::path;
 
@@ -104,12 +105,23 @@ fn test_case(resource: &str) {
                                 }
                                 assert!(found);
                             }
+                        } else if case["result_re"].is_string() {
+                            // Ability to define a regular expression to match the result. This strategy is useful
+                            // to validate the result of an expression that's not deterministic (like the $millis() function).
+                            let regex_pattern = Regex::new(case["result_re"].as_str().as_ref())
+                                .expect("Should have a valid regex expression");
+
+                            assert!(
+                                regex_pattern.is_match(&result.as_str()),
+                                "Value: {result:?}, did not match expected result_re",
+                            );
                         } else {
+                            eprintln!("RESULT: {}", result);
                             assert_eq!(result, expected_result);
                         }
                     }
                     Err(error) => {
-                        eprintln!("{}", error);
+                        eprintln!("ERROR: {}", error);
                         let code = if !case["error"].is_undefined() {
                             &case["error"]["code"]
                         } else {

tests/testsuite/groups/function-millis/case000.json

@@ -0,0 +1,6 @@
+{
+    "expr": "$millis()",
+    "dataset": null,
+    "bindings": {},
+    "result_re": "(\\d+)"
+}

tests/testsuite/groups/function-millis/case001.json

@@ -0,0 +1,6 @@
+{
+    "expr": "$millis() & \"-SUFFIX\"",
+    "dataset": null,
+    "bindings": {},
+    "result_re": "(\\d+)-SUFFIX"
+}

tests/testsuite/groups/function-uuid/case000.json

@@ -0,0 +1,6 @@
+{
+    "expr": "$uuid()",
+    "dataset": null,
+    "bindings": {},
+    "result_re": "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$"
+}