Merge branch 'PowerShell:main' into reference-doc-compare-and-object

Author: Gijsreyn

build.ps1

@@ -24,6 +24,8 @@ param(
 )
 
 $env:RUSTC_LOG=$null
+$env:RUSTFLAGS='-Dwarnings'
+
 if ($Verbose) {
     $env:RUSTC_LOG='rustc_codegen_ssa::back::link=info'
 }
@@ -567,7 +569,11 @@ if ($Test) {
         (Get-Module -Name Pester -ListAvailable).Path
     }
 
-    Invoke-Pester -ErrorAction Stop
+    try {
+        Invoke-Pester -ErrorAction Stop
+    } catch {
+        throw "Pester had unexpected error: $($_.Exception.Message)"
+    }
 }
 
 function Find-MakeAppx() {

dsc/tests/dsc_expressions.tests.ps1

@@ -222,6 +222,10 @@ description = "Encodes a string to Base64 format"
 description = "Converts a string or number to a boolean"
 invoked = "bool function"
 
+[functions.coalesce]
+description = "Returns the first non-null value from a list of arguments"
+invoked = "coalesce function"
+
 [functions.concat]
 description = "Concatenates two or more strings or arrays"
 invoked = "concat function"
@@ -237,6 +241,12 @@ argsMustAllBeIntegers = "Arguments must all be integers"
 argsMustAllBeObjects = "Arguments must all be objects"
 argsMustAllBeStrings = "Arguments must all be strings"
 
+[functions.createObject]
+description = "Creates an object from the given key-value pairs"
+invoked = "createObject function"
+argsMustBePairs = "Arguments must be provided in key-value pairs"
+keyMustBeString = "Object keys must be strings"
+
 [functions.div]
 description = "Divides the first number by the second"
 invoked = "div function"
@@ -313,6 +323,10 @@ invoked = "mul function"
 description = "Negates a boolean value"
 invoked = "not function"
 
+[functions.null]
+description = "Returns a null value"
+invoked = "null function"
+
 [functions.or]
 description = "Evaluates if any arguments are true"
 invoked = "or function"

dsc_lib/locales/en-us.toml

@@ -0,0 +1,154 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use crate::DscError;
+use crate::configure::context::Context;
+use crate::functions::{AcceptedArgKind, Function, FunctionCategory};
+use rust_i18n::t;
+use serde_json::Value;
+use tracing::debug;
+
+#[derive(Debug, Default)]
+pub struct Coalesce {}
+
+impl Function for Coalesce {
+    fn description(&self) -> String {
+        t!("functions.coalesce.description").to_string()
+    }
+
+    fn category(&self) -> FunctionCategory {
+        FunctionCategory::Comparison
+    }
+
+    fn min_args(&self) -> usize {
+        1
+    }
+
+    fn max_args(&self) -> usize {
+        usize::MAX
+    }
+
+    fn accepted_arg_types(&self) -> Vec<AcceptedArgKind> {
+        vec![
+            AcceptedArgKind::Array,
+            AcceptedArgKind::Boolean,
+            AcceptedArgKind::Number,
+            AcceptedArgKind::Object,
+            AcceptedArgKind::String,
+        ]
+    }
+
+    fn invoke(&self, args: &[Value], _context: &Context) -> Result<Value, DscError> {
+        debug!("{}", t!("functions.coalesce.invoked"));
+
+        for arg in args {
+            if !arg.is_null() {
+                return Ok(arg.clone());
+            }
+        }
+
+        Ok(Value::Null)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::configure::context::Context;
+    use crate::parser::Statement;
+    use super::*;
+
+    #[test]
+    fn direct_function_call_with_nulls() {
+        let coalesce = Coalesce {};
+        let context = Context::new();
+        
+        let args = vec![Value::Null, Value::Null, Value::String("hello".to_string())];
+        let result = coalesce.invoke(&args, &context).unwrap();
+        assert_eq!(result, Value::String("hello".to_string()));
+        
+        let args = vec![Value::Null, Value::Null, Value::Null];
+        let result = coalesce.invoke(&args, &context).unwrap();
+        assert_eq!(result, Value::Null);
+        
+        let args = vec![Value::String("first".to_string()), Value::String("second".to_string())];
+        let result = coalesce.invoke(&args, &context).unwrap();
+        assert_eq!(result, Value::String("first".to_string()));
+    }
+
+    #[test]
+    fn direct_function_call_mixed_types() {
+        let coalesce = Coalesce {};
+        let context = Context::new();
+        
+        let args = vec![Value::Null, serde_json::json!(42), Value::String("fallback".to_string())];
+        let result = coalesce.invoke(&args, &context).unwrap();
+        assert_eq!(result, serde_json::json!(42));
+        
+        let args = vec![Value::Null, Value::Bool(true)];
+        let result = coalesce.invoke(&args, &context).unwrap();
+        assert_eq!(result, Value::Bool(true));
+    }
+
+    #[test]
+    fn direct_function_call_with_arrays() {
+        let coalesce = Coalesce {};
+        let context = Context::new();
+        
+        let first_array = serde_json::json!(["a", "b", "c"]);
+        let second_array = serde_json::json!(["x", "y", "z"]);
+        
+        let args = vec![Value::Null, first_array.clone(), second_array];
+        let result = coalesce.invoke(&args, &context).unwrap();
+        assert_eq!(result, first_array);
+        
+        let args = vec![Value::Null, Value::Null, serde_json::json!([1, 2, 3])];
+        let result = coalesce.invoke(&args, &context).unwrap();
+        assert_eq!(result, serde_json::json!([1, 2, 3]));
+    }
+
+    #[test]
+    fn direct_function_call_with_objects() {
+        let coalesce = Coalesce {};
+        let context = Context::new();
+        
+        let first_obj = serde_json::json!({"name": "test", "value": 42});
+        let second_obj = serde_json::json!({"name": "fallback", "value": 0});
+        
+        let args = vec![Value::Null, first_obj.clone(), second_obj];
+        let result = coalesce.invoke(&args, &context).unwrap();
+        assert_eq!(result, first_obj);
+        
+        let args = vec![Value::Null, Value::Null, serde_json::json!({"key": "value"})];
+        let result = coalesce.invoke(&args, &context).unwrap();
+        assert_eq!(result, serde_json::json!({"key": "value"}));
+    }
+
+    #[test]
+    fn direct_function_call_with_empty_collections() {
+        let coalesce = Coalesce {};
+        let context = Context::new();
+        
+        let empty_array = serde_json::json!([]);
+        let args = vec![Value::Null, empty_array.clone(), Value::String("fallback".to_string())];
+        let result = coalesce.invoke(&args, &context).unwrap();
+        assert_eq!(result, empty_array);
+        
+        let empty_obj = serde_json::json!({});
+        let args = vec![Value::Null, empty_obj.clone(), Value::String("fallback".to_string())];
+        let result = coalesce.invoke(&args, &context).unwrap();
+        assert_eq!(result, empty_obj);
+    }
+
+    #[test]
+    fn parser_with_values() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[coalesce('hello', 'world')]", &Context::new()).unwrap();
+        assert_eq!(result, "hello");
+        
+        let result = parser.parse_and_execute("[coalesce(42, 'fallback')]", &Context::new()).unwrap();
+        assert_eq!(result, 42);
+        
+        let result = parser.parse_and_execute("[coalesce(true)]", &Context::new()).unwrap();
+        assert_eq!(result, true);
+    }
+}

dsc_lib/src/functions/coalesce.rs

@@ -0,0 +1,130 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use crate::DscError;
+use crate::configure::context::Context;
+use crate::functions::{AcceptedArgKind, Function, FunctionCategory};
+use rust_i18n::t;
+use serde_json::{Map, Value};
+use tracing::debug;
+
+#[derive(Debug, Default)]
+pub struct CreateObject {}
+
+impl Function for CreateObject {
+    fn description(&self) -> String {
+        t!("functions.createObject.description").to_string()
+    }
+
+    fn category(&self) -> FunctionCategory {
+        FunctionCategory::Object
+    }
+
+    fn min_args(&self) -> usize {
+        0
+    }
+
+    fn max_args(&self) -> usize {
+        usize::MAX
+    }
+
+    fn accepted_arg_types(&self) -> Vec<AcceptedArgKind> {
+        vec![
+            AcceptedArgKind::Array,
+            AcceptedArgKind::Boolean,
+            AcceptedArgKind::Number,
+            AcceptedArgKind::Object,
+            AcceptedArgKind::String,
+        ]
+    }
+
+    fn invoke(&self, args: &[Value], _context: &Context) -> Result<Value, DscError> {
+        debug!("{}", t!("functions.createObject.invoked"));
+        
+        if args.len() % 2 != 0 {
+            return Err(DscError::Parser(t!("functions.createObject.argsMustBePairs").to_string()));
+        }
+
+        let mut object_result = Map::<String, Value>::new();
+        
+        for chunk in args.chunks(2) {
+            let key = &chunk[0];
+            let value = &chunk[1];
+            
+            if !key.is_string() {
+                return Err(DscError::Parser(t!("functions.createObject.keyMustBeString").to_string()));
+            }
+            
+            let key_str = key.as_str().unwrap().to_string();
+            object_result.insert(key_str, value.clone());
+        }
+
+        Ok(Value::Object(object_result))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::configure::context::Context;
+    use crate::parser::Statement;
+
+    #[test]
+    fn simple_object() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[createObject('name', 'test')]", &Context::new()).unwrap();
+        assert_eq!(result.to_string(), r#"{"name":"test"}"#);
+    }
+
+    #[test]
+    fn multiple_properties() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[createObject('name', 'test', 'value', 42)]", &Context::new()).unwrap();
+        assert_eq!(result.to_string(), r#"{"name":"test","value":42}"#);
+    }
+
+    #[test]
+    fn mixed_value_types() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[createObject('string', 'hello', 'number', 123, 'boolean', true)]", &Context::new()).unwrap();
+        
+        let json: serde_json::Value = serde_json::from_str(&result.to_string()).unwrap();
+        assert_eq!(json["string"], "hello");
+        assert_eq!(json["number"], 123);
+        assert_eq!(json["boolean"], true);
+    }
+
+    #[test]
+    fn nested_objects() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[createObject('outer', createObject('inner', 'value'))]", &Context::new()).unwrap();
+        assert_eq!(result.to_string(), r#"{"outer":{"inner":"value"}}"#);
+    }
+
+    #[test]
+    fn with_arrays() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[createObject('items', createArray('a', 'b', 'c'))]", &Context::new()).unwrap();
+        assert_eq!(result.to_string(), r#"{"items":["a","b","c"]}"#);
+    }
+
+    #[test]
+    fn odd_number_of_args() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[createObject('name')]", &Context::new());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn non_string_key() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[createObject(123, 'value')]", &Context::new());
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn empty() {
+        let mut parser = Statement::new().unwrap();
+        let result = parser.parse_and_execute("[createObject()]", &Context::new()).unwrap();
+        assert_eq!(result.to_string(), "{}");
+    }
+}

dsc_lib/src/functions/create_object.rs

@@ -34,7 +34,7 @@ impl Function for Less {
 
     fn invoke(&self, args: &[Value], _context: &Context) -> Result<Value, DscError> {
         debug!("{}", t!("functions.less.invoked"));
-        
+
         let first = &args[0];
         let second = &args[1];
 
@@ -83,6 +83,7 @@ mod tests {
         assert_eq!(result, true);
     }
 
+    #[test]
     fn type_mismatch_string_number() {
         let mut parser = Statement::new().unwrap();
         let result = parser.parse_and_execute("[lessOrEquals('5', 3)]", &Context::new());

dsc_lib/src/functions/less.rs

@@ -34,7 +34,7 @@ impl Function for LessOrEquals {
 
     fn invoke(&self, args: &[Value], _context: &Context) -> Result<Value, DscError> {
         debug!("{}", t!("functions.lessOrEquals.invoked"));
-        
+
         let first = &args[0];
         let second = &args[1];
 
@@ -83,6 +83,7 @@ mod tests {
         assert_eq!(result, true);
     }
 
+    #[test]
     fn type_mismatch_string_number() {
         let mut parser = Statement::new().unwrap();
         let result = parser.parse_and_execute("[lessOrEquals('5', 3)]", &Context::new());