Initial support for format() function

Author: SteveL-MSFT

dsc/Cargo.lock

@@ -16,10 +16,11 @@ chrono = "0.4"
 clap = { version = "4.5", features = ["derive"] }
 derive_builder ="0.20"
 indicatif = "0.17"
-jsonschema = { version = "0.29", default-features = false }
+jsonschema = { version = "0.30", default-features = false }
 linked-hash-map = "0.5"
 num-traits = "0.2"
 regex = "1.11"
+rt-format = "0.3"
 rust-i18n = { version = "3.1" }
 # reqwest = { version = "0.12.8", features = ["native-tls"], default-features = false }
 schemars = { version = "0.8", features = ["preserve_order"] }
@@ -29,13 +30,13 @@ serde_yaml = { version = "0.9" }
 thiserror = "2.0"
 security_context_lib = { path = "../security_context_lib" }
 semver = "1.0"
-tokio = { version = "1.43", features = ["full"] }
+tokio = { version = "1.44", features = ["full"] }
 tracing = "0.1"
 tracing-indicatif = { version = "0.3" }
 tree-sitter = "0.25"
 tree-sitter-rust = "0.24"
 tree-sitter-dscexpression = { path = "../tree-sitter-dscexpression" }
-uuid = { version = "1.15", features = ["v4"] }
+uuid = { version = "1.16", features = ["v4"] }
 which = "7.0"
 
 [dev-dependencies]

dsc_lib/Cargo.lock

@@ -0,0 +1,158 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use crate::DscError;
+use crate::configure::context::Context;
+use crate::functions::{AcceptedArgKind, Function};
+use rt_format::{Format, FormatArgument, ParsedFormat, Specifier};
+use rust_i18n::t;
+use serde_json::Value;
+use std::fmt::{Error, Formatter, Write};
+
+impl FormatArgument for Value {
+    fn supports_format(&self, spec: &Specifier) -> bool {
+        match self {
+            Value::Boolean(_) | Value::String(_) | Value::Number(_) => true,
+            _ => false,
+        }
+    }
+
+    fn fmt_display(&self, f: &mut Formatter) -> std::fmt::Result {
+        match self {
+            Value::Boolean(b) => write!(f, "{}", b),
+            Value::String(s) => write!(f, "{}", s),
+            Value::Number(n) => write!(f, "{}", n),
+            _ => Err(fmt::Error),
+        }
+    }
+
+    fn fmt_lower_hex(&self, f: &mut Formatter) -> std::fmt::Result {
+        match self {
+            Value::Number(n) => write!(f, "{:x}", n.as_i64().unwrap_or_default()),
+            _ => Err(fmt::Error),
+        }
+    }
+
+    fn fmt_upper_hex(&self, f: &mut Formatter) -> std::fmt::Result {
+        match self {
+            Value::Number(n) => write!(f, "{:X}", n.as_i64().unwrap_or_default()),
+            _ => Err(fmt::Error),
+        }
+    }
+
+    fn fmt_binary(&self, f: &mut Formatter) -> std::fmt::Result {
+        match self {
+            Value::Number(n) => write!(f, "{:b}", n.as_i64().unwrap_or_default()),
+            _ => Err(fmt::Error),
+        }
+    }
+
+    fn fmt_octal(&self, f: &mut Formatter) -> std::fmt::Result {
+        match self {
+            Value::Number(n) => write!(f, "{:o}", n.as_i64().unwrap_or_default()),
+            _ => Err(fmt::Error),
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct Format {}
+
+impl Function for Format {
+    fn min_args(&self) -> usize {
+        2
+    }
+
+    fn max_args(&self) -> usize {
+        usize::MAX
+    }
+
+    fn accepted_arg_types(&self) -> Vec<AcceptedArgKind> {
+        vec![AcceptedArgKind::Boolean, AcceptedArgKind::String, AcceptedArgKind::Number]
+    }
+
+    fn invoke(&self, args: &[Value], _context: &Context) -> Result<Value, DscError> {
+        let mut string_result = String::new();
+        let Ok(format_string) = args[0].as_str() else {
+            return Err(DscError::Parser("First `format()` argument must be a string".to_string()));
+        };
+        for value in &args[1..] {
+            if let Some(parsed_format) = ParsedFormat::parse(format_string) {
+                let mut formatted_string = String::new();
+                for specifier in parsed_format.specifiers() {
+                    if let Some(arg) = args.get(specifier.index()) {
+                        formatted_string.push_str(&arg.to_string());
+                    } else {
+                        return Err(DscError::Parser("Invalid format specifier".to_string()));
+                    }
+                }
+                string_result.push_str(&formatted_string);
+            } else {
+                return Err(DscError::Parser("Invalid format string".to_string()));
+            }
+        }
+        Ok(Value::String(string_result))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::configure::context::Context;
+    use crate::parser::Statement;
+
+    #[test]
+    fn position() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[format('{0} - {1}', 'hello', 2)]", &Context::new()).unwrap();
+        assert_eq!(result, "hello - 2");
+    }
+
+    #[test]
+    fn strings_with_spaces() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[concat('a ', ' ', ' b')]", &Context::new()).unwrap();
+        assert_eq!(result, "a   b");
+    }
+
+    #[test]
+    fn arrays() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[concat(createArray('a','b'), createArray('c','d'))]", &Context::new()).unwrap();
+        assert_eq!(result.to_string(), r#"["a","b","c","d"]"#);
+    }
+
+    #[test]
+    fn string_and_numbers() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[concat('a', 1)]", &Context::new());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn nested() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[concat('a', concat('b', 'c'), 'd')]", &Context::new()).unwrap();
+        assert_eq!(result, "abcd");
+    }
+
+    #[test]
+    fn invalid_one_parameter() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[concat('a')]", &Context::new());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn string_and_array() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[concat('a', createArray('b','c'))]", &Context::new());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn array_and_string() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[concat(createArray('a','b'), 'c')]", &Context::new());
+        assert!(result.is_err());
+    }
+}

dsc_lib/Cargo.toml

@@ -16,6 +16,7 @@ pub mod div;
 pub mod envvar;
 pub mod equals;
 pub mod r#if;
+pub mod format;
 pub mod int;
 pub mod max;
 pub mod min;
@@ -77,6 +78,7 @@ impl FunctionDispatcher {
         functions.insert("envvar".to_string(), Box::new(envvar::Envvar{}));
         functions.insert("equals".to_string(), Box::new(equals::Equals{}));
         functions.insert("if".to_string(), Box::new(r#if::If{}));
+        functions.insert("format".to_string(), Box::new(format::Format{}));
         functions.insert("int".to_string(), Box::new(int::Int{}));
         functions.insert("max".to_string(), Box::new(max::Max{}));
         functions.insert("min".to_string(), Box::new(min::Min{}));